Global

A selection of colors and text effects for console output.

• browser: Terminal colors for the browser console See https://stackoverflow.com/q/7505623/544779

• node.js: ANSI terminal codes to turn on certain font effects See https://stackoverflow.com/q/4842424/544779

This object provides human-readable names for constants used in ObjectGraphIteratorOptions. The object-graph-iterator has these three options how to treat ID hash links.

• It can iterate over the ID object itself
• It can find the latest version for the ID hash and continue iteration with the object the hash points to.
• It can find all versions for the ID hash and continue iteration with all the object the hashes points to.
• It can ignore ID references altogether

The actual numeric values of the ID_LINK_ITERATION enum (object).

Enum for the various reference hash types that can occur in a ONE object. They directly correspond to the reference types in module object-find-link's LinkedObjectsHashList

Create a random nonce that can be used for all functions in this file.

Create a random symmetric key.

Create a new public/secret keypair.

Create a suitable salt for the key derivation function in deriveSymmetricKeyFromSecret.

Ensure that it is a public key by comparing the length of the data.

Note that we cannot really check that it is a public key, we can just check that the single requirement is met - the length. If the length is right we cast it to the right type.

Ensure that it is a secret key by comparing the length of the data.

Note that we cannot really check that it is a secret key, we can just check that the single requirement is met - the length. If the length is right we cast it to the right type.

Ensure that it is a public key by comparing the length of the data.

Note that we cannot really check that it is a public key, we can just check that the single requirement is met - the length. If the length is right we cast it to the right type.

Ensure that it is a nonce by comparing the length of the data.

Note that we cannot really check that it is a nonce, we can just check that the single requirement is met - the length. If the length is right we cast it to the right type.

Ensure that it is a suitable salt by ensuring that it is longer than a safe threshold.

Note that we cannot really check that it is a salt, we can just check that the single requirement is met - the length. If the length is right we cast it to the right type.

Derive a symmetric key pair from the public key of somebody else and your own private key.

Derive a symmetric key from a password.

Encrypt data with a symmetric key.

Encrypt data and store the nonce along the cypher in the result.

Storing the nonce along the cypher has the advantage, that you don't have to remember the nonce for decryption later.

Decrypt encrypted data.

Decrypt encrypted data.

Since the nonce is embedded in the cypher there is no need to specify it.

Encrypt data with a symmetric key derived from a public key of someone else and my own secret key.

When you have two key pairs 'myKeypair' and 'otherKeypair', then the symmetric key used for encryption will be the same for (myKeypair.secretKey, otherKeyPair.publicKey) and (myKeypair.publicKey, otherKeyPair.secretKey). That's how two communication partners can encrypt / decrypt the same steam, because they can derive the same symmetric key, without having the same secret key.

Encrypt data and store the nonce along the cypher in the result.

Storing the nonce along the cypher has the advantage, that you don't have to remember the nonce for decryption later.

Decrypt encrypted data.

Decrypt encrypted data.

Since the nonce is embedded in the cypher there is no need to specify it.

Create a new public/secret keypair for signing.

Ensure that it is a secret sign key by comparing the length of the data.

Note that we cannot really check that it is a secret key, we can just check that the single requirement is met - the length. If the length is right we cast it to the right type.

Ensure that it is a public sign key by comparing the length of the data.

Note that we cannot really check that it is a public key, we can just check that the single requirement is met - the length. If the length is right we cast it to the right type.

Sign data.

Verify a signature.

Stores the public part of the keys.

Get the public keys from the Keys object.

Store the passed key pairs in the key storage.

The public keys will be stores as 'Keys' object, the secret keys will be stored in the 'private' section of the OneDb.

Create a new random set of keys for the specified owner.

Get the person encryption and sign key-pairs.

Unlock the keychain.

This will derive a key from the secret and store the master key in memory.

Lock the keychain.

The master key is purged from memory and all other keychain functions won't work anymore.

Changes the secret used to unlock the keychain.

Create a crypto functions for a person or instance.

Get a list of all keys associated with this owner.

Note: Incomplete keys are not trustworthy. The Keys object could have been sent from anyone.

Get incomplete keys associated with a person.

Incomplete means, that you do not possess secret keys for this keys object.

Note: The keys are not trustworthy. The Keys object could have been sent from anyone.

Get a list of complete keys associated with a person.

Note: You can trust complete keys, because the secret part can only be written by yourself.

Get the person keys for which we have the secret part (hence complete)

Returns whether we have a complete keypair for a person.

'Complete' means that we have public and secret keys.

Create new default encryption and sign key pairs for a person.

If a default keypair already exists, this function will fail. At the moment this is to ensure, that we only have a single private key for a person (will change in the future - but makes things easier right now).

Same as createDefaultKeys() but skip if default keys already exist.

There are two Access objects that are identical in structure and purpose except for in name: 'Access' points to immutable graphs.

Example

Javascript representation:

const obj = {
    $type$: 'Access',
    object: hash,
    person: [personIdHash]
};

HTML microdata representation:

<div itemscope itemtype="//refin.io/Access">
  <a itemprop="object" href="${hash}">${hash}</a>
  <a itemprop="person" href="${personIdHash}">${personIdHash}</a>
</span>

Options object for Chum importer function chum-base.sendAccessibleObjectsEventsRequest

Return value of promises passed through Promise.allSettled The status is 'fulfilled' and there is value with the value the promise resolved with, or the status is 'rejected' and there is a reason with the value of the promise's rejection, usually an Error object.

The possible string constant values of Promise.allSettled results. It is made available as export from util/promise to avoid inline repetition of these constants.

A union type of versioned and unversioned object creation result objects, for any ONE object type.

This object is part of ValueType and describes the value-type of an Array Object.

An API-object interface to a Map<K, V[]> object created by util/function.createArrayValueMap (also see the description there) whose values are arrays of values of type <V>. Provides a function to add values to the array identified by a given key. The purpose is to serve as an accumulator of values under a set of keys, with 1...n values per key (0 values means no entry, i.e. no key, there is no key with no value).

This is a virtual type representing BLOB files. It is used as a generic parameter type for SHA256Hash and SHA256IdHash.

This object is part of ValueType and describes the value-type of a Bag Object. A "bag" is a data-structure that implements a multiset, which is a set that allows multiple (duplicates). In the microdata the sequence of items is ordered by ONE.

This object is part of ValueType and describes the value-type of a Boolean.

This is a virtual type representing CLOB (UTF-8 text) files. It is used as a generic parameter type for SHA256Hash and SHA256IdHash.

A Chum object defines a filter for exchanging data with other instances. Initially it only filters by persons.

Example

<div itemscope itemtype="//refin.io/Chum">
  <span itemprop="name">ThisChumsName</span>
  <span itemprop="instance">${name1}</span>
  <span itemprop="instance">${name2}</span>
  <span itemprop="person">${hash1}</span>
  <span itemprop="person">${hash2}</span>
  <span itemprop="highestRemoteTimestamp">${timestamp1}</span>
  ...
</span>

The chum-exporter may send event notifications of this type to the chum-importer through the websocket connection.

This is a TypeScript helper type that extracts the type of the elements of certain container types. If the container is read-only and its elements are known this results in a union type of those elements.

Examples:

const set = new Set(['a', 'b', 'c'] as const);
// "a" | "b" | "c"
type SSS = ElementType<typeof set>;

const arr = ['aa', 'bb', 'cc'] as const;
// // "aa" | "bb" | "cc"
type AAA = ElementType<typeof arr>;

const map = new Map([['a', 1], ['b', 2], ['c', 42]] as const);
// 1 | 2 | 42
type MMM = ElementType<typeof map>;

Event handler callback functions

The union of all event types that the chum-exporter can send to the chum-importer.

This event is sent when the chum-exporter has iterated through all accessible objects found in the initial full scan. It is mostly useful for non-ending keepRunning:true chums, although if the receiving importer's ONE instance still is not done with its own chum-exporter task of sending accessible objects this event still appears before the chum exchange is over. When both sides' chum-exporter sent this event a full-sync chum without keepRunning:true will be over.

Return result object of creating CLOB and BLOB file objects.

This defines the creation status string constants for files such as ONE microdata files, CLOBs and BLOBs. This overlaps with the status for unversioned ONE objects because those are simple text files for the low-level storage API that does not deal with ONE objects but simple with "files" in the most general sense.

To check a status don't use the string constants directly (they could be changed!). Use storage module's exported CREATION_STATUS enum (static frozen object) with the properties NEW and EXISTS.

Usage

Instead of using these strings directly please use the storage-base-common.CREATION_STATUS export of

import {StorageBaseCommon} from 'storage-base-common');

// StorageBaseCommon.CREATION_STATUS.NEW
// StorageBaseCommon.CREATION_STATUS.EXISTS

Access objects link to Group objects to grant access rights.

Example

Javascript representation:

const obj = {
    $type$: 'Group',
    name: name,
    person: [Person1-idHash, Person2-idHash]
};

HTML microdata representation:

<span itemprop="item" itemscope itemtype="//refin.io/Group">
  <span itemprop="name">${name}</span>
  <span itemprop="person">${Person1-ID-hash}</span>
  <span itemprop="person">${Person2-ID-hash}</span>
</span>

The union of all "name" property values of all Recipes used by one.core and the application plus 'BLOB' for binary objects and 'CLOB' for UTF-8 objects.

This type represents a hexadecimal string.

This hexadecimal string is expected to have an even number of elements, so that it can be converted to binary representation: Two hexadecimal bytes result in one byte in binary representation.

Note that this is a type that cannot be constructed, just cast to. This is a Typescript trick to have a special kind of string.

Same as Access object but instead of a reference to a concrete object it has a reference to an ID object of a versioned object and grants access to all current and future versions of the object.

Return result object of creating ID objects with function storeIdObject(obj: OneVersionedObjectTypes | OneIdObjectTypes).

Options for the initStorage function in module system/storage-base. The function is called by initInstance.

An Instance object describes one instance of the app. Multiple instances can co-exist on one, and even in the same disk space. Both instances would share the same directory and much of their respective data.

The encryption key pair is generated by TweetNaCl.js and is stored in two Base 64 encoded strings:

• Base 64 character set: https://tools.ietf.org/html/rfc4648#section-4
• Base 64 length: https://stackoverflow.com/q/13378815/544779
• TweetNaCl length is n=32 bytes
• Base 64 encoded length: Math.ceil(4 * n/3) => 43, plus trailing "=" padding character for a total length of 44 characters.

Example

Javascript representation:

const obj = {
    $type$: 'Instance',
    name: 'InstanceName',
    owner: personIdHash,
    publicKey: blobHash,
    secretKey: blobHash,
    module: [moduleHash]
};

HTML microdata representation:

<div itemscope itemtype="//refin.io/Instance">
  <div itemscope="name">InstanceName</span>
  <span itemprop="owner">${personIdHash}</span>
  <span itemprop="publicKey">${publicKey}</span>
  <a itemprop="module" href="${moduleHash}">${module1-hash}</a>
</span>

Options object for instance-updater, which updates the currently active instance.

This object is part of ValueType and describes the value-type of an Integer.

This object stores the public encryption and sign keys for a given Instance or Person ID. The secret keys are stored in a special non-shared private storage area.

This type is for an object that lists the collected links of one or more ONE objects, separated into ONE object references (versioned, unversioned or ID-references) and BLOB or CLOB links (only a hash, links to files that are not ONE microdata objects).

The way this type is used the lists may include all or only a subset of the links found in a ONE object. All links are present in the lists returned by findLinkedHashesInObject, the Chum-sync modules using this type list only those links that had to be transferred from the remote instance.

Note that if a hash is referenced more than once it will also be included in the array for its type more than once. We decided not to filter duplicates because that would mean hiding information (how many links to the same hash there are).

This type is for an object that lists the collected links of one or more ONE objects, separated into ONE object references (versioned, unversioned or ID-references) and BLOB or CLOB links (only a hash, links to files that are not ONE microdata objects).

The way this type is used the lists may include all or only a subset of the links found in a ONE object. All links are present in the lists returned by findLinkedHashesInObject, the Chum-sync modules using this type list only those links that had to be transferred from the remote instance.

Note that if a hash is referenced more than once it will also be included in the array for its type more than once. We decided not to filter duplicates because that would mean hiding information (how many links to the same hash there are).

Implementation of an LRU collection with a given maximum size. Internally it uses a Map object and uses the fact that that object's iterator uses insertion order. Each time a key is accessed - get or set - it is removed and reinserted. That means that at the beginning of the Map iterator there will always be the least recently used item. See util/lru-map

This object is part of ValueType and describes the value-type of a Map Object.

An API-object that provides several functions bound to a context established by the function that created the API-object.

Example

// Result is a MessageBusObj
import {create} from './message-bus';
const MessageBus = create('some-id-string');

Example

Javascript representation:

const obj = {
    $type$: 'Module',
    name: '@module/imap-mailbox-handler',
    version: '1.0',
    requires: [
        '@module/imap-promisifier.js',
        '@one/message-bus.js',
        '@one/storage.js'
    ],
    code: clobHash
};

HTML microdata representation:

<div itemscope itemtype="//refin.io/Module">
  <span itemprop="name">@module/imap-mailbox-handler</span>
  <span itemprop="version">1.0</span>
  <span itemprop="requires">@module/imap-promisifier.js</span>
  <span itemprop="requires">lib/message-bus.js</span>
  <span itemprop="requires">lib/storage.js</span>
  <span itemprop="code">${CLOB-hash}</span>
</span>

The function returned by calling the NeverFailAsyncErrorWrapper function returned by util/function.createNeverFailAsyncErrorWrapper. For an in-depth explanation see util/function.createNeverFailAsyncErrorWrapper

The function returned by util/function.createNeverFailAsyncErrorWrapper For an in-depth explanation see util/function.createNeverFailAsyncErrorWrapper

This object is part of ValueType and describes the value-type of a Number.

This object is part of ValueType and describes the value-type of an ONE Object.

Object type created by the util/event-source.createEventSource method.

Object with functions for the intended consumer of events. This object is part of the OneEventSource object type created by the util/event-source.createEventSource method.

A meta-type defined in one.core/@OneObjectInterfaces.d.ts in module namespace "@OneObjectInterfaces" that can be extended through TypeScript's declaration merging feature to include ONE object definitions defined through recipes of the application.

In order to add your own project's ID ONE object types create similar .d.ts file, declare a module namespace @OneObjectInterfaces and export an interface declaration for OneIdObjectInterfaces just as in the one.core file. If you tell tsc (TypeScript server) via your tsconfig.json to include both one.core's and your own definition files it will merge the declarations into one.

This interface contains the names (as keys) and TypeScript interface types (as values) of all ID objects. Unless you need to refer to the ID object types by name it probably is best to use TypeScript's built-in Pick<T, K> helper to pick the ID object properties from the full versioned object types. Usually only the latter will have named interfaces. If necessary, in .ts code files you can always refer to ID object interfaces using OneIdObjectInterfaces[TypeId], where TypeId is the appropriate string key. For key names one.core follows the rule to take the name of the versioned object type and append, for example, 'Id'.

Note that ID object interfaces are special and must be used explicitly, they are not part in any of the unions or merged definitions of ONE object types. Except for in rare places ID object types are not to be permitted even when the respective versioned object types are, because the ID object types may miss properties that are not ID properties but still non-optional. ID objects are only used to calculate ID hashes and never written, nor should they be used for processing.

That is why the name (key) you choose for the ID object type may be arbitrary, it is not used as type name. Only the values are used, i.e. the ID object declarations.

This key/value interface still is necessary, the declarations cannot just be written directly to OneIdObjectTypes: Declaration merging of ID object types declared for the application requires this key/value structure.

This union is obtained by extracting all values from OneIdObjectInterfaces.

Defined in one.core's @OneObjectInterfaces.d.ts file, this is the result of merging the declarations of OneUnversionedObjectInterfaces, OneVersionedObjectInterfaces.

This is a key/value map object where the keys are all valid ONE object type names, and the values are the interface type (i.e. ONE object) definitions.

ID object interface definitions are not included in this map because except for in rare places ID object types are not to be permitted even when the respective versioned object types are, because the ID object types may miss properties that are not ID properties but still non-optional. ID objects are only used to calculate ID hashes and never written, nor should they be used for processing.

The union of all "name" property values of all Recipes used by one.core and the application. The type is created as union of OneUnversionedObjectTypeNames and OneVersionedObjectTypeNames.

The union of all interfaces of ONE object types used by one.core and the application. The type is created as union of OneUnversionedObjectTypes and OneVersionedObjectTypes.

A meta-type defined in one.core/[src|lib]/@OneObjectInterfaces.d.ts in module namespace "@OneObjectInterfaces" that can be extended through TypeScript's declaration merging feature to include ONE object definitions defined through recipes of the application.

In order to add your own project's unversioned ONE object types create similar .d.ts file, declare a module namespace @OneObjectInterfaces and export an interface declaration for OneUnversionedObjectInterfaces just as in the one.core file. If you tell tsc (TypeScript server) via your tsconfig.json to include both one.core's and your own definition files it will merge the declarations into one.

To extend this structure have a look at file one.core/@OneObjectInterfaces.d.ts and do what was one there to add ONE object types defined for the one.core tests for your own application types.

This interface contains the names (as keys) and TypeScript interface types (as values) of all unversioned objects.

Important: The string keys for each entry must be exactly the ONE object type name as used in the "name" property of the recipe for that type.

This union is obtained by extracting all keys from OneUnversionedObjectInterfaces.

This union is obtained by extracting all values from OneUnversionedObjectInterfaces.

A meta-type defined in one.core/@OneObjectInterfaces.d.ts in module namespace "@OneObjectInterfaces" that can be extended through TypeScript's declaration merging feature to include ONE object definitions defined through recipes of the application.

In order to add your own project's versioned ONE object types create similar .d.ts file, declare a module namespace @OneObjectInterfaces and export an interface declaration for OneVersionedObjectInterfaces just as in the one.core file. If you tell tsc (TypeScript server) via your tsconfig.json to include both one.core's and your own definition files it will merge the declarations into one.

This interface contains the names (as keys) and TypeScript interface types (as values) of all versioned objects.

Important: The string keys for each entry must be exactly the ONE object type name as used in the "name" property of the recipe for that type.

This union is obtained by extracting all keys from OneVersionedObjectInterfaces.

This union is obtained by extracting all values from OneVersionedObjectInterfaces.

This type is used in the ONE microdata parsing modules, first of all in microdata-to-object.

It is used to store the last value that a particular parser sub-function successfully parsed (if any) as well as the position in the microdata string up to which parsing has advanced.

Programming style notes:

The context object makes the parse functions impure, since the parsing position is stored on the outside. The reason is that we wanted to avoid a complex return type for the parse functions: The parsed value plus the position would both have to be returned, which means an object or array-object (tuple) would have to be created to box the return values. As an optimization, to save on object creations (especially with embedded platform JS runtimes in mind), we create an external object which gets passed into the parse functions as a pointer and whose position property is mutated.

Most people would make the whole parser a class and use this as the context object. We chose to be explicit throughout one.core, which avoids this binding issues if an individual parsing function is to be used standalone (since we export a number of those individual partial parser functions that parse only a small section).

Example

Javascript representation:

const obj = {
    $type$: 'Person',
    email: 'members@gmx.net',
    name: 'Foo Test'
};

HTML microdata representation:

<div itemscope itemtype="//refin.io/Person">
  <span itemprop="email">members@gmx.net</span>
</span>

The array of rules determines the properties of the ONE object and their order (in the written microdata representation).

Example

Javascript representation:

const obj = {
    $type$: 'Recipe',
    name: ONE-object-type-name,
    version: 1,
    rule: [
        {
            itemprop: property1-name
            isId: true
            valueType: 'number'
        },
        {
            itemprop: property2-name,
            regexp: /^[\w]*+$/
        },
        {
            itemprop: property3-name
            valueType: 'map'
        },
        {
            itemprop: property4-name
            referenceToObj: new Set(['*'])
        }
    ]
};

HTML microdata representation:

<div itemscope itemtype="//refin.io/Recipe">
  <span itemprop="name">${ONE-object-type-name}</span>
  <span itemprop="rule">
    <span itemprop="itemprop">${property1-name}</span>
    <span itemprop="isId">true</span>
    <span itemprop="valueType">number</span>
  </span>
  <span itemprop="rule">
    <span itemprop="itemprop">${property2-name}</span>
  </span>
  <span itemprop="rule">
    <span itemprop="itemprop">${property3-name}</span>
    <span itemprop="valueType">Map</span>
  </span>
  <span itemprop="rule">
    <span itemprop="itemprop">${property4-name}</span>
    <span itemprop="referenceToObj">['*']</span>
  </span>
</span>

This object is part of Recipe but has an extra type because the rule objects appear on their own in parts of the code, where those rules are given to functions to process parts of ONE objects.

NOTE: If this type is updated don't forget to also update function ensureRecipeRule() in <PROJECT_HOME>/src/util/recipe-checks.js

This object is part of ValueType and describes the value-type of a SHA256Hash of a BLOB.

This object is part of ValueType and describes the value-type of a SHA256Hash of a CLOB.

This object is part of ValueType and describes the value-type of a SHA256IdHash of an object.

This object is part of ValueType and describes the value-type of a SHA256Hash of an object.

The function returned by calling the RethrowingAsyncErrorWrapper function returned by util/function.createRethrowingAsyncErrorWrapper. For an in-depth explanation see util/function.createRethrowingAsyncErrorWrapper

The function returned by util/function.createRethrowingAsyncErrorWrapper For an in-depth explanation see util/function.createRethrowingAsyncErrorWrapper

Important note (from @sebastian). I decided to keep exclude 'list' even if we don't have the list field anymore in RecipeRule. It will remove 'array','bag' or 'set' field in the RecipeRule.itemtype and keep only the item type.

The recipe-rule property "inheritFrom" can be either a string (common inheritance) or an object (inheritance with additional options). This is the type of the object in the latter case.

(Simulated) opaque type name alias for strings that are SHA-256 hashes pointing to concrete objects.

This type has a generic parameter: A member or a union of OneObjectTypes as well as the virtual types BLOB and CLOB.

This generic parameter is used by and passed through all major one.core functions' type definitions. For example, after storing an object the hashes in the object creation result object will be tagged with the typed of the object.

(Simulated) opaque type name alias for strings that are SHA-256 hashes pointing to ID objects, i.e. to all past, present and future versions of a versioned object.

This type has a generic parameter: A member or a union of OneObjectTypes as well as the virtual types BLOB and CLOB.

An enum to be used when calling the access.module:ts access module to set access rights and create IdAccess or Access ONE objects.

An array of SetAccessParam objects is expected by the "Lib/access" module.

This object is part of ValueType and describes the value-type of a Set Object.

The settings store is a key-value store used to store instance settings that cannot or should not be stored in the usual ONE storage places. The browser implementation uses localStorage and the node.js version stores a file with the settings ina JSON.stringified object in the "private" storage space.

SystemReadStream objects are created by factory function system/storage-streams.createFileReadStream.

This type has a generic parameter for the encoding setting: undefined | 'utf8' | 'base64'. Depending on the encoding the ondData function yields string or ArrayBuffer data.

It provides a platform independent interface to streams: filesystem streams on node.js, RNFetchBlob on React Native, and a custom minimal implementation on browsers.

The event system is modeled after the one found for IndexedDB and for WebSockets, among others: You simply assign a function to the appropriately named property on the SimpleReadStream object.

SimpleWriteStream objects are created by factory function storage-streams.createFileWriteStream.

This type has a generic parameter for the encoding setting: undefined | 'utf8' | 'base64'. Depending on the encoding the write function expects (only) string or ArrayBuffer data.

It provides a platform independent interface to streams: filesystem streams on node.js, RNFetchBlob on React Native, and a custom minimal implementation on browsers.

Instead of events for "error" and "finish" there is a promise, which allows for easier integration with promise based code in general and async/await based code in particular.

Style

This write-stream object assumes two different kinds of clients:

• A single instance of code that actually uses and manages the stream

• An arbitrary number of instances of code not involved with the stream but interested in its final result.

The active code gets functions to control the stream.

Passively involved code gets a promise that will resolve or reject when the final result of the stream becomes available. That promise does not control any of the code used to run the stream, it is only used to communicate the official result.

The code actually using the stream would have no use for a promise though: Streams and promises are fundamentally different in their aims. The code that does end up using the promise, however, a promise is the perfect abstraction - it only wants to know the final result.

A StopIteratorError is a type of Error with a fixed name property string value. You can stop the object graph iteration without the iterator promise rejecting by throwing an Error whose name property is "StopIteratorError" from within the callback function. Any other error causes the iterator promise to reject with that error.

Note that this is not a special class, i.e. you cannot use instanceof. The object is created by decorating a given Error object. To check for this error check the "name" property!

One of these fixed strings: 'objects' | 'tmp' | rmaps | vmaps | 'acache', 'private'

See module chum-exporter-storage-monitor.

This object is part of ValueType and describes the value-type of a String.

Function helper util/function.throttleWithFixedDelay returns a function to cancel a timer and prevent queued delayed execution of a throttled function, and the throttled function wrapper function itself.

See util/promise.createTrackingPromise

The type returned by SET operation(s) for ONE objects written without version history mechanism. Exactly one file is created. This type is only used for write operations because read operations of objects directly return the object.

ONE microdata object properties can store one of these types:

• NumberValue
• BooleanValue
• StringifiableValue
• ReferenceToObjValue
• ReferenceToIdValue
• ReferenceToClobValue
• ReferenceToBlobValue
• MapValue
• BagValue
• ArrayValue
• SetValue
• ObjectValue;

Conversion from and to the types is performed upon writing and reading ONE microdata objects:

When reading microdata and creating a Javascript object representation of the ONE object the strings will be converted to these types if the respective rule for the item has type information. By default, everything remains a string.

Result of listing all versions of a versioned ONE object. The version map that describes all versions of a ONE object contains the millisecond timestamp of when the version map was updated, and the hash of the actual object. Using the position index you can then ask for a particular version of the versioned ONE object.

These are the internal values for the enum VERSION_UPDATES defined in and exported by storage-base-common. Never use the numeric values, always use the symbols in VERSION_UPDATES exported by module storage-base-common and re-exported by the public storage API module storage.

The type returned by write operation(s) for versioned ONE objects as well as by getObjectByIdHash and getObjectByIdObject. This is similar to UnversionedObjectResult except that it also includes the idHash property which identifies all versions of a versioned object as well as the timestamp written into the version map.

This type is included in Chum objects as well as used internally. The numbers are without network overhead. The number of sent requests always includes the connect request, so after communication finished both parties will have sent one more request than they themselves received, since the connect request is to the communication server!