@soundworks/core 4.0.0-alpha.28 → 4.0.0-alpha.29

package/types/common/BaseStateManager.d.ts

@@ -1,135 +1,245 @@
+export const kStateManagerInit: unique symbol;
+export const kStateManagerDeleteState: unique symbol;
+export const kStateManagerClient: unique symbol;
 export default BaseStateManager;
+/**
+ * Callback executed when a state is created on the network.
+ */
+export type stateManagerObserveCallback = () => any;
+/**
+ * Callback to execute in order to remove a {@link stateManagerObserveCallback }
+ * from the list of observer.
+ */
+export type stateManagerDeleteObserveCallback = () => any;
+/**
+ * Callback executed when a state is created on the network.
+ *
+ * @callback stateManagerObserveCallback
+ * @async
+ * @param {string} schemaName - name of the schema
+ * @param {number} stateId - id of the state
+ * @param {number} nodeId - id of the node that created the state
+ */
+/**
+ * Callback to execute in order to remove a {@link stateManagerObserveCallback}
+ * from the list of observer.
+ *
+ * @callback stateManagerDeleteObserveCallback
+ */
 /** @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 states.
-     *  Must implement a basic EventEmitter API.
-     */
-    /** @private */
-    private init;
-    client: {
-        id: any;
-        transport: BatchedTransport;
-    };
-    /** @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)
+     * @return {SharedStateSchema}
      * @example
-     * const schema = await client.stateManager.getSchema('my-schema');
+     * const schema = await client.stateManager.getSchema('my-class');
      */
-    getSchema(schemaName: string): Promise<any>;
+    getSchema(schemaName: string): SharedStateSchema;
     /**
-     * Create a `SharedState` instance from a registered schema.
+     * Create a {@link SharedState} instance from a registered schema.
      *
-     * @param {String} schemaName - Name of the schema as given on registration
+     * @param {string} schemaName - Name of the schema as given on registration
      *  (cf. ServerStateManager)
-     * @param {Object} [initValues={}] - Default values for the state.
-     * @returns {client.SharedState|server.SharedState}
-     * @see {@link client.SharedState}
-     * @see {@link server.SharedState}
+     * @param {Object.<string, any>} [initValues={}] - Default values for the state.
+     * @returns {Promise<SharedState>}
      * @example
-     * const state = await client.stateManager.create('my-schema');
+     * const state = await client.stateManager.create('my-class');
      */
-    create(schemaName: string, initValues?: any): client.SharedState | server.SharedState;
+    create(schemaName: string, initValues?: {
+        [x: string]: any;
+    }): Promise<SharedState>;
     /**
-     * Attach to an existing `SharedState` instance.
+     * Attach to an existing {@link SharedState} instance.
      *
-     * Alternative signatures:
-     * - `stateManager.attach(schemaName)`
-     * - `stateManager.attach(schemaName, stateId)`
-     * - `stateManager.attach(schemaName, filter)`
-     * - `stateManager.attach(schemaName, stateId, filter)`
+     * @overload
+     * @param {string} schemaName
+     * @returns {Promise<SharedState>}
      *
-     * @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-class');
+     */
+    attach(schemaName: string): Promise<SharedState>;
+    /**
+     * Attach to an existing {@link SharedState} instance.
+     *
+     * @overload
+     * @param {string} schemaName - Name of the schema
+     * @param {number} stateId - Id of the state
+     * @returns {Promise<SharedState>}
      *
      * @example
-     * const state = await client.stateManager.attach('my-schema');
+     * const state = await client.stateManager.attach('my-class', stateId);
      */
-    attach(schemaName: string, stateIdOrFilter?: any, filter?: any[] | null, ...args: any[]): client.SharedState | server.SharedState;
+    attach(schemaName: string, stateId: number): Promise<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.
-     *
-     * 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.
-     * @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.
+     * Attach to an existing {@link SharedState} instance.
+     *
+     * @overload
+     * @param {string} schemaName - Name of the schema
+     * @param {string[]} filter - List of parameters of interest
+     * @returns {Promise<SharedState>}
      *
      * @example
+     * const state = await client.stateManager.attach('my-class', ['some-param']);
+     */
+    attach(schemaName: string, filter: string[]): Promise<SharedState>;
+    /**
+     * Attach to an existing {@link SharedState} instance.
+     *
+     * @overload
+     * @param {string} schemaName - Name of the schema
+     * @param {number} stateId - Id of the state
+     * @param {string[]} filter - List of parameters of interest
+     * @returns {Promise<SharedState>}
+     *
+     * @example
+     * const state = await client.stateManager.attach('my-class', stateId, ['some-param']);
+     */
+    attach(schemaName: string, stateId: number, filter: string[]): Promise<SharedState>;
+    /**
+     * Observe all the {@link SharedState} instances that are created on the network.
+     *
+     * @overload
+     * @param {stateManagerObserveCallback} callback - Function to execute when a
+     *   new {@link SharedState} is created on the network.
+     * @example
      * client.stateManager.observe(async (schemaName, stateId) => {
-     *   if (schemaName === 'something') {
-     *     const state = await this.client.stateManager.attach(schemaName, stateId);
-     *     console.log(state.getValues());
+     *   if (schemaName === 'my-shared-state-class') {
+     *     const attached = await client.stateManager.attach(schemaName, stateId);
      *   }
      * });
      */
-    observe(...args: any[]): Promise<Function>;
+    observe(callback: stateManagerObserveCallback): any;
+    /**
+     * Observe all the {@link SharedState} instances of given {@link SharedStateClassName}
+     * that are created on the network.
+     *
+     * @overload
+     * @param {SharedStateClassName} schemaName - Observe only ${@link SharedState}
+     *   of given name.
+     * @param {stateManagerObserveCallback} callback - Function to execute when a
+     *   new {@link SharedState} is created on the network.
+     * @example
+     * client.stateManager.observe('my-shared-state-class', async (schemaName, stateId) => {
+     *   const attached = await client.stateManager.attach(schemaName, stateId);
+     * });
+     */
+    observe(schemaName: SharedStateClassName, callback: stateManagerObserveCallback): any;
+    /**
+     * Observe all the {@link SharedState} instances of given excluding the ones
+     * created by the current node.
+     *
+     * @overload
+     * @param {stateManagerObserveCallback} callback - Function to execute when a
+     *   new {@link SharedState} is created on the network.
+     * @param {object} options - Options.
+     * @param {boolean} options.excludeLocal=false - If set to true, exclude states
+     *   created by the same node from the collection.
+     * @example
+     * client.stateManager.observe(async (schemaName, stateId) => {
+     *   if (schemaName === 'my-shared-state-class') {
+     *     const attached = await client.stateManager.attach(schemaName, stateId);
+     *   }
+     * }, { excludeLocal: true });
+     */
+    observe(callback: stateManagerObserveCallback, options: {
+        excludeLocal: boolean;
+    }): any;
+    /**
+     * Observe all the {@link SharedState} instances of given {@link SharedStateClassName}
+     * that are created on the network, excluding the ones created by the current node.
+     *
+     * @overload
+     * @param {SharedStateClassName} schemaName - Observe only ${@link SharedState}
+     *   of given name.
+     * @param {stateManagerObserveCallback} callback - Function to execute when a
+     *   new {@link SharedState} is created on the network.
+     * @param {object} options - Options.
+     * @param {boolean} options.excludeLocal=false - If set to true, exclude states
+     *   created by the same node from the collection.
+     * @example
+     * client.stateManager.observe('my-shared-state-class', async (schemaName, stateId) => {
+     *   const attached = await client.stateManager.attach(schemaName, stateId);
+     * }, { excludeLocal: true });
+     */
+    observe(schemaName: SharedStateClassName, callback: stateManagerObserveCallback, options: {
+        excludeLocal: boolean;
+    }): any;
+    /**
+     * Returns a collection of all the states created from the schema name.
+     *
+     * @overload
+     * @param {string} schemaName - Name of the schema.
+     * @returns {Promise<SharedStateCollection>}
+     *
+     * @example
+     * const collection = await client.stateManager.getCollection(schemaName);
+     */
+    getCollection(schemaName: string): Promise<SharedStateCollection>;
+    /**
+     * Returns a collection of all the states created from the schema name.
+     *
+     * @overload
+     * @param {string} schemaName - Name of the schema.
+     * @param {SharedStateParameterName[]} filter - Filter parameter of interest for each
+     *  state of the collection.
+     * @returns {Promise<SharedStateCollection>}
+     *
+     * @example
+     * const collection = await client.stateManager.getCollection(schemaName, ['my-param']);
+     */
+    getCollection(schemaName: string, filter: SharedStateParameterName[]): Promise<SharedStateCollection>;
     /**
      * 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)`
+     * @overload
+     * @param {string} schemaName - Name of the schema.
+     * @param {object} options - Options.
+     * @param {boolean} options.excludeLocal=false - If set to true, exclude states
+     *  created by the same node from the collection.
+     * @returns {Promise<SharedStateCollection>}
+     *
+     * @example
+     * const collection = await client.stateManager.getCollection(schemaName, { excludeLocal: true });
+     */
+    getCollection(schemaName: string, options: {
+        excludeLocal: boolean;
+    }): Promise<SharedStateCollection>;
+    /**
+     * Returns a collection of all the states created from the schema name.
      *
+     * @overload
      * @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
+     * @param {SharedStateParameterName[]} filter - Filter parameter of interest for each
+     *  state of the collection.
+     * @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}
+     * @returns {Promise<SharedStateCollection>}
      *
      * @example
-     * const collection = await client.stateManager.getCollection(schemaName);
+     * const collection = await client.stateManager.getCollection(schemaName, ['my-param'], { excludeLocal: true });
      */
-    getCollection(schemaName: string, filterOrOptions?: any, options?: {
-        excludeLocal?: boolean;
-    }, ...args: any[]): server.SharedStateCollection | client.SharedStateCollection;
+    getCollection(schemaName: string, filter: SharedStateParameterName[], options: {
+        excludeLocal: boolean;
+    }): Promise<SharedStateCollection>;
+    /** @private */
+    private [kStateManagerDeleteState];
+    /**
+     * Executed on `client.init`
+     * @param {Number} id - Id of the node.
+     * @param {Object} transport - Transport to use for synchronizing the states.
+     *  Must implement a basic EventEmitter API.
+     *
+     * @private
+     */
+    private [kStateManagerInit];
+    /** @private */
+    private [kStateManagerClient];
+    #private;
 }
-import PromiseStore from './PromiseStore.js';
-import BatchedTransport from './BatchedTransport.js';
-//# sourceMappingURL=BaseStateManager.d.ts.map
+import SharedState from './SharedState.js';
+import SharedStateCollection from './SharedStateCollection.js';

package/types/common/BatchedTransport.d.ts

@@ -9,13 +9,9 @@ export default BatchedTransport;
  */
 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;
+    #private;
 }
-//# sourceMappingURL=BatchedTransport.d.ts.map

package/types/common/ParameterBag.d.ts

@@ -1,27 +1,29 @@
 export namespace sharedOptions {
     let nullable: boolean;
     let event: boolean;
+    let required: boolean;
     let metas: {};
     let filterChange: boolean;
     let immediate: boolean;
 }
 export namespace types {
     export namespace boolean {
-        let required: string[];
-        const defaultOptions: any;
-        function coerceFunction(name: any, def: any, value: any): boolean;
-    }
-    export namespace string {
         let required_1: string[];
         export { required_1 as required };
+        export const defaultOptions: any;
+        export function coerceFunction(name: any, def: any, value: any): boolean;
+    }
+    export namespace string {
+        let required_2: string[];
+        export { required_2 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 {
-        let required_2: string[];
-        export { required_2 as required };
+        let required_3: string[];
+        export { required_3 as required };
         const defaultOptions_2: any;
         export { defaultOptions_2 as defaultOptions };
         export function sanitizeSchema(def: any): any;
@@ -29,8 +31,8 @@ export namespace types {
         export { coerceFunction_2 as coerceFunction };
     }
     export namespace float {
-        let required_3: string[];
-        export { required_3 as required };
+        let required_4: string[];
+        export { required_4 as required };
         const defaultOptions_3: any;
         export { defaultOptions_3 as defaultOptions };
         export function sanitizeSchema_1(def: any): any;
@@ -39,8 +41,8 @@ export namespace types {
         export { coerceFunction_3 as coerceFunction };
     }
     export namespace _enum {
-        let required_4: string[];
-        export { required_4 as required };
+        let required_5: string[];
+        export { required_5 as required };
         const defaultOptions_4: any;
         export { defaultOptions_4 as defaultOptions };
         export function coerceFunction_4(name: any, def: any, value: any): any;
@@ -48,8 +50,8 @@ export namespace types {
     }
     export { _enum as enum };
     export namespace any {
-        let required_5: string[];
-        export { required_5 as required };
+        let required_6: string[];
+        export { required_6 as required };
         const defaultOptions_5: any;
         export { defaultOptions_5 as defaultOptions };
         export function coerceFunction_5(name: any, def: any, value: any): any;
@@ -57,10 +59,7 @@ export namespace types {
     }
 }
 export default ParameterBag;
-/**
- * Bag of parameters.
- * @private
- */
+/** @private */
 declare class ParameterBag {
     static validateSchema(schema: any): void;
     constructor(schema: any, initValues?: {});
@@ -161,4 +160,3 @@ declare class ParameterBag {
     getInitValues(): {};
     getDefaults(): {};
 }
-//# sourceMappingURL=ParameterBag.d.ts.map

package/types/common/PromiseStore.d.ts

@@ -1,3 +1,4 @@
+/** @private */
 export default class PromiseStore {
     constructor(name: any);
     name: any;
@@ -8,4 +9,3 @@ export default class PromiseStore {
     reject(reqId: any, msg: any): void;
     flush(): void;
 }
-//# sourceMappingURL=PromiseStore.d.ts.map