@soundworks/core 4.0.0-alpha.21 → 4.0.0-alpha.23

package/types/common/BaseSharedStateCollection.d.ts

@@ -0,0 +1,183 @@
+export default BaseSharedStateCollection;
+/** @private */
+declare class BaseSharedStateCollection {
+    constructor(stateManager: any, schemaName: any, filter?: any, options?: {});
+    _stateManager: any;
+    _schemaName: any;
+    _filter: any;
+    _options: {
+        excludeLocal: boolean;
+    };
+    _schema: any;
+    _states: any[];
+    _onUpdateCallbacks: Set<any>;
+    _onAttachCallbacks: Set<any>;
+    _onDetachCallbacks: Set<any>;
+    _unobserve: any;
+    /** @private */
+    private _init;
+    /**
+     * Size of the collection, alias `size`
+     * @type {number}
+     * @readonly
+     */
+    readonly get length(): number;
+    /**
+     * Size of the collection, , alias `length`
+     * @type {number}
+     * @readonly
+     */
+    readonly get size(): number;
+    /**
+     * Name of the schema from which the collection has been created.
+     * @type {String}
+     * @readonly
+     */
+    readonly get schemaName(): string;
+    /**
+     * Definition of schema from which the collection has been created.
+     *
+     * @param {string} [name=null] - If given, returns only the definition
+     *  corresponding to the given param name.
+     * @throws Throws if `name` does not correspond to an existing field
+     *  of the schema.
+     * @return {object}
+     * @example
+     * const schema = collection.getSchema();
+     */
+    getSchema(name?: string): object;
+    /**
+     * Get the default values as declared in the schema.
+     *
+     * @return {object}
+     * @example
+     * const defaults = state.getDefaults();
+     */
+    getDefaults(): object;
+    /**
+     * Return the current values of all the states in the collection.
+     * @return {Object[]}
+     */
+    getValues(): any[];
+    /**
+     * Return the current values of all the states in the collection.
+     *
+     * Similar to `getValues` but returns a reference to the underlying value in
+     * case of `any` type. May be usefull if the underlying value is big (e.g.
+     * sensors recordings, etc.) and deep cloning expensive. Be aware that if
+     * changes are made on the returned object, the state of your application will
+     * become inconsistent.
+     *
+     * @return {Object[]}
+     */
+    getValuesUnsafe(): any[];
+    /**
+     * Return the current param value of all the states in the collection.
+     *
+     * @param {String} name - Name of the parameter
+     * @return {any[]}
+     */
+    get(name: string): any[];
+    /**
+     * Similar to `get` but returns a reference to the underlying value in case of
+     * `any` type. May be usefull if the underlying value is big (e.g. sensors
+     * recordings, etc.) and deep cloning expensive. Be aware that if changes are
+     * made on the returned object, the state of your application will become
+     * inconsistent.
+     *
+     * @param {String} name - Name of the parameter
+     * @return {any[]}
+     */
+    getUnsafe(name: string): any[];
+    /**
+     * Update all states of the collection with given values.
+     * @param {object} updates - key / value pairs of updates to apply to the state.
+     * @param {mixed} [context=null] - optionnal contextual object that will be propagated
+     *   alongside the updates of the state. The context is valid only for the
+     *   current call and will be passed as third argument to all update listeners.
+     */
+    set(updates: object, context?: mixed): Promise<any[]>;
+    /**
+     * Subscribe to any state update of the collection.
+     *
+     * @param {server.SharedStateCollection~onUpdateCallback|client.SharedStateCollection~onUpdateCallback}
+     *  callback - Callback to execute when an update is applied on a state.
+     * @param {Boolean} [executeListener=false] - Execute the callback immediately
+     *  for all underlying states with current state values. (`oldValues` will be
+     *  set to `{}`, and `context` to `null`)
+     * @returns {Function} - Function that delete the registered listener.
+     */
+    onUpdate(callback: any, executeListener?: boolean): Function;
+    /**
+     * Register a function to execute when a state is added to the collection.
+     *
+     * @param {Function} callback - callback to execute  when a state is added to
+     *   the collection.
+     * @param {Function} executeListener - execute the callback with the states
+     *   already present in the collection.
+     * @returns {Function} - Function that delete the registered listener.
+     */
+    onAttach(callback: Function, executeListener?: Function): Function;
+    /**
+     * Register a function to execute when a state is removed from the collection.
+     *
+     * @param {Function} callback - callback to execute  when a state is removed
+     *   from the collection.
+     * @returns {Function} - Function that delete the registered listener.
+     */
+    onDetach(callback: Function): Function;
+    /**
+     * Detach from the collection, i.e. detach all underlying shared states.
+     * @type {number}
+     */
+    detach(): Promise<void>;
+    /**
+     * Execute the given function once for each states of the collection (see `Array.forEach`).
+     *
+     * @param {Function} func - A function to execute for each element in the array.
+     *  Its return value is discarded.
+     */
+    forEach(func: Function): void;
+    /**
+     * Creates a new array populated with the results of calling a provided function
+     * on every state of the collection (see `Array.map`).
+     *
+     * @param {Function} func - A function to execute for each element in the array.
+     *  Its return value is added as a single element in the new array.
+     */
+    map(func: Function): any[];
+    /**
+     * Creates a shallow copy of a portion of the collection, filtered down to just
+     * the estates that pass the test implemented by the provided function (see `Array.filter`).
+     *
+     * @param {Function} func - A function to execute for each element in the array.
+     *  It should return a truthy to keep the element in the resulting array, and a f
+     *  alsy value otherwise.
+     */
+    filter(func: Function): any[];
+    /**
+     * Sort the elements of the collection in place (see `Array.sort`).
+     *
+     * @param {Function} func - Function that defines the sort order.
+     */
+    sort(func: Function): void;
+    /**
+     * Returns the first element of the collection that satisfies the provided testing
+     * function. If no values satisfy the testing function, undefined is returned.
+     *
+     * @param {Function} func - Function to execute for each element in the array.
+     *  It should return a truthy value to indicate a matching element has been found.
+     * @return {}
+     */
+    find(func: Function): any;
+    /**
+     * Iterable API, e.g. for use in `for .. of` loops
+     */
+    [Symbol.iterator](): {
+        next: () => {
+            value: any;
+            done: boolean;
+        };
+    };
+}
+//# sourceMappingURL=BaseSharedStateCollection.d.ts.map

package/types/common/BaseSharedStateCollection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseSharedStateCollection.d.ts","sourceRoot":"","sources":["../../src/common/BaseSharedStateCollection.js"],"names":[],"mappings":";AAAA,eAAe;AACf;IACE,4EAaC;IAZC,mBAAiC;IACjC,iBAA6B;IAC7B,aAAqB;IACrB;;MAA+D;IAE/D,aAAmB;IACnB,eAAiB;IAEjB,6BAAmC;IACnC,6BAAmC;IACnC,6BAAmC;IACnC,gBAAsB;IAGxB,eAAe;IACf,cAiCC;IAED;;;;OAIG;IACH,8BAEC;IAED;;;;OAIG;IACH,4BAEC;IAED;;;;OAIG;IACH,kCAEC;IAED;;;;;;;;;;OAUG;IACH,iBARW,MAAM,GAIL,MAAM,CAUjB;IAED;;;;;;OAMG;IACH,eAJY,MAAM,CAUjB;IAED;;;OAGG;IACH,aAFY,KAAQ,CAInB;IAED;;;;;;;;;;OAUG;IACH,mBAFY,KAAQ,CAInB;IAED;;;;;OAKG;IACH,mBAFY,GAAG,EAAE,CAMhB;IAED;;;;;;;;;OASG;IACH,yBAFY,GAAG,EAAE,CAMhB;IAED;;;;;;OAMG;IACH,aALW,MAAM,mCAUhB;IAED;;;;;;;;;OASG;IACH,6DAcC;IAED;;;;;;;;OAQG;IACH,mEAQC;IAED;;;;;;OAMG;IACH,uCAIC;IAED;;;OAGG;IACH,wBAQC;IAED;;;;;OAKG;IACH,8BAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,8BAEC;IAED;;;;OAIG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,0BAEC;IAED;;OAEG;IACH;;;;;MAYC;CACF"}

package/types/common/BaseStateManager.d.ts

@@ -1,22 +1,34 @@
 export default BaseStateManager;
-/**
- * @private
- */
+/** @private */
 declare class BaseStateManager {
+    _statesById: Map<any, any>;
+    _cachedSchemas: Map<any, any>;
+    _observeListeners: Set<any>;
+    _observeRequestCallbacks: Map<any, any>;
+    _promiseStore: PromiseStore;
     /**
+     * Executed on `client.init`
      * @param {Number} id - Id of the node.
-     * @param {Object} transport - Transport to use for synchronizing the state.
+     * @param {Object} transport - Transport to use for synchronizing the states.
      *  Must implement a basic EventEmitter API.
      */
-    constructor(id: number, transport: any);
+    /** @private */
+    private init;
     client: {
-        id: number;
-        transport: any;
+        id: any;
+        transport: BatchedTransport;
     };
-    _statesById: Map<any, any>;
-    _observeListeners: Set<any>;
-    _cachedSchemas: Map<any, any>;
-    _observeRequestCallbacks: Map<any, any>;
+    /** @private */
+    private _filterObserve;
+    /**
+     * Return the schema from a given registered schema name
+     *
+     * @param {String} schemaName - Name of the schema as given on registration
+     *  (cf. ServerStateManager)
+     * @example
+     * const schema = await client.stateManager.getSchema('my-schema');
+     */
+    getSchema(schemaName: string): Promise<any>;
     /**
      * Create a `SharedState` instance from a registered schema.
      *
@@ -33,38 +45,91 @@ declare class BaseStateManager {
     /**
      * Attach to an existing `SharedState` instance.
      *
+     * Alternative signatures:
+     * - `stateManager.attach(schemaName)`
+     * - `stateManager.attach(schemaName, stateId)`
+     * - `stateManager.attach(schemaName, filter)`
+     * - `stateManager.attach(schemaName, stateId, filter)`
+     *
      * @param {String} schemaName - Name of the schema as given on registration
      *  (cf. ServerStateManager)
      * @param {Object} [stateId=null] - Id of the state to attach to. If `null`,
      *  attach to the first state found with the given schema name (usefull for
      *  globally shared states owned by the server).
+     * @param {array|null} [filter=null] - Filter parameters of interest in the
+     *  returned state. If set to `null`, no filter applied.
      * @returns {client.SharedState|server.SharedState}
      * @see {@link client.SharedState}
      * @see {@link server.SharedState}
+     *
      * @example
      * const state = await client.stateManager.attach('my-schema');
      */
-    attach(schemaName: string, stateId?: any): client.SharedState | server.SharedState;
+    attach(schemaName: string, stateIdOrFilter?: any, filter?: any[] | null, ...args: any[]): client.SharedState | server.SharedState;
     /**
      * Observe all the `SharedState` instances that are created on the network.
      * This can be usefull for clients with some controller role that might want to track
      * the state of all other clients of the application, to monitor them and/or take
      * control over them from a single point.
      *
-     * @todo Optionnal schema name
+     * Notes:
+     * - The order of execution is not guaranted between nodes, i.e. an state attached
+     * in the `observe` callback could be created before the `async create` method resolves.
+     * - Filtering, i.e. `observedSchemaName` and `options.excludeLocal` are handled
+     * on the node side, the server just notify all state creation activity and
+     * the node executes the given callbacks according to the different filter rules.
+     * Such strategy allows to share the observe notifications between all observers.
+     *
+     * Alternative signatures:
+     * - `stateManager.observe(callback)`
+     * - `stateManager.observe(schemaName, callback)`
+     * - `stateManager.observe(callback, options)`
+     * - `stateManager.observe(schemaName, callback, options)`
+     *
+     * @param {string} [schemaName] - optionnal schema name to filter the observed
+     *  states.
      * @param {server.StateManager~ObserveCallback|client.StateManager~ObserveCallback}
      *  callback - Function to be called when a new state is created on the network.
-     * @returns {Promise<Function>} - Return a Promise that resolves when the callback
-     *  as been executed for the first time. The promise value is a function which
-     *  allows to stop observing the network.
+     * @param {object} options - Options.
+     * @param {boolean} [options.excludeLocal = false] - If set to true, exclude states
+     *  created locallly, i.e. by the same node, from the collection.
+     * @returns {Promise<Function>} - Returns a Promise that resolves when the given
+     *  callback as been executed on each existing states. The promise value is a
+     *  function which allows to stop observing the states on the network.
+     *
      * @example
-     * client.stateManager.observe(async (schemaName, stateId, nodeId) => {
+     * client.stateManager.observe(async (schemaName, stateId) => {
      *   if (schemaName === 'something') {
      *     const state = await this.client.stateManager.attach(schemaName, stateId);
      *     console.log(state.getValues());
      *   }
      * });
      */
-    observe(callback: any): Promise<Function>;
+    observe(...args: any[]): Promise<Function>;
+    /**
+     * Returns a collection of all the states created from the schema name.
+     *
+     * Alternitive signatures:
+     * - `stateManager.getCollection(schemaName)`
+     * - `stateManager.getCollection(schemaName, filter)`
+     * - `stateManager.getCollection(schemaName, options)`
+     * - `stateManager.getCollection(schemaName, filter, options)`
+     *
+     * @param {string} schemaName - Name of the schema.
+     * @param {array|null} [filter=null] - Filter parameter of interest for each
+     *  state of the collection. If set to `null`, no filter applied.
+     * @param {object} [options={}] - Options.
+     * @param {boolean} [options.excludeLocal=false] - If set to true, exclude states
+     *  created by the same node from the collection.
+     * @returns {server.SharedStateCollection|client.SharedStateCollection}
+     *
+     * @example
+     * const collection = await client.stateManager.getCollection(schemaName);
+     */
+    getCollection(schemaName: string, filterOrOptions?: any, options?: {
+        excludeLocal?: boolean;
+    }, ...args: any[]): server.SharedStateCollection | client.SharedStateCollection;
 }
+import PromiseStore from './PromiseStore.js';
+import BatchedTransport from './BatchedTransport.js';
 //# sourceMappingURL=BaseStateManager.d.ts.map

package/types/common/BaseStateManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BaseStateManager.d.ts","sourceRoot":"","sources":["../../src/common/BaseStateManager.js"],"names":[],"mappings":";AAoBA;;GAEG;AACH;IACE;;;;OAIG;IACH,wCA4FC;IA3FC;;;MAA+B;IAE/B,2BAA4B;IAC5B,4BAAkC;IAClC,8BAA+B;IAC/B,wCAAyC;IAwF3C;;;;;;;;;;;OAWG;IACH,8CANa,uCAAqC,CAYjD;IAED;;;;;;;;;;;;;OAaG;IACH,2CANa,uCAAqC,CAajD;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,wBAXa,iBAAiB,CAoB7B;CACF"}
+{"version":3,"file":"BaseStateManager.d.ts","sourceRoot":"","sources":["../../src/common/BaseStateManager.js"],"names":[],"mappings":";AAwBA,eAAe;AACf;IAEI,2BAA4B;IAC5B,8BAA+B;IAE/B,4BAAkC;IAClC,wCAAyC;IAEzC,4BAAuC;IAGzC;;;;;OAKG;IACH,eAAe;IACf,aAgIC;IA9HC;;;MAAiD;IAgInD,eAAe;IACf,uBAYC;IAED;;;;;;;OAOG;IACH,4CAYC;IAED;;;;;;;;;;;OAWG;IACH,8CANa,uCAAqC,CAYjD;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,2DATW,QAAM,IAAI,mBAER,uCAAqC,CA8CjD;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IAIH,yBAfa,iBAAiB,CAsH7B;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,0BAXW,MAAM;QAIY,YAAY,GAA9B,OAAO;wBAEL,2DAAyD,CA2CrE;CACF;yBA/ewB,mBAAmB;6BAFf,uBAAuB"}

package/types/common/BatchedTransport.d.ts

@@ -0,0 +1,21 @@
+export default BatchedTransport;
+/**
+ * This class proxies transports given the SharedStateManager to batch messages
+ *
+ * @param {number} [options.wait=0] - Wait for given number of milliseconds
+ *  for stacking messages before emitting on the network. If 0 is given, network
+ *  message is emitted on next microtask
+ * @private
+ */
+declare class BatchedTransport {
+    constructor(transport: any);
+    _transport: any;
+    _listeners: Map<any, any>;
+    _stack: any[];
+    _sending: boolean;
+    addListener(channel: any, callback: any): void;
+    emit(channel: any, ...args: any[]): Promise<void>;
+    removeListener(channel: any, callback: any): void;
+    removeAllListeners(channel?: any): void;
+}
+//# sourceMappingURL=BatchedTransport.d.ts.map

package/types/common/BatchedTransport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BatchedTransport.d.ts","sourceRoot":"","sources":["../../src/common/BatchedTransport.js"],"names":[],"mappings":";AAIA;;;;;;;GAOG;AACH;IACE,4BAkBC;IAjBC,gBAA2B;IAC3B,0BAA2B;IAC3B,cAAgB;IAChB,kBAAqB;IAgBvB,+CAOC;IAED,kDAWC;IAED,kDAKC;IAED,wCAOC;CACF"}

package/types/common/ParameterBag.d.ts

@@ -1,69 +1,62 @@
 export namespace sharedOptions {
-    const nullable: boolean;
-    const event: boolean;
-    const metas: {};
-    const filterChange: boolean;
-    const immediate: boolean;
+    let nullable: boolean;
+    let event: boolean;
+    let metas: {};
+    let filterChange: boolean;
+    let immediate: boolean;
 }
 export namespace types {
     export namespace boolean {
-        const required: string[];
+        let required: string[];
+        const defaultOptions: any;
         function coerceFunction(name: any, def: any, value: any): boolean;
     }
     export namespace string {
-        const required_1: string[];
+        let required_1: string[];
         export { required_1 as required };
+        const defaultOptions_1: any;
+        export { defaultOptions_1 as defaultOptions };
         export function coerceFunction_1(name: any, def: any, value: any): string;
         export { coerceFunction_1 as coerceFunction };
     }
     export namespace integer {
-        const required_2: string[];
+        let required_2: string[];
         export { required_2 as required };
+        const defaultOptions_2: any;
+        export { defaultOptions_2 as defaultOptions };
         export function sanitizeSchema(def: any): any;
         export function coerceFunction_2(name: any, def: any, value: any): number;
         export { coerceFunction_2 as coerceFunction };
     }
     export namespace float {
-        const required_3: string[];
+        let required_3: string[];
         export { required_3 as required };
+        const defaultOptions_3: any;
+        export { defaultOptions_3 as defaultOptions };
         export function sanitizeSchema_1(def: any): any;
         export { sanitizeSchema_1 as sanitizeSchema };
         export function coerceFunction_3(name: any, def: any, value: any): number;
         export { coerceFunction_3 as coerceFunction };
     }
     export namespace _enum {
-        const required_4: string[];
+        let required_4: string[];
         export { required_4 as required };
+        const defaultOptions_4: any;
+        export { defaultOptions_4 as defaultOptions };
         export function coerceFunction_4(name: any, def: any, value: any): any;
         export { coerceFunction_4 as coerceFunction };
     }
     export { _enum as enum };
     export namespace any {
-        const required_5: string[];
+        let required_5: string[];
         export { required_5 as required };
+        const defaultOptions_5: any;
+        export { defaultOptions_5 as defaultOptions };
         export function coerceFunction_5(name: any, def: any, value: any): any;
         export { coerceFunction_5 as coerceFunction };
     }
 }
 export default ParameterBag;
-export namespace server {
-    /**
-     * ~schema
-     *
-     * Description of a schema to be register by the {@link server.ServerStateManagerServer }
-     * A schema consists of a combinaison of key value pairs where the key is the
-     * name of the parameter, and the value is an object describing the parameter.
-     *
-     * Available types are:
-     * - {@link server.SharedStateManagerServer ~schemaBooleanDef}
-     * - {@link server.SharedStateManagerServer ~schemaStringDef}
-     * - {@link server.SharedStateManagerServer ~schemaIntegerDef}
-     * - {@link server.SharedStateManagerServer ~schemaFloatDef}
-     * - {@link server.SharedStateManagerServer ~schemaEnumDef}
-     * - {@link server.SharedStateManagerServer ~schemaAnyDef}
-     */
-    type SharedStateManagerServer = any;
-}
 /**
  * Bag of parameters.
  * @private
@@ -94,33 +87,61 @@ declare class ParameterBag {
     /**
      * Define if the parameter exists.
      *
-     * @param {String} name - Name of the parameter.
+     * @param {string} name - Name of the parameter.
      * @return {Boolean}
      */
     has(name: string): boolean;
     /**
-     * Return values of all parameters as a flat object.
+     * Return values of all parameters as a flat object. If a parameter is of `any`
+     * type, a deep copy is made.
      *
-     * @return {Object}
+     * @return {object}
      */
-    getValues(): any;
+    getValues(): object;
+    /**
+     * Return values of all parameters as a flat object. Similar to `getValues` but
+     * returns a reference to the underlying value in case of `any` type. May be
+     * usefull if the underlying value is big (e.g. sensors recordings, etc.) and
+     * deep cloning expensive. Be aware that if changes are made on the returned
+     * object, the state of your application will become inconsistent.
+     *
+     * @return {object}
+     */
+    getValuesUnsafe(): object;
     /**
      * Return the value of the given parameter. If the parameter is of `any` type,
      * a deep copy is returned.
      *
-     * @param {String} name - Name of the parameter.
+     * @param {string} name - Name of the parameter.
      * @return {Mixed} - Value of the parameter.
      */
     get(name: string): Mixed;
+    /**
+     * Similar to `get` but returns a reference to the underlying value in case of
+     * `any` type. May be usefull if the underlying value is big (e.g. sensors
+     * recordings, etc.) and deep cloning expensive. Be aware that if changes are
+     * made on the returned object, the state of your application will become
+     * inconsistent.
+     *
+     * @param {string} name - Name of the parameter.
+     * @return {Mixed} - Value of the parameter.
+     */
+    getUnsafe(name: string): Mixed;
+    /**
+     * Check that the value is valid according to the schema and return it coerced
+     * to the schema definition
+     *
+     * @param {String} name - Name of the parameter.
+     * @param {Mixed} value - Value of the parameter.
+     */
+    coerceValue(name: string, value: Mixed): Mixed;
     /**
      * Set the value of a parameter. If the value of the parameter is updated
      * (aka if previous value is different from new value) all registered
      * callbacks are registered.
      *
-     * @param {String} name - Name of the parameter.
+     * @param {string} name - Name of the parameter.
      * @param {Mixed} value - Value of the parameter.
-     * @param {Boolean} [forcePropagation=false] - if true, propagate value even
-     *    if the value has not changed.
      * @return {Array} - [new value, updated flag].
      */
     set(name: string, value: Mixed): any[];
@@ -129,14 +150,14 @@ declare class ParameterBag {
      * @note - prefer `state.set(state.getInitValues())`
      *         or     `state.set(state.getDefaultValues())`
      *
-     * @param {String} [name=null] - Name of the parameter to reset.
+     * @param {string} [name=null] - Name of the parameter to reset.
      */
     /**
      * Return the given schema along with the initialization values.
      *
-     * @return {Object}
+     * @return {object}
      */
-    getSchema(name?: any): any;
+    getSchema(name?: any): object;
     getInitValues(): {};
     getDefaults(): {};
 }

package/types/common/ParameterBag.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParameterBag.d.ts","sourceRoot":"","sources":["../../src/common/ParameterBag.js"],"names":[],"mappings":";;;;;;;;;;QA8MoB,kEAMf;;;;;QAOe,0EAMf;;;;;;QAUe,8CAgBf;QACe,0EAMf;;;;;;QAUe,gDAgBf;;QACe,0EAMf;;;;;;QAOe,uEAOf;;;;;;;QAOe,uEAGf;;;;;;;;;;;;;;;;;;;;;;;AAKL;;;GAGG;AACH;IACE,yCAsBC;IAED,0CAsEC;IA9DC;;;;;;;;OAQG;IACH,gBAAiB;IAEjB;;;;;;;;OAQG;IACH,gBAAiB;IA4CnB;;;;;OAKG;IACH,2BAEC;IAED;;;;OAIG;IACH,iBAQC;IAED;;;;;;OAMG;IACH,yBAUC;IAED;;;;;;;;;;OAUG;IACH,uCAuBC;IAED;;;;;;OAMG;IAWH;;;;OAIG;IACH,2BAUC;IAGD,oBAMC;IAGD,kBAMC;CACF"}
+{"version":3,"file":"ParameterBag.d.ts","sourceRoot":"","sources":["../../src/common/ParameterBag.js"],"names":[],"mappings":";;;;;;;;;;;QAiBoB,kEAMf;;;;;;;QAOe,0EAMf;;;;;;;;QAUe,8CAgBf;QACe,0EAMf;;;;;;;;QAUe,gDAgBf;;QACe,0EAMf;;;;;;;;QAOe,uEAOf;;;;;;;;;QAOe,uEAGf;;;;;AAKL;;;GAGG;AACH;IACE,yCAsBC;IAED,0CAqEC;IA7DC;;;;;;;;OAQG;IACH,gBAAiB;IAEjB;;;;;;;;OAQG;IACH,gBAAiB;IA2CnB;;;;;OAKG;IACH,UAHW,MAAM,WAKhB;IAED;;;;;OAKG;IACH,aAFY,MAAM,CAUjB;IAED;;;;;;;;OAQG;IACH,mBAFY,MAAM,CAUjB;IAED;;;;;;OAMG;IACH,UAHW,MAAM,SAehB;IAED;;;;;;;;;OASG;IACH,gBAHW,MAAM,SAShB;IAED;;;;;;OAMG;IACH,+CAiBC;IAED;;;;;;;;OAQG;IACH,UAJW,MAAM,uBAsBhB;IAED;;;;;;OAMG;IAWH;;;;OAIG;IACH,uBAFY,MAAM,CAYjB;IAGD,oBAQC;IAGD,kBAQC;CACF"}

package/types/common/PromiseStore.d.ts

@@ -0,0 +1,11 @@
+export default class PromiseStore {
+    constructor(name: any);
+    name: any;
+    store: Map<any, any>;
+    generateRequestId: any;
+    add(resolve: any, reject: any, type: any, localParams: any): any;
+    resolve(reqId: any, data: any): void;
+    reject(reqId: any, msg: any): void;
+    flush(): void;
+}
+//# sourceMappingURL=PromiseStore.d.ts.map

package/types/common/PromiseStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PromiseStore.d.ts","sourceRoot":"","sources":["../../src/common/PromiseStore.js"],"names":[],"mappings":"AAEA;IACE,uBAIC;IAHC,UAAgB;IAChB,qBAAsB;IACtB,uBAAsC;IAGxC,iEAKC;IAED,qCAcC;IAED,mCASC;IAGD,cAOC;CACF"}

package/types/common/SharedStatePrivate.d.ts

@@ -1,7 +1,8 @@
 export default SharedStatePrivate;
 /**
  * The "real" state, this instance is kept private by the server.StateManager.
- * It cannot be accessed without a SharedState proxy
+ * It can only be accessed through a SharedState proxy.
+ *
  * @private
  */
 declare class SharedStatePrivate {
@@ -13,8 +14,8 @@ declare class SharedStatePrivate {
     _attachedClients: Map<any, any>;
     _creatorRemoteId: any;
     _creatorId: any;
-    _attachClient(remoteId: any, client: any, isOwner?: boolean): void;
+    _attachClient(remoteId: any, client: any, isOwner: any, filter: any): void;
     _detachClient(remoteId: any, client: any): void;
 }
-import ParameterBag from "../common/ParameterBag.js";
+import ParameterBag from '../common/ParameterBag.js';
 //# sourceMappingURL=SharedStatePrivate.d.ts.map

package/types/common/SharedStatePrivate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SharedStatePrivate.d.ts","sourceRoot":"","sources":["../../src/common/SharedStatePrivate.js"],"names":[],"mappings":";AAaA;;;;GAIG;AACH;IACE,kFAUC;IATC,QAAY;IACZ,gBAA4B;IAE5B,cAAuB;IACvB,0BAAuD;IACvD,gCAAiC;IAEjC,sBAA4B;IAC5B,gBAAsB;IAGxB,mEAmJC;IAED,gDAMC;CACF"}
+{"version":3,"file":"SharedStatePrivate.d.ts","sourceRoot":"","sources":["../../src/common/SharedStatePrivate.js"],"names":[],"mappings":";AAgCA;;;;;GAKG;AACH;IACE,kFAUC;IATC,QAAY;IACZ,gBAA4B;IAE5B,cAAuB;IACvB,0BAAuD;IACvD,gCAAiC;IAEjC,sBAA4B;IAC5B,gBAAsB;IAGxB,2EAwKC;IAED,gDAMC;CACF;yBApOwB,2BAA2B"}

package/types/common/constants.d.ts

@@ -1,4 +1,9 @@
 export const SERVER_ID: -1;
+export const PING_INTERVAL: number;
+export const PING_LATENCY_TOLERANCE: 1000;
+export const PING_MESSAGE: "h:ping";
+export const PONG_MESSAGE: "h:pong";
+export const BATCHED_TRANSPORT_CHANNEL: "b:t";
 export const CREATE_REQUEST: "s:c:req";
 export const CREATE_RESPONSE: "s:c:res";
 export const CREATE_ERROR: "s:c:err";
@@ -14,6 +19,7 @@ export const DETACH_RESPONSE: "s:dt:res";
 export const DETACH_ERROR: "s:dt:err";
 export const OBSERVE_REQUEST: "s:o:req";
 export const OBSERVE_RESPONSE: "s:o:res";
+export const OBSERVE_ERROR: "s:o:err";
 export const OBSERVE_NOTIFICATION: "s:o:not";
 export const UNOBSERVE_NOTIFICATION: "s:uo:not";
 export const UPDATE_REQUEST: "s:u:req";
@@ -21,6 +27,9 @@ export const UPDATE_RESPONSE: "s:u:res";
 export const UPDATE_ABORT: "s:u:ab";
 export const UPDATE_NOTIFICATION: "s:u:not";
 export const DELETE_SCHEMA: "s:d:s";
+export const GET_SCHEMA_REQUEST: "s:s:req";
+export const GET_SCHEMA_RESPONSE: "s:s:res";
+export const GET_SCHEMA_ERROR: "s:s:err";
 export const CONTEXT_ENTER_REQUEST: "c:en:req";
 export const CONTEXT_ENTER_RESPONSE: "c:en:res";
 export const CONTEXT_ENTER_ERROR: "c:en:err";
@@ -30,6 +39,6 @@ export const CONTEXT_EXIT_ERROR: "c:ex:err";
 export const CLIENT_HANDSHAKE_REQUEST: "cl:h:req";
 export const CLIENT_HANDSHAKE_RESPONSE: "cl:h:res";
 export const CLIENT_HANDSHAKE_ERROR: "cl:h:err";
-export const AUDIT_STATE_NAME: "s:c:audit";
+export const AUDIT_STATE_NAME: "p:s:audit";
 export const PRIVATE_STATES: string[];
 //# sourceMappingURL=constants.d.ts.map

package/types/common/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/common/constants.js"],"names":[],"mappings":"AACA,2BAA4B;AAG5B,uCAAwC;AACxC,wCAAyC;AACzC,qCAAsC;AAEtC,wCAAyC;AACzC,yCAA0C;AAC1C,sCAAuC;AACvC,6CAA8C;AAE9C,uCAAwC;AACxC,wCAAyC;AACzC,qCAAsC;AAEtC,wCAAyC;AACzC,yCAA0C;AAC1C,sCAAuC;AAEvC,wCAAyC;AACzC,yCAA0C;AAC1C,6CAA8C;AAE9C,gDAAiD;AAEjD,uCAAwC;AACxC,wCAAyC;AACzC,oCAAqC;AACrC,4CAA6C;AAE7C,oCAAqC;AAGrC,+CAAgD;AAChD,gDAAiD;AACjD,6CAA8C;AAE9C,8CAA+C;AAC/C,+CAAgD;AAChD,4CAA6C;AAG7C,kDAAmD;AACnD,mDAAoD;AACpD,gDAAiD;AAGjD,2CAA4C;AAC5C,sCAAiD"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/common/constants.js"],"names":[],"mappings":"AACA,2BAA4B;AAE5B,mCAAuC;AACvC,0CAA2C;AAC3C,oCAAqC;AACrC,oCAAqC;AAGrC,8CAA+C;AAG/C,uCAAwC;AACxC,wCAAyC;AACzC,qCAAsC;AAEtC,wCAAyC;AACzC,yCAA0C;AAC1C,sCAAuC;AACvC,6CAA8C;AAE9C,uCAAwC;AACxC,wCAAyC;AACzC,qCAAsC;AAEtC,wCAAyC;AACzC,yCAA0C;AAC1C,sCAAuC;AAEvC,wCAAyC;AACzC,yCAA0C;AAC1C,sCAAuC;AACvC,6CAA8C;AAE9C,gDAAiD;AAEjD,uCAAwC;AACxC,wCAAyC;AACzC,oCAAqC;AACrC,4CAA6C;AAE7C,oCAAqC;AAErC,2CAA4C;AAC5C,4CAA6C;AAC7C,yCAA0C;AAG1C,+CAAgD;AAChD,gDAAiD;AACjD,6CAA8C;AAE9C,8CAA+C;AAC/C,+CAAgD;AAChD,4CAA6C;AAG7C,kDAAmD;AACnD,mDAAoD;AACpD,gDAAiD;AAGjD,2CAA4C;AAC5C,sCAAiD"}

package/types/common/logger.d.ts

@@ -1,6 +1,6 @@
 export default logger;
 declare namespace logger {
-    const verbose: boolean;
+    let verbose: boolean;
     function configure(verbose: any): void;
     function title(msg: any): void;
     function clientConfigAndRouting(routes: any, config: any): void;

package/types/common/sockets-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sockets-utils.d.ts","sourceRoot":"","sources":["../../src/common/sockets-utils.js"],"names":[],"mappings":"AAsBA,eAAe;AACf,4EAqBC;AAED,eAAe;AACf,wDAeC;AAED,eAAe;AACf,wEAEC;AAED,eAAe;AACf,oDAEC"}
+{"version":3,"file":"sockets-utils.d.ts","sourceRoot":"","sources":["../../src/common/sockets-utils.js"],"names":[],"mappings":"AAqBA,eAAe;AACf,4EAqBC;AAED,eAAe;AACf,wDAeC;AAED,eAAe;AACf,wEAEC;AAED,eAAe;AACf,oDAEC"}

package/types/common/version.d.ts

@@ -0,0 +1,3 @@
+declare const _default: "4.0.0-alpha.22";
+export default _default;
+//# sourceMappingURL=version.d.ts.map

package/types/common/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/common/version.js"],"names":[],"mappings":""}