@soundworks/core 5.6.0 → 5.8.0

package/src/server/SharedStatePrivate.js

@@ -24,7 +24,7 @@ import {
  * @private
  */
 function whiteListFilterUpdates(updates, whiteList) {
-  if (whiteList === null) {
+  if (!Array.isArray(whiteList)) {
     return updates;
   }
 
@@ -44,7 +44,7 @@ function whiteListFilterUpdates(updates, whiteList) {
  * @private
  */
 function blackListFilterUpdates(updates, blackList) {
-  if (blackList === null) {
+  if (!Array.isArray(blackList)) {
     return updates;
   }
   // create a shallow copy so we can have multiple filters applied on same source
@@ -59,6 +59,22 @@ function blackListFilterUpdates(updates, blackList) {
   return filtered;
 }
 
+function applyFilters(updates, options) {
+  if (options === null) {
+    return updates;
+  }
+
+  const { whiteList, blackList } = options;
+  // precedence to white list
+  if (Array.isArray(whiteList)) {
+    updates = whiteListFilterUpdates(updates, whiteList);
+  } else if (Array.isArray(blackList)) {
+    updates = blackListFilterUpdates(updates, blackList);
+  }
+
+  return updates;
+}
+
 export const kSharedStatePrivateAttachClient = Symbol('soundworks:shared-state-private-attach-client');
 export const kSharedStatePrivateDetachClient = Symbol('soundworks:shared-state-private-detach-client');
 export const kSharedStatePrivateGetValues = Symbol('soundworks:shared-state-private-get-values');
@@ -74,8 +90,7 @@ class SharedStatePrivate {
   #className = null;
   #manager = null;
   #parameters = null;
-  #creatorId = null;
-  #creatorInstanceId = null;
+  #ownerId = null;
   #attachedClients = new Map();
 
   constructor(manager, className, classDefinition, id, initValues = {}) {
@@ -94,12 +109,8 @@ class SharedStatePrivate {
     return this.#className;
   }
 
-  get creatorId() {
-    return this.#creatorId;
-  }
-
-  get creatorInstanceId() {
-    return this.#creatorInstanceId;
+  get ownerId() {
+    return this.#ownerId;
   }
 
   get attachedClients() {
@@ -114,21 +125,53 @@ class SharedStatePrivate {
     return this.#parameters.getValues();
   }
 
-  [kSharedStatePrivateAttachClient](instanceId, client, isOwner, filter) {
-    const clientInfos = { client, isOwner, filter };
+  [kSharedStatePrivateAttachClient](instanceId, client, isOwner, options) {
+    if (isOwner) {
+      this.#ownerId = client.id;
+    }
+
+    const clientInfos = { client, isOwner, options };
     this.#attachedClients.set(instanceId, clientInfos);
 
+    client.transport.addListener(`${UPDATE_REQUEST}-${this.id}-${instanceId}`, this.#onUpdateRequest(instanceId, client));
+
     if (isOwner) {
-      this.#creatorId = client.id;
-      this.#creatorInstanceId = instanceId;
+      client.transport.addListener(`${DELETE_REQUEST}-${this.id}-${instanceId}`, this.#onDeleteRequest);
+    } else {
+      client.transport.addListener(`${DETACH_REQUEST}-${this.id}-${instanceId}`, this.#onDetachRequest(instanceId, client));
+      this.#updateHasSiblings();
     }
+  }
+
+  [kSharedStatePrivateDetachClient](instanceId, client) {
+    this.#attachedClients.delete(instanceId);
+
+    client.transport.removeAllListeners(`${UPDATE_REQUEST}-${this.id}-${instanceId}`);
+    client.transport.removeAllListeners(`${DELETE_REQUEST}-${this.id}-${instanceId}`);
+    client.transport.removeAllListeners(`${DETACH_REQUEST}-${this.id}-${instanceId}`);
+
+    this.#updateHasSiblings();
+  }
+
+  /**
+   * Update hasSiblings property on owner
+   */
+  #updateHasSiblings() {
+    for (let [instanceId, clientInfos] of this.attachedClients) {
+      const { client, isOwner } = clientInfos;
 
-    // attach client listeners
-    client.transport.addListener(`${UPDATE_REQUEST}-${this.id}-${instanceId}`, async (reqId, updates) => {
-      // apply registered hooks
+      if (isOwner) {
+        const hasSiblings = this.attachedClients.size > 1;
+        client.transport.emit(`${HAS_SIBLINGS_NOTIFICATION}-${this.id}-${instanceId}`, hasSiblings);
+      }
+    }
+  }
+
+  #onUpdateRequest = (instanceId, client) => {
+    return async (reqId, updates) => {
       const hooks = this.#manager[kServerStateManagerGetUpdateHooks](this.className);
       const values = this.#parameters.getValues();
-      // make sur we don't propagate back to requester param that are marked as `acknowledge=false`
+      // Do not propagate back to the requester, params that are marked as `acknowledge=false`
       const acknowledgeFilter = this.#parameters.getParamListByDescriptor('acknowledge', false);
 
       let hookAborted = false;
@@ -186,8 +229,9 @@ class SharedStatePrivate {
           //
           // @note - instanceId correspond to unique remote state id
 
-          // - Apply acknowledge filter on `acknowledgedUpdates`
-          // - We don't need to apply the regular filter on update request, they are blocked client-side
+          // Apply acknowledge filter on `acknowledgedUpdates`
+          // Note that, We don't need to apply the whiteList / blackList filters
+          // for the requester, as they are blocked early on client-side
           const requesterFilteredUpdates = blackListFilterUpdates(acknowledgedUpdates, acknowledgeFilter);
 
           // propagate RESPONSE to the client that originates the request if not the server
@@ -204,11 +248,12 @@ class SharedStatePrivate {
 
           // propagate NOTIFICATION to all peer states except on server-side
           for (let [peerInstanceId, clientInfos] of this.#attachedClients) {
-            const { client: peer, filter } = clientInfos;
+            const { client: peer, options } = clientInfos;
 
             if (instanceId !== peerInstanceId && peer.id !== -1) {
-              const filteredUpdates = whiteListFilterUpdates(acknowledgedUpdates, filter);
-              // propagate only if there something left after applying the white list filter
+              const filteredUpdates = applyFilters(acknowledgedUpdates, options);
+
+              // propagate only if there something left after applying the whiteList/blackList filters
               if (Object.keys(filteredUpdates).length > 0) {
                 peer.transport.emit(
                   `${UPDATE_NOTIFICATION}-${this.id}-${peerInstanceId}`,
@@ -232,11 +277,12 @@ class SharedStatePrivate {
 
           // propagate NOTIFICATION to all peer states on the server-side
           for (let [peerInstanceId, clientInfos] of this.#attachedClients) {
-            const { client: peer, filter } = clientInfos;
+            const { client: peer, options } = clientInfos;
 
             if (instanceId !== peerInstanceId && peer.id === -1) {
-              const filteredUpdates = whiteListFilterUpdates(acknowledgedUpdates, filter);
-              // propagate only if there something left after applying the white list filter
+              const filteredUpdates = applyFilters(acknowledgedUpdates, options);
+
+              // propagate only if there something left after applying the whiteList/blackList filters
               if (Object.keys(filteredUpdates).length > 0) {
                 peer.transport.emit(
                   `${UPDATE_NOTIFICATION}-${this.id}-${peerInstanceId}`,
@@ -254,9 +300,9 @@ class SharedStatePrivate {
             client.transport.emit(`${UPDATE_ABORT}-${this.id}-${instanceId}`, reqId, requesterFilteredUpdates);
           }
         }
-      } else {
-        // @note - abort messages are only sent back to requester
-        // explicitly aborted by hook (return `null`), send back current values to requester
+      } else { // hookAborted === true
+        // when explicitly aborted by a hook (return `null`), we only send
+        // back the current values to the requester
         const currentValues = {};
 
         for (let name in updates) {
@@ -268,64 +314,36 @@ class SharedStatePrivate {
           client.transport.emit(`${UPDATE_ABORT}-${this.id}-${instanceId}`, reqId, requesterFilteredUpdates);
         }
       }
-    });
-
-    if (isOwner) {
-      // delete only if creator
-      client.transport.addListener(`${DELETE_REQUEST}-${this.id}-${instanceId}`, async reqId => {
-        // make sure hooks have been called when `delete()` fulfills
-        await this.#manager[kServerStateManagerDeletePrivateState](this);
-        // --------------------------------------------------------------------
-        // WARNING - MAKE SURE WE DON'T HAVE PROBLEM W/ THAT
-        // --------------------------------------------------------------------
-        // @todo - propagate server-side last, because if a subscription function sends a
-        // message to a client, network messages order are kept coherent
-        // this._subscriptions.forEach(func => func(updated));
-        for (let [instanceId, clientInfos] of this.#attachedClients) {
-          const attached = clientInfos.client;
-          this[kSharedStatePrivateDetachClient](instanceId, attached);
-
-          if (instanceId === this.#creatorInstanceId) {
-            attached.transport.emit(`${DELETE_RESPONSE}-${this.id}-${instanceId}`, reqId);
-          } else {
-            attached.transport.emit(`${DELETE_NOTIFICATION}-${this.id}-${instanceId}`);
-          }
-        }
-      });
-    } else {
-      // detach only if not creator
-      client.transport.addListener(`${DETACH_REQUEST}-${this.id}-${instanceId}`, (reqId) => {
-        this[kSharedStatePrivateDetachClient](instanceId, client);
-        client.transport.emit(`${DETACH_RESPONSE}-${this.id}-${instanceId}`, reqId);
-      });
-
-      this.#updateHasSiblings();
-    }
-  }
-
-  [kSharedStatePrivateDetachClient](instanceId, client) {
-    this.#attachedClients.delete(instanceId);
-    // delete listeners
-    client.transport.removeAllListeners(`${UPDATE_REQUEST}-${this.id}-${instanceId}`);
-    client.transport.removeAllListeners(`${DELETE_REQUEST}-${this.id}-${instanceId}`);
-    client.transport.removeAllListeners(`${DETACH_REQUEST}-${this.id}-${instanceId}`);
-
-    this.#updateHasSiblings();
-  }
-
-  /**
-   * Update hasSiblings property on owner
-   */
-  #updateHasSiblings() {
-    for (let [instanceId, clientInfos] of this.attachedClients) {
+    };
+  };
+
+  #onDeleteRequest = async reqId => {
+    // make sure hooks have been called when `delete()` fulfills
+    await this.#manager[kServerStateManagerDeletePrivateState](this);
+    // --------------------------------------------------------------------
+    // WARNING - MAKE SURE WE DON'T HAVE PROBLEM W/ THAT
+    // --------------------------------------------------------------------
+    // @todo - propagate server-side last, because if a subscription function sends a
+    // message to a client, network messages order are kept coherent
+    // this._subscriptions.forEach(func => func(updated));
+    for (let [instanceId, clientInfos] of this.#attachedClients) {
       const { client, isOwner } = clientInfos;
+      this[kSharedStatePrivateDetachClient](instanceId, client);
 
       if (isOwner) {
-        const hasSiblings = this.attachedClients.size > 1;
-        client.transport.emit(`${HAS_SIBLINGS_NOTIFICATION}-${this.id}-${instanceId}`, hasSiblings);
+        client.transport.emit(`${DELETE_RESPONSE}-${this.id}-${instanceId}`, reqId);
+      } else {
+        client.transport.emit(`${DELETE_NOTIFICATION}-${this.id}-${instanceId}`);
       }
     }
-  }
+  };
+
+  #onDetachRequest = (instanceId, client) => {
+    return reqId => {
+      this[kSharedStatePrivateDetachClient](instanceId, client);
+      client.transport.emit(`${DETACH_RESPONSE}-${this.id}-${instanceId}`, reqId);
+    };
+  };
 }
 
 export default SharedStatePrivate;

package/types/common/BaseStateManager.d.ts

@@ -1,5 +1,6 @@
 export const kStateManagerInit: unique symbol;
 export const kStateManagerDeleteState: unique symbol;
+export const kPendingSharedStateConstructionData: unique symbol;
 export const kStateManagerClient: unique symbol;
 export default BaseStateManager;
 /**
@@ -46,10 +47,6 @@ declare class BaseStateManager {
      * const classDescription = await client.stateManager.getClassDescription('my-class');
      */
     getClassDescription(className: SharedStateClassName): SharedStateClassDescription;
-    /**
-     * @deprecated Use {@link BaseStateManager#getClassDescription} instead.
-     */
-    getSchema(className: any): Promise<any>;
     /**
      * Create a {@link SharedState} instance from a registered class.
      *
@@ -90,26 +87,36 @@ declare class BaseStateManager {
      *
      * @overload
      * @param {SharedStateClassName} className - Name of the class.
-     * @param {string[]} filter - List of parameters of interest
+     * @param {Object} [options={}]
+     * @param {string[]} [options.whiteList] - White list of parameter names to track (as precedence over `blackList`).
+     * @param {string[]} [options.blackList] - Black list of parameter names to ignore.
      * @returns {Promise<SharedState>}
      *
      * @example
      * const state = await client.stateManager.attach('my-class', ['some-param']);
      */
-    attach(className: SharedStateClassName, filter: string[]): Promise<SharedState>;
+    attach(className: SharedStateClassName, options?: {
+        whiteList?: string[] | undefined;
+        blackList?: string[] | undefined;
+    } | undefined): Promise<SharedState>;
     /**
      * Attach to an existing {@link SharedState} instance.
      *
      * @overload
      * @param {SharedStateClassName} className - Name of the class.
      * @param {number} stateId - Id of the state
-     * @param {string[]} filter - List of parameters of interest
+     * @param {object} [options={}]
+     * @param {string[]} [options.whiteList] - White list of parameter names to track (as precedence over `blackList`).
+     * @param {string[]} [options.blackList] - Black list of parameter names to ignore.
      * @returns {Promise<SharedState>}
      *
      * @example
      * const state = await client.stateManager.attach('my-class', stateId, ['some-param']);
      */
-    attach(className: SharedStateClassName, stateId: number, filter: string[]): Promise<SharedState>;
+    attach(className: SharedStateClassName, stateId: number, options?: {
+        whiteList?: string[] | undefined;
+        blackList?: string[] | undefined;
+    } | undefined): Promise<SharedState>;
     /**
      * Observe all the {@link SharedState} instances that are created on the network.
      *
@@ -147,7 +154,7 @@ declare class BaseStateManager {
      * @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
+     * @param {boolean} [options.excludeLocal=false] - If set to true, exclude states
      *   created by the same node from the collection.
      * @example
      * client.stateManager.observe(async (className, stateId) => {
@@ -157,7 +164,7 @@ declare class BaseStateManager {
      * }, { excludeLocal: true });
      */
     observe(callback: stateManagerObserveCallback, options: {
-        excludeLocal: boolean;
+        excludeLocal?: boolean | undefined;
     }): any;
     /**
      * Observe all the {@link SharedState} instances of given {@link SharedStateClassName}
@@ -169,7 +176,7 @@ declare class BaseStateManager {
      * @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
+     * @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 (className, stateId) => {
@@ -177,7 +184,7 @@ declare class BaseStateManager {
      * }, { excludeLocal: true });
      */
     observe(className: SharedStateClassName, callback: stateManagerObserveCallback, options: {
-        excludeLocal: boolean;
+        excludeLocal?: boolean | undefined;
     }): any;
     /**
      * Returns a collection of all the states created from a given shared state class.
@@ -195,48 +202,28 @@ declare class BaseStateManager {
      *
      * @overload
      * @param {SharedStateClassName} className - Name of the shared state class.
-     * @param {SharedStateParameterName[]} filter - Filter parameter of interest for each
-     *  state of the collection.
-     * @returns {Promise<SharedStateCollection>}
-     *
-     * @example
-     * const collection = await client.stateManager.getCollection(className, ['my-param']);
-     */
-    getCollection(className: SharedStateClassName, filter: SharedStateParameterName[]): Promise<SharedStateCollection>;
-    /**
-     * Returns a collection of all the states created from a given shared state class.
-     *
-     * @overload
-     * @param {SharedStateClassName} className - Name of the shared state class.
-     * @param {object} options - Options.
-     * @param {boolean} options.excludeLocal=false - If set to true, exclude states
+     * @param {object} [options={}] - Options.
+     * @param {boolean} [options.excludeLocal=false] - If set to true, exclude states
      *  created by the same node from the collection.
+     * @param {string[]} [options.whiteList] - White list of parameter names to track (as precedence over `blackList`).
+     * @param {string[]} [options.blackList] - Black list of parameter names to ignore.
      * @returns {Promise<SharedStateCollection>}
      *
      * @example
-     * const collection = await client.stateManager.getCollection(className, { excludeLocal: true });
+     * const collection = await client.stateManager.getCollection(className, {
+     *   blackList: ['my-param'],
+     *   excludeLocal: true,
+     * });
      */
-    getCollection(className: SharedStateClassName, options: {
-        excludeLocal: boolean;
-    }): Promise<SharedStateCollection>;
+    getCollection(className: SharedStateClassName, options?: {
+        excludeLocal?: boolean | undefined;
+        whiteList?: string[] | undefined;
+        blackList?: string[] | undefined;
+    } | undefined): Promise<SharedStateCollection>;
     /**
-     * Returns a collection of all the states created from a given shared state class.
-     *
-     * @overload
-     * @param {SharedStateClassName} className - Name of the shared state class.
-     * @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 {Promise<SharedStateCollection>}
-     *
-     * @example
-     * const collection = await client.stateManager.getCollection(className, ['my-param'], { excludeLocal: true });
+     * @deprecated Use {@link BaseStateManager#getClassDescription} instead.
      */
-    getCollection(className: SharedStateClassName, filter: SharedStateParameterName[], options: {
-        excludeLocal: boolean;
-    }): Promise<SharedStateCollection>;
+    getSchema(className: any): Promise<any>;
     /** @private */
     private [kStateManagerDeleteState];
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"BaseStateManager.d.ts","sourceRoot":"","sources":["../../src/common/BaseStateManager.js"],"names":[],"mappings":"AAgCA,8CAAyE;AACzE,qDAAwF;AAExF,gDAA6E;;;;;;;;;;;AAE7E;;;;;;;;GAQG;AACH;;;;;GAKG;AAEH,eAAe;AACf;IAuLE;;;;;;OAMG;IACH,2CAHW,GAAC,QAKX;IAED;;;;;;;;OAQG;IACH,+BANW,oBAAoB,GAEnB,2BAA2B,CAatC;IAED;;OAEG;IACH,wCAGC;IAED;;;;;;;;OAQG;IACH,kBANW,oBAAoB;;QAElB,OAAO,CAAC,WAAW,CAAC,CAahC;;;;;;;;;;;IAKE,kBACQ,oBAAoB,GAClB,OAAO,CAAC,WAAW,CAAC,CAE9B;;;;;;;;;;;;IAMA,kBACQ,oBAAoB,WACpB,MAAM,GACJ,OAAO,CAAC,WAAW,CAAC,CAE9B;;;;;;;;;;;;IAMA,kBACQ,oBAAoB,UACpB,MAAM,EAAE,GACN,OAAO,CAAC,WAAW,CAAC,CAE9B;;;;;;;;;;;;;IAMA,kBACQ,oBAAoB,WACpB,MAAM,UACN,MAAM,EAAE,GACN,OAAO,CAAC,WAAW,CAAC,CAE9B;;;;;;;;;;;;;;IAsEA,kBACQ,2BAA2B,OAEnC;;;;;;;;;;;;;;;IAWA,mBACQ,oBAAoB,YAEpB,2BAA2B,OAEnC;;;;;;;;;;;;;;;;;;IASA,kBACQ,2BAA2B,WAGnC;QAAyB,YAAY,EAA7B,OAAO;KAEf,OAAA;;;;;;;;;;;;;;;;;;IAWA,mBACQ,oBAAoB,YAEpB,2BAA2B,WAGnC;QAAyB,YAAY,EAA7B,OAAO;KAEf,OAAA;;;;;;;;;;;IAwJA,yBACQ,oBAAoB,GAClB,OAAO,CAAC,qBAAqB,CAAC,CAExC;;;;;;;;;;;;;IAMA,yBACQ,oBAAoB,UACpB,wBAAwB,EAAE,GAExB,OAAO,CAAC,qBAAqB,CAAC,CAExC;;;;;;;;;;;;;;IAMA,yBACQ,oBAAoB,WAE5B;QAAyB,YAAY,EAA7B,OAAO;KAEf,GAAU,OAAO,CAAC,qBAAqB,CAAC,CAExC;;;;;;;;;;;;;;;;IAMA,yBACQ,oBAAoB,UACpB,wBAAwB,EAAE,WAGlC;QAAyB,YAAY,EAA7B,OAAO;KAEf,GAAU,OAAO,CAAC,qBAAqB,CAAC,CAExC;IA7jBH,eAAe;IACf,mCAEC;IAED;;;;;;;OAOG;IACH,4BA2IC;IA5KC,eAAe;IACf,8BAAgC;;CAupBnC;wBAjtBuB,kBAAkB;kCAGnC,4BAA4B"}
+{"version":3,"file":"BaseStateManager.d.ts","sourceRoot":"","sources":["../../src/common/BaseStateManager.js"],"names":[],"mappings":"AA+BA,8CAAyE;AACzE,qDAAwF;AACxF,gEAA6H;AAE7H,gDAA6E;;;;;;;;;;;AAG7E;;;;;;;;GAQG;AACH;;;;;GAKG;AAEH,eAAe;AACf;IA6EE;;;;;;OAMG;IACH,2CAHW,GAAC,QAKX;IAED;;;;;;;;OAQG;IACH,+BANW,oBAAoB,GAEnB,2BAA2B,CAatC;IAYD;;;;;;;;OAQG;IACH,kBANW,oBAAoB;;QAElB,OAAO,CAAC,WAAW,CAAC,CAahC;;;;;;;;;;;IAyBE,kBACQ,oBAAoB,GAClB,OAAO,CAAC,WAAW,CAAC,CAE9B;;;;;;;;;;;;IAMA,kBACQ,oBAAoB,WACpB,MAAM,GACJ,OAAO,CAAC,WAAW,CAAC,CAE9B;;;;;;;;;;;;;;IAMA,kBACQ,oBAAoB;;;oBAIlB,OAAO,CAAC,WAAW,CAAC,CAE9B;;;;;;;;;;;;;;;IAMA,kBACQ,oBAAoB,WACpB,MAAM;;;oBAIJ,OAAO,CAAC,WAAW,CAAC,CAE9B;;;;;;;;;;;;;;IAgHA,kBACQ,2BAA2B,OAEnC;;;;;;;;;;;;;;;IAWA,mBACQ,oBAAoB,YAEpB,2BAA2B,OAEnC;;;;;;;;;;;;;;;;;;IASA,kBACQ,2BAA2B,WAGnC;QAA0B,YAAY;KAEtC,OAAA;;;;;;;;;;;;;;;;;;IAWA,mBACQ,oBAAoB,YAEpB,2BAA2B,WAGnC;QAA0B,YAAY;KAEtC,OAAA;;;;;;;;;;;IA4NA,yBACQ,oBAAoB,GAClB,OAAO,CAAC,qBAAqB,CAAC,CAExC;;;;;;;;;;;;;;;;;;;IAMA,yBACQ,oBAAoB;;;;oBAMlB,OAAO,CAAC,qBAAqB,CAAC,CAExC;IAqFH;;OAEG;IACH,wCAGC;IA5qBD,eAAe;IACf,mCAEC;IAED;;;;;;;OAOG;IACH,4BAyBC;IA3CC,eAAe;IACf,8BAAgC;;CAirBnC;wBA5uBuB,kBAAkB;kCAGnC,4BAA4B"}

package/types/common/SharedState.d.ts

@@ -3,7 +3,7 @@ export default SharedState;
 /**
  * Callback executed when updates are applied on a {@link SharedState}.
  */
-export type sharedStateOnUpdateCallback = (newValues: Object, oldValues: Object) => any;
+export type sharedStateOnUpdateCallback = (newValues: Object | any, oldValues: Object | any, unsubscribe: sharedStateDeleteOnUpdateCallback) => any;
 /**
  * Delete the registered {@link sharedStateOnUpdateCallback}.
  */
@@ -12,10 +12,14 @@ export type sharedStateDeleteOnUpdateCallback = () => any;
  * Callback executed when updates are applied on a {@link SharedState}.
  *
  * @callback sharedStateOnUpdateCallback
- * @param {Object} newValues - Key / value pairs of the updates that have been
- *  applied to the state.
- * @param {Object} oldValues - Key / value pairs of the updated params before
- *  the updates has been applied to the state.
+ * @param {Object|any} newValues - Key / value pairs of the updates that have been
+ *  applied to the state, or single value if the callback has been registered against
+ *  a parameter name filter.
+ * @param {Object|any} oldValues - Key / value pairs of the updated params before
+ *  the updates has been applied to the state, or single value if the callback has been
+ *  registered against a parameter name filter.
+ * @param {sharedStateDeleteOnUpdateCallback} unsubscribe - Reference to unsubscribe
+ *  function returned by the `SharedState#onUpdate` method.
  */
 /**
  * Delete the registered {@link sharedStateOnUpdateCallback}.
@@ -79,16 +83,6 @@ export type sharedStateDeleteOnUpdateCallback = () => any;
  * ```
  */
 declare class SharedState {
-    constructor({ stateId, instanceId, className, classDescription, isOwner, manager, initValues, filter, }: {
-        stateId: any;
-        instanceId: any;
-        className: any;
-        classDescription: any;
-        isOwner: any;
-        manager: any;
-        initValues: any;
-        filter: any;
-    });
     /**
      * Id of the state
      * @type {Number}
@@ -128,10 +122,6 @@ declare class SharedState {
      * const paramDescription = state.getDescription('my-param');
      */
     getDescription(paramName?: string): SharedStateClassDescription | SharedStateParameterDescription;
-    /**
-     * @deprecated Use {@link SharedState#getDescription} instead.
-     */
-    getSchema(paramName?: null): any;
     /**
      * Update the values of the state.
      *
@@ -255,26 +245,36 @@ declare class SharedState {
      */
     delete(): Promise<any>;
     /**
-     * Subscribe to state updates.
+     * Subscribe to any updates in the state.
      *
+     * @overload
      * @param {sharedStateOnUpdateCallback} callback
      *  Callback to execute when an update is applied on the state.
      * @param {Boolean} [executeListener=false] - Execute the callback immediately
      *  with current state values. Note that `oldValues` will be set to `{}`.
      * @returns {sharedStateDeleteOnUpdateCallback}
      * @example
-     * const unsubscribe = state.onUpdate(async (newValues, oldValues) =>  {
-     *   for (let [key, value] of Object.entries(newValues)) {
-     *      switch (key) {
-     *        // do something
-     *      }
-     *   }
+     * state.onUpdate(updates => {
+     *   // ...
      * });
+     */
+    onUpdate(callback: sharedStateOnUpdateCallback, executeListener?: boolean | undefined): sharedStateDeleteOnUpdateCallback;
+    /**
+     * Subscribe to updates in the state filtered by a given parameter name.
      *
-     * // later
-     * unsubscribe();
+     * @overload
+     * @param {SharedStateParameterName} paramName
+     * @param {sharedStateOnUpdateCallback} callback
+     *  Callback to execute when an update is applied on the state.
+     * @param {Boolean} [executeListener=false] - Execute the callback immediately
+     *  with current state values. Note that `oldValues` will be set to `{}`.
+     * @returns {sharedStateDeleteOnUpdateCallback}
+     * @example
+     * state.onUpdate('my-param', myValue => {
+     *   // ...
+     * });
      */
-    onUpdate(listener: any, executeListener?: boolean): sharedStateDeleteOnUpdateCallback;
+    onUpdate(paramName: SharedStateParameterName, callback: sharedStateOnUpdateCallback, executeListener?: boolean | undefined): sharedStateDeleteOnUpdateCallback;
     /**
      * Register a function to execute when detaching from the state. The function
      * will be executed before the `detach` promise resolves.
@@ -292,6 +292,27 @@ declare class SharedState {
      * @param {Function} callback - Callback to execute when the state is deleted.
      */
     onDelete(callback: Function): () => boolean;
+    /**
+     * Wait for a given condition in the state of the SharedState instance.
+     * If the state watches the condition when `waitFor` is called, the promise is
+     * resolved immediately.
+     *
+     * @note - mark as private until tested in real-world
+     *
+     * @private
+     * @param {object} condition - Condition to be meet in the state for the
+     *  returned promise to resolve. The condition is either a function which returns
+     *  `true` when the condition is met or an object that describe a desired state
+     *  of a subset the `SharedState` values.
+     * @param {object} timeout - Timeout (in milliseconds) that trigger the rejection
+     *  of the returned promise.
+     * @return {Promise}
+     */
+    private waitFor;
+    /**
+     * @deprecated Use {@link SharedState#getDescription} instead.
+     */
+    getSchema(paramName?: null): any;
     /** @private */
     private [kSharedStatePromiseStore];
     #private;

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

@@ -1 +1 @@
-{"version":3,"file":"SharedState.d.ts","sourceRoot":"","sources":["../../src/common/SharedState.js"],"names":[],"mappings":"AA2BA,qDAAwF;;;;;sDAM7E,MAAM,aAEN,MAAM;;;;;AANjB;;;;;;;;GAQG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH;IAiBE;;;;;;;;;OAkKC;IAED;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;OAEG;IACH,yBAGC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;;OAKG;IACH,2BAUC;IAwED;;;;;;;;;;;OAWG;IACH,2BARW,MAAM,GAEL,2BAA2B,GAAC,+BAA+B,CAYtE;IAED;;OAEG;IACH,iCAGC;;;;;;;;;;;IAQE,aACQ,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAC3B;;;;;;;;;;;;IAOE,UACQ,wBAAwB,SACxB,GAAC,GACC,OAAO,CAAC,MAAM,CAAC,CAC3B;IA8KD;;;;;;;;;;;;;;OAcG;IACH,UANW,wBAAwB,GACvB,GAAG,CAiBd;IAED;;;;;;;;;;;;;;OAcG;IACH,gBANW,wBAAwB,GACvB,GAAG,CAiBd;IAED;;;;;;;;OAQG;IACH,aAJY,MAAM,CAgBjB;IAED;;;;;;;;;;;;OAYG;IACH,mBAJY,MAAM,CAgBjB;IAED;;;;;;;OAOG;IACH,iBAJY,MAAM,CAMjB;IAED;;;;;;OAMG;IACH,eAJY,MAAM,CAMjB;IAED;;;;;;;;OAQG;IACH,uBAiBC;IAED;;;;;;;;;;;;;;OAcG;IACH,uBAUC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,oDAba,iCAAiC,CAkC7C;IAED;;;;;;;OAOG;IACH,4CAGC;IAED;;;;;;OAMG;IACH,4CAOC;IAluBC,eAAe;IACf,mCAAwE;;CAkuB3E"}
+{"version":3,"file":"SharedState.d.ts","sourceRoot":"","sources":["../../src/common/SharedState.js"],"names":[],"mappings":"AAoCA,qDAAwF;;;;;sDAM7E,MAAM,GAAC,GAAG,aAGV,MAAM,GAAC,GAAG,eAGV,iCAAiC;;;;;AAV5C;;;;;;;;;;;;GAYG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH;IA0SE;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;OAEG;IACH,yBAGC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;;OAKG;IACH,2BAUC;IAED;;;;;;;;;;;OAWG;IACH,2BARW,MAAM,GAEL,2BAA2B,GAAC,+BAA+B,CAYtE;;;;;;;;;;;IAQE,aACQ,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAC3B;;;;;;;;;;;;IAOE,UACQ,wBAAwB,SACxB,GAAC,GACC,OAAO,CAAC,MAAM,CAAC,CAC3B;IA6KD;;;;;;;;;;;;;;OAcG;IACH,UANW,wBAAwB,GACvB,GAAG,CAkBd;IAED;;;;;;;;;;;;;;OAcG;IACH,gBANW,wBAAwB,GACvB,GAAG,CAkBd;IAED;;;;;;;;OAQG;IACH,aAJY,MAAM,CAOjB;IAED;;;;;;;;;;;;OAYG;IACH,mBAJY,MAAM,CAOjB;IAED;;;;;;;OAOG;IACH,iBAJY,MAAM,CAMjB;IAED;;;;;;OAMG;IACH,eAJY,MAAM,CAMjB;IAED;;;;;;;;OAQG;IACH,uBAiBC;IAED;;;;;;;;;;;;;;OAcG;IACH,uBAUC;;;;;;;;;;;;;;;IAKE,mBACQ,2BAA2B,0CAIzB,iCAAiC,CAC3C;;;;;;;;;;;;;;;;IAQA,oBACQ,wBAAwB,YACxB,2BAA2B,0CAIzB,iCAAiC,CAC3C;IAwDH;;;;;;;OAOG;IACH,4CAGC;IAED;;;;;;OAMG;IACH,4CAOC;IAED;;;;;;;;;;;;;;;OAeG;IACH,gBAgCC;IAMD;;OAEG;IACH,iCAGC;IAh2BC,eAAe;IACf,mCAAwE;;CAi2B3E"}

package/types/common/SharedStateCollection.d.ts

@@ -4,10 +4,14 @@
  *
  * @callback sharedStateCollectionOnUpdateCallback
  * @param {SharedState} state - The shared state instance that triggered the update.
- * @param {Object} newValues - Key / value pairs of the updates that have been
- *  applied to the state.
- * @param {Object} oldValues - Key / value pairs of the updated params before
- *  the updates has been applied to the state.
+ * @param {Object|any} newValues - Key / value pairs of the updates that have been
+ *  applied to the state, or single value if the callback has been registered against
+ *  a parameter name filter.
+ * @param {Object|any} oldValues - Key / value pairs of the updated params before
+ *  the updates has been applied to the state, or single value if the callback has been
+ *  registered against a parameter name filter.
+ * @param {sharedStateCollectionDeleteOnUpdateCallback} unsubscribe - Reference to unsubscribe
+ *  function returned by the `SharedStateCollection#onUpdate` method.
  */
 /**
  * Delete the registered {@link sharedStateCollectionOnUpdateCallback} when executed.
@@ -53,7 +57,7 @@ export default SharedStateCollection;
  * Callback to execute when an update is triggered on one of the shared states
  * of the collection.
  */
-export type sharedStateCollectionOnUpdateCallback = (state: SharedState, newValues: Object, oldValues: Object) => any;
+export type sharedStateCollectionOnUpdateCallback = (state: SharedState, newValues: Object | any, oldValues: Object | any, unsubscribe: sharedStateCollectionDeleteOnUpdateCallback) => any;
 /**
  * Delete the registered {@link sharedStateCollectionOnUpdateCallback} when executed.
  */
@@ -102,7 +106,7 @@ export type sharedStateCollectionDeleteOnChangeCallback = () => any;
  * @hideconstructor
  */
 declare class SharedStateCollection {
-    constructor(stateManager: any, className: any, filter?: null, options?: {});
+    constructor(stateManager: any, className: any, options?: {});
     /**
      * Size of the collection, alias `size`
      * @type {number}
@@ -207,8 +211,22 @@ declare class SharedStateCollection {
      */
     set(name: SharedStateParameterName, value: any): Promise<Array<Object>>;
     /**
-     * Register a function to execute when any shared state of the collection is updated.
+     * Subscribe to any updates in the collection.
      *
+     * @overload
+     * @param {sharedStateCollectionOnUpdateCallback}
+     *  callback - Callback to execute when an update is applied on a state.
+     * @param {Boolean} [executeListener=false] - Execute the callback immediately
+     *  with current state values. Note that `oldValues` will be set to `{}`.
+     * @returns {sharedStateCollectionDeleteOnUpdateCallback} - Function that delete
+     *  the registered listener when executed.
+     */
+    onUpdate(callback: sharedStateCollectionOnUpdateCallback, executeListener?: boolean | undefined): sharedStateCollectionDeleteOnUpdateCallback;
+    /**
+     * Subscribe to updates in the collection filtered by a given parameter name.
+     *
+     * @overload
+     * @param {SharedStateParameterName} paramName
      * @param {sharedStateCollectionOnUpdateCallback}
      *  callback - Callback to execute when an update is applied on a state.
      * @param {Boolean} [executeListener=false] - Execute the callback immediately
@@ -216,7 +234,7 @@ declare class SharedStateCollection {
      * @returns {sharedStateCollectionDeleteOnUpdateCallback} - Function that delete
      *  the registered listener when executed.
      */
-    onUpdate(callback: sharedStateCollectionOnUpdateCallback, executeListener?: boolean): sharedStateCollectionDeleteOnUpdateCallback;
+    onUpdate(paramName: SharedStateParameterName, callback: sharedStateCollectionOnUpdateCallback, executeListener?: boolean | undefined): sharedStateCollectionDeleteOnUpdateCallback;
     /**
      * Register a function to execute when a shared state is attached to the collection,
      * i.e. when a node creates a new state from same {@link SharedState} class.

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

@@ -1 +1 @@
-{"version":3,"file":"SharedStateCollection.d.ts","sourceRoot":"","sources":["../../src/common/SharedStateCollection.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAEH;;;;GAIG;AAEH;;;;;GAKG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH,uDAA4F;;;;;;4DApDjF,WAAW,aACX,MAAM,aAEN,MAAM;;;;;;;;4DAcN,WAAW;;;;;;;;;4DAcX,WAAW;;;;;;;;;;;;;AAuBtB;;;;;;;;;;;;;;;;;GAiBG;AACH;IAaE,4EAKC;IAuCD;;;;OAIG;IACH,uBAHU,MAAM,CAKf;IAED;;;OAGG;IACH,YAFU,MAAM,CAIf;IAED;;;OAGG;IACH,wBAEC;IAED;;OAEG;IACH,yBAGC;IAED;;OAEG;IACH,iCAGC;IAED;;;;;;;;;;;OAWG;IACH,2BARW,MAAM,GAEL,2BAA2B,GAAC,+BAA+B,CAgBtE;IAED;;;;;;OAMG;IACH,eAJY,MAAM,CAUjB;IAED;;;OAGG;IACH,aAFY,MAAM,EAAE,CAInB;IAED;;;;;;;;;;OAUG;IACH,mBAFY,MAAM,EAAE,CAInB;IAED;;;;;OAKG;IACH,mBAFY,GAAG,EAAE,CAMhB;IAED;;;;;;;;;OASG;IACH,yBAFY,GAAG,EAAE,CAMhB;;;;;;;;;;;IAQE,aACQ,MAAM,GACJ,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAClC;;;;;;;;;;;;IAOE,UACQ,wBAAwB,SACxB,GAAC,GACC,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAClC;IAwBD;;;;;;;;;OASG;IACH,mBAPW,qCAAqC,8BAInC,2CAA2C,CAyBvD;IAED;;;;;;;;;;OAUG;IACH,mBAPW,qCAAqC,oBAErC,OAAO,GAEL,2CAA2C,CAWvD;IAED;;;;;;;;OAQG;IACH,mBALW,qCAAqC,GAEnC,2CAA2C,CAOvD;IAED;;;;;;;;;;;OAWG;IACH,mBARW,qCAAqC,8BAEnC,2CAA2C,CAcvD;IAED;;;OAGG;IACH,wBAUC;IAED;;;;;OAKG;IACH,8BAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,8BAEC;IAED;;;;OAIG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,0BAEC;IAED;;;;;;;;;;;;;;OAcG;IACH,OAVa,CAAC,gCAKH,CAAC,mBAGA,CAAC,CASZ;IA5YD,eAAe;IACf,qCAkCC;IA2WD;;OAEG;IACH;;;;;MAYC;;CACF"}
+{"version":3,"file":"SharedStateCollection.d.ts","sourceRoot":"","sources":["../../src/common/SharedStateCollection.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;GAcG;AAEH;;;;GAIG;AAEH;;;;;GAKG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH,uDAA4F;;;;;;4DAxDjF,WAAW,aACX,MAAM,GAAC,GAAG,aAGV,MAAM,GAAC,GAAG,eAGV,2CAA2C;;;;;;;;4DAc3C,WAAW;;;;;;;;;4DAcX,WAAW;;;;;;;;;;;;;AAuBtB;;;;;;;;;;;;;;;;;GAiBG;AACH;IAaE,6DAQC;IA4CD;;;;OAIG;IACH,uBAHU,MAAM,CAKf;IAED;;;OAGG;IACH,YAFU,MAAM,CAIf;IAED;;;OAGG;IACH,wBAEC;IAED;;OAEG;IACH,yBAGC;IAED;;OAEG;IACH,iCAGC;IAED;;;;;;;;;;;OAWG;IACH,2BARW,MAAM,GAEL,2BAA2B,GAAC,+BAA+B,CAgBtE;IAED;;;;;;OAMG;IACH,eAJY,MAAM,CAUjB;IAED;;;OAGG;IACH,aAFY,MAAM,EAAE,CAInB;IAED;;;;;;;;;;OAUG;IACH,mBAFY,MAAM,EAAE,CAInB;IAED;;;;;OAKG;IACH,mBAFY,GAAG,EAAE,CAMhB;IAED;;;;;;;;;OASG;IACH,yBAFY,GAAG,EAAE,CAMhB;;;;;;;;;;;IAQE,aACQ,MAAM,GACJ,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAClC;;;;;;;;;;;;IAOE,UACQ,wBAAwB,SACxB,GAAC,GACC,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAClC;;;;;;;;;;;;IA2BE,mBACQ,qCAAqC,0CAInC,2CAA2C,CAEvD;;;;;;;;;;;;;IAIE,oBACQ,wBAAwB,YACxB,qCAAqC,0CAInC,2CAA2C,CAEvD;IA6CD;;;;;;;;;;OAUG;IACH,mBAPW,qCAAqC,oBAErC,OAAO,GAEL,2CAA2C,CAWvD;IAED;;;;;;;;OAQG;IACH,mBALW,qCAAqC,GAEnC,2CAA2C,CAOvD;IAED;;;;;;;;;;;OAWG;IACH,mBARW,qCAAqC,8BAEnC,2CAA2C,CAcvD;IAED;;;OAGG;IACH,wBAUC;IAED;;;;;OAKG;IACH,8BAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,8BAEC;IAED;;;;OAIG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,0BAEC;IAED;;;;;;;;;;;;;;OAcG;IACH,OAVa,CAAC,gCAKH,CAAC,mBAGA,CAAC,CASZ;IAlbD,eAAe;IACf,qCA6BC;IAsZD;;OAEG;IACH;;;;;MAYC;;CACF"}