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

package/types/client/PluginManager.d.ts

@@ -24,7 +24,7 @@ export namespace client {
  *
  * Plugins should always be registered both client-side and server-side,
  * and before {@link client.Client#start} or {@link server.Server#start}
- * are called for proper initialization.
+ * to be properly initialized.
  *
  * In some sitautions, you might want to register the same plugin factory several times
  * using different ids (e.g. for watching several parts of the file system, etc.).
@@ -36,12 +36,13 @@ export namespace client {
  * See {@link client.Client#pluginManager}
  *
  * ```
+ * // client-side
  * import { Client } from '@soundworks/core/client.js';
- * import platformPlugin from '@soundworks/plugin-sync/client.js';
+ * import syncPlugin from '@soundworks/plugin-sync/client.js';
  *
  * const client = new Client(config);
  * // register the plugin before `client.start()`
- * client.pluginManager.register('sync', pluginSync);
+ * client.pluginManager.register('sync', syncPlugin);
  *
  * await client.start();
  *
@@ -53,6 +54,25 @@ export namespace client {
  * }, 1000);
  * ```
  *
+ * ```
+ * // server-side
+ * import { Server } from '@soundworks/core/server.js';
+ * import syncPlugin from '@soundworks/plugin-sync/server.js';
+ *
+ * const server = new Server(config);
+ * // register the plugin before `server.start()`
+ * server.pluginManager.register('sync', syncPlugin);
+ *
+ * await server.start();
+ *
+ * const sync = await server.pluginManager.get('sync');
+ *
+ * setInterval(() => {
+ *   // log the estimated global synced clock alongside the local clock.
+ *   console.log(sync.getSyncTime(), sync.getLocalTime());
+ * }, 1000);
+ * ```
+ *
  * @memberof client
  * @extends BasePluginManager
  * @inheritdoc
@@ -76,8 +96,8 @@ declare class PluginManager extends BasePluginManager {
      * initialization (e.g. to display initialization screen, etc.), you should rely
      * on the `onStateChange` method.
      *
-     * _Note: the async API is designed to enable the dynamic creation of plugins (hopefully
-     * without brealing changes) in a future release._
+     * _Note: the async API is designed to enable the dynamic creation of plugins
+     * (hopefully without brealing changes) in a future release._
      *
      * @param {client.Plugin#id} id - Id of the plugin as defined when registered.
      * @returns {client.Plugin}
@@ -86,11 +106,6 @@ declare class PluginManager extends BasePluginManager {
      * @private
      */
     private get;
-    /**
-     * @protected
-     * @ignore
-     */
-    protected getRegisteredPlugins(): any[];
 }
-import BasePluginManager from "../common/BasePluginManager.js";
+import BasePluginManager from '../common/BasePluginManager.js';
 //# sourceMappingURL=PluginManager.d.ts.map

package/types/client/PluginManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PluginManager.d.ts","sourceRoot":"","sources":["../../src/client/PluginManager.js"],"names":[],"mappings":";;;;;4BAQW,MAAM,aACN,gBAAc,IAAI;;AAL7B;;;;;;;;GAQG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH;IACE;;OAEG;IACH,mCAMC;IAED,kEAQC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,YAMC;IAKD;;;OAGG;IACH,wCAEC;CACF"}
+{"version":3,"file":"PluginManager.d.ts","sourceRoot":"","sources":["../../src/client/PluginManager.js"],"names":[],"mappings":";;;;;4BAQW,MAAM,aACN,gBAAc,IAAI;;AAL7B;;;;;;;;GAQG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH;IACE;;OAEG;IACH,mCAMC;IAED,kEAQC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,YAMC;CACF;8BAjI6B,gCAAgC"}

package/types/client/SharedState.d.ts

@@ -81,5 +81,5 @@ export namespace client {
  */
 declare class SharedState extends BaseSharedState {
 }
-import BaseSharedState from "../common/BaseSharedState.js";
+import BaseSharedState from '../common/BaseSharedState.js';
 //# sourceMappingURL=SharedState.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"SharedState.d.ts","sourceRoot":"","sources":["../../src/client/SharedState.js"],"names":[],"mappings":";;;;;;;AAIA;;;;;;;;GAQG;AAEH;;;;GAIG;AAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH;CAA4C"}
+{"version":3,"file":"SharedState.d.ts","sourceRoot":"","sources":["../../src/client/SharedState.js"],"names":[],"mappings":";;;;;;;AAIA;;;;;;;;GAQG;AAEH;;;;GAIG;AAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH;CAA4C;4BAjFhB,8BAA8B"}

package/types/client/SharedStateCollection.d.ts

@@ -0,0 +1,41 @@
+export default SharedStateCollection;
+export namespace client {
+    /**
+     * ~onUpdateCallback
+     */
+    type SharedStateCollection = (state: client.SharedState, newValues: any, oldValues: any, context?: Mixed) => any;
+}
+/**
+ * @callback client.SharedStateCollection~onUpdateCallback
+ * @param {client.SharedState} state - State 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 {Mixed} [context=null] - Optionnal context object that has been passed
+ *  with the values updates in the `set` call.
+ */
+/**
+ * The `SharedStateCollection` interface represent a collection of all states
+ * created from a given schema name on the network.
+ *
+ * It can optionnaly exclude the states created by the current node.
+ *
+ * See {@link client.StateManager#getCollection} for factory method API
+ *
+ * ```
+ * const collection = await client.stateManager.getCollection('my-schema');
+ * const allValues = collection.getValues();
+ * collection.onUpdate((state, newValues, oldValues, context) => {
+ *   // do something
+ * });
+ * ```
+ * @memberof client
+ * @extends BaseSharedStateCollection
+ * @inheritdoc
+ * @hideconstructor
+ */
+declare class SharedStateCollection extends BaseSharedStateCollection {
+}
+import BaseSharedStateCollection from '../common/BaseSharedStateCollection.js';
+//# sourceMappingURL=SharedStateCollection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SharedStateCollection.d.ts","sourceRoot":"","sources":["../../src/client/SharedStateCollection.js"],"names":[],"mappings":";;;;;;;AAIA;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH;CAAgE;sCAnC1B,wCAAwC"}

package/types/client/Socket.d.ts

@@ -2,34 +2,33 @@ export default Socket;
 /**
  * The Socket class is a simple publish / subscribe wrapper built on top of the
  * [isomorphic-ws](https://github.com/heineiuo/isomorphic-ws) library.
- * An instance of `Socket` is automatically created by the `soundworks.Client`.
+ * An instance of `Socket` is automatically created by the `soundworks.Client`
+ * (see {@link client.Client#socket}).
  *
- * _Important: In most cases, you should consider using a {@link client.SharedState} rather than
- * sending messages directly through the sockets._
+ * _Important: In most cases, you should consider using a {@link client.SharedState}
+ * rather than directly using the sockets._
  *
  * The Socket class concurrently opens two different WebSockets:
- * - a socket configured with `binaryType = 'string'` for JSON compatible string
- *  messages.
- * - a socket configured with `binaryType=arraybuffer` for efficient streaming
+ * - a socket configured with `binaryType = 'blob'` for JSON compatible data
+ *  types (i.e. string, number, boolean, object, array and null).
+ * - a socket configured with `binaryType= 'arraybuffer'` for efficient streaming
  *  of binary data.
  *
  * Both sockets re-emits all "native" ws events ('open', 'upgrade', 'close', 'error'
  *  and 'message'.
  *
- * See {@link client.Client#socket}
- *
  * @memberof client
  * @hideconstructor
  */
 declare class Socket {
     /**
-     * WebSocket instance w/ string protocol, i.e. `binaryType = 'string'`.
+     * WebSocket instance configured with `binaryType = 'blob'`.
      *
      * @private
      */
     private ws;
     /**
-     * WebSocket instance w/ binary protocol, i.e. `binaryType = 'arraybuffer'`.
+     * WebSocket instance configured with `binaryType = 'arraybuffer'`.
      *
      * @private
      */
@@ -38,6 +37,8 @@ declare class Socket {
     private _stringListeners;
     /** @private */
     private _binaryListeners;
+    /** @private */
+    private _heartbeatId;
     /**
      * Initialize a websocket connection with the server. Automatically called
      * during `client.init()`
@@ -48,6 +49,17 @@ declare class Socket {
      * @ignore
      */
     protected init(role: string, config: object): Promise<void>;
+    /**
+     * Removes all listeners and immediately close the two sockets. Is automatically
+     * called on `client.stop()`
+     *
+     * Is also called when a disconnection is detected by the heartbeat (note that
+     * in this case, the launcher will call `client.stop()` but the listeners are
+     * already cleared so the event will be trigerred only once)
+     *
+     * @private
+     */
+    private terminate;
     /**
      * @param {boolean} binary - Emit to either the string or binary socket.
      * @param {string} channel - Channel name.
@@ -77,62 +89,61 @@ declare class Socket {
      */
     private _removeAllListeners;
     /**
-     * Send JSON compatible messages on a given channel.
+     * Send messages with JSON compatible data types on a given channel.
      *
-     * @param {string} channel - Channel name of the message.
-     * @param {...*} args - Message list, as many as needed, of any serializable type).
+     * @param {string} channel - Channel name.
+     * @param {...*} args - Payload of the message. As many arguments as needed, of
+     *  JSON compatible data types (i.e. string, number, boolean, object, array and null).
      */
     send(channel: string, ...args: any[]): void;
     /**
-     * Listen to JSON compatible messages on a given channel.
+     * Listen messages with JSON compatible data types on a given channel.
      *
-     * @param {string} channel - Channel name of the message.
-     * @param {Function} callback - Callback to execute when a message is received.
+     * @param {string} channel - Channel name.
+     * @param {Function} callback - Callback to execute when a message is received,
+     *  arguments of the callback function will match the arguments sent using the
+     *  {@link server.Socket#send} method.
      */
     addListener(channel: string, callback: Function): void;
     /**
      * Remove a listener from JSON compatible messages on a given channel.
      *
-     * @param {string} channel - Channel name of the message.
+     * @param {string} channel - Channel name.
      * @param {Function} callback - Callback to remove.
      */
     removeListener(channel: string, callback: Function): void;
     /**
-     * Remove all listeners from JSON compatible messages on a given channel.
+     * Remove all listeners of messages with JSON compatible data types.
      *
-     * @param {string} channel - Channel name of the message.
+     * @param {string} channel - Channel name.
      */
     removeAllListeners(channel?: string): void;
     /**
      * Send binary messages on a given channel.
      *
-     * @param {string} channel - Channel name of the message.
+     * @param {string} channel - Channel name.
      * @param {TypedArray} typedArray - Binary data to be sent.
      */
     sendBinary(channel: string, typedArray: TypedArray): void;
     /**
-     * Listen binary messages on a given channel.
+     * Listen binary messages on a given channel
      *
-     * @param {string} channel - Channel name of the message.
+     * @param {string} channel - Channel name.
      * @param {Function} callback - Callback to execute when a message is received.
      */
     addBinaryListener(channel: string, callback: Function): void;
     /**
-     * Remove a listener from binary compatible messages on a given channel
+     * Remove a listener of binary compatible messages from a given channel
      *
-     * @param {string} channel - Channel of the message.
-     * @param {Function} callback - Callback to cancel.
+     * @param {string} channel - Channel name.
+     * @param {Function} callback - Callback to remove.
      */
     removeBinaryListener(channel: string, callback: Function): void;
     /**
-     * Remove all listeners from binary compatible messages on a given channel
+     * Remove all listeners of binary compatible messages on a given channel
      *
      * @param {string} channel - Channel of the message.
      */
     removeAllBinaryListeners(channel?: string): void;
-    /**
-     * Removes all listeners and immediately close the two sockets.
-     */
-    terminate(): Promise<void>;
 }
 //# sourceMappingURL=Socket.d.ts.map

package/types/client/Socket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Socket.d.ts","sourceRoot":"","sources":["../../src/client/Socket.js"],"names":[],"mappings":";AA2BA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAEI;;;;OAIG;IACH,WAAc;IACd;;;;OAIG;IACH,iBAAoB;IACpB,eAAe;IACf,yBAAiC;IACjC,eAAe;IACf,yBAAiC;IAGnC;;;;;;;;OAQG;IACH,qBALW,MAAM,UACN,MAAM,iBA6JhB;IAED;;;;;OAKG;IACH,cAOC;IAED;;;;;OAKG;IACH,qBAOC;IAED;;;;;OAKG;IACH,wBASC;IAED;;;;;OAKG;IACH,4BAMC;IAED;;;;;OAKG;IACH,cAHW,MAAM,wBAMhB;IAED;;;;;OAKG;IACH,qBAHW,MAAM,4BAKhB;IAED;;;;;OAKG;IACH,wBAHW,MAAM,4BAKhB;IAED;;;;OAIG;IACH,6BAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,oBAHW,MAAM,gCAMhB;IAED;;;;;OAKG;IACH,2BAHW,MAAM,4BAKhB;IAED;;;;;OAKG;IACH,8BAHW,MAAM,4BAKhB;IAED;;;;OAIG;IACH,mCAFW,MAAM,QAIhB;IAED;;OAEG;IACH,2BAQC;CACF"}
+{"version":3,"file":"Socket.d.ts","sourceRoot":"","sources":["../../src/client/Socket.js"],"names":[],"mappings":";AAiCA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAEI;;;;OAIG;IACH,WAAc;IACd;;;;OAIG;IACH,iBAAoB;IACpB,eAAe;IACf,yBAAiC;IACjC,eAAe;IACf,yBAAiC;IACjC,eAAe;IACf,qBAAwB;IAG1B;;;;;;;;OAQG;IACH,qBALW,MAAM,UACN,MAAM,iBA+KhB;IAED;;;;;;;;;OASG;IACH,kBAmBC;IAED;;;;;OAKG;IACH,cAOC;IAED;;;;;OAKG;IACH,qBAOC;IAED;;;;;OAKG;IACH,wBASC;IAED;;;;;OAKG;IACH,4BAMC;IAED;;;;;;OAMG;IACH,cAJW,MAAM,wBAOhB;IAED;;;;;;;OAOG;IACH,qBALW,MAAM,4BAOhB;IAED;;;;;OAKG;IACH,wBAHW,MAAM,4BAKhB;IAED;;;;OAIG;IACH,6BAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,oBAHW,MAAM,gCAMhB;IAED;;;;;OAKG;IACH,2BAHW,MAAM,4BAKhB;IAED;;;;;OAKG;IACH,8BAHW,MAAM,4BAKhB;IAED;;;;OAIG;IACH,mCAFW,MAAM,QAIhB;CACF"}

package/types/client/StateManager.d.ts

@@ -68,5 +68,5 @@ export namespace client {
  */
 declare class StateManager extends BaseStateManager {
 }
-import BaseStateManager from "../common/BaseStateManager.js";
+import BaseStateManager from '../common/BaseStateManager.js';
 //# sourceMappingURL=StateManager.d.ts.map

package/types/client/StateManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StateManager.d.ts","sourceRoot":"","sources":["../../src/client/StateManager.js"],"names":[],"mappings":";;;;;;;AAEA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH;CAA8C"}
+{"version":3,"file":"StateManager.d.ts","sourceRoot":"","sources":["../../src/client/StateManager.js"],"names":[],"mappings":";;;;;;;AAEA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH;CAA8C;6BAhEjB,+BAA+B"}

package/types/client/index.d.ts

@@ -1,11 +1,3 @@
 export { default as Context } from "./Context.js";
 export { default as Client } from "./Client.js";
-/**
- * Configuration object for a client running in a browser runtime.
- */
-export type BrowserClientConfig = any;
-/**
- * Configuration object for a client running in a node runtime.
- */
-export type NodeClientConfig = any;
 //# sourceMappingURL=index.d.ts.map

package/types/common/BasePlugin.d.ts

@@ -4,25 +4,10 @@ export default BasePlugin;
  */
 declare class BasePlugin {
     constructor(id: any);
-    /**
-     * User defined ID of the plugin.
-     *
-     * @type {string}
-     * @see {@link client.PluginManager#register}
-     * @see {@link server.PluginManager#register}
-     */
-    id: string;
-    /**
-     * Type of the plugin, i.e. the ClassName.
-     *
-     * Usefull to do perform some logic based on certain types of plugins without
-     * knowing under which `id` they have been registered. (e.g. creating some generic
-     * views, etc.)
-     *
-     * @type {string}
-     * @readonly
-     */
-    readonly type: string;
+    /** @private */
+    private _id;
+    /** @private */
+    private _type;
     /**
      * Options of the plugin.
      *
@@ -50,6 +35,26 @@ declare class BasePlugin {
     status: string;
     /** @private */
     private _onStateChangeCallbacks;
+    /**
+     * User defined ID of the plugin.
+     *
+     * @type {string}
+     * @readonly
+     * @see {@link client.PluginManager#register}
+     * @see {@link server.PluginManager#register}
+     */
+    readonly get id(): string;
+    /**
+     * Type of the plugin, i.e. the ClassName.
+     *
+     * Usefull to do perform some logic based on certain types of plugins without
+     * knowing under which `id` they have been registered. (e.g. creating some generic
+     * views, etc.)
+     *
+     * @type {string}
+     * @readonly
+     */
+    readonly get type(): string;
     /**
      * Start the plugin. This method is automatically called during the client or
      * server `init()` lifecyle step. After `start()` is fulfilled the plugin should

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

@@ -1 +1 @@
-{"version":3,"file":"BasePlugin.d.ts","sourceRoot":"","sources":["../../src/common/BasePlugin.js"],"names":[],"mappings":";AAEA;;GAEG;AACH;IACE,qBAoDC;IAnDC;;;;;;OAMG;IACH,IAJU,MAAM,CAIJ;IAEZ;;;;;;;;;OASG;IACH,eAHU,MAAM,CAGiB;IAEjC;;;;OAIG;IACH,SAFU,MAAM,CAEC;IAEjB;;;;;;;;;;;OAWG;IACH,iBAPU,MAAM,CAOD;IAEf;;;;OAIG;IACH,QAFU,MAAM,CAEI;IAEpB,eAAe;IACf,gCAAwC;IAG1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,uBAAgB;IAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,sBAAe;IAEf;;;;;;;;;;;;;OAaG;IACH,4CAGC;IAED;;;;;;;;;;OAUG;IACH,8BANW,MAAM,QAShB;CACF"}
+{"version":3,"file":"BasePlugin.d.ts","sourceRoot":"","sources":["../../src/common/BasePlugin.js"],"names":[],"mappings":";AAEA;;GAEG;AACH;IACE,qBAoCC;IAnCC,eAAe;IACf,YAAa;IACb,eAAe;IACf,cAAkC;IAElC;;;;OAIG;IACH,SAFU,MAAM,CAEC;IAEjB;;;;;;;;;;;OAWG;IACH,iBAPU,MAAM,CAOD;IAEf;;;;OAIG;IACH,QAFU,MAAM,CAEI;IAEpB,eAAe;IACf,gCAAwC;IAG1C;;;;;;;OAOG;IACH,0BAEC;IAED;;;;;;;;;OASG;IACH,4BAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,uBAAgB;IAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,sBAAe;IAEf;;;;;;;;;;;;;OAaG;IACH,4CAGC;IAED;;;;;;;;;;OAUG;IACH,8BANW,MAAM,QAShB;CACF"}

package/types/common/BasePluginManager.d.ts

@@ -9,7 +9,7 @@ declare class BasePluginManager {
     /** @private */
     private _node;
     /** @private */
-    private _registeredPlugins;
+    private _dependencies;
     /** @private */
     private _instances;
     /** @private */
@@ -41,21 +41,33 @@ declare class BasePluginManager {
      * server.pluginManager.register('user-defined-id', pluginFactory);
      */
     register(id: string, ctor: any, options?: object, deps?: any[]): void;
+    /**
+     * Manually add a dependency to a given plugin. Usefull to require a plugin
+     * within a plugin
+     *
+     */
+    addDependency(pluginId: any, dependencyId: any): void;
+    /**
+     * Returns the list of the registered plugins ids
+     * @returns {string[]}
+     */
+    getRegisteredPlugins(): string[];
     /**
      * Initialize all the registered plugin. Executed during the `Client.init()` or
      * `Server.init()` initialization step.
      * @private
      */
     private start;
-    stop(): Promise<void>;
+    /** @private */
+    private stop;
     /**
      * Retrieve an fully started instance of a registered plugin, without checking
-     * that the pluginManager is started. This is important for starting the plugin
-     * manager itself.
+     * that the pluginManager has started. This is required for starting the plugin
+     * manager itself and to require a plugin from within another plugin
      *
      * @private
      */
-    private getUnsafe;
+    private unsafeGet;
     /**
      * Propagate a notification each time a plugin is updated (status or inner state).
      * The callback will receive the list of all plugins as first parameter, and the

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

@@ -1 +1 @@
-{"version":3,"file":"BasePluginManager.d.ts","sourceRoot":"","sources":["../../src/common/BasePluginManager.js"],"names":[],"mappings":";AAKA;;;;GAIG;AACH;IACE,uBAcC;IAZC,eAAe;IACf,cAAiB;IACjB,eAAe;IACf,2BAAmC;IACnC,eAAe;IACf,mBAA2B;IAC3B,eAAe;IACf,+BAAuC;IACvC,eAAe;IACf,gCAAwC;IAExC,eAAoB;IAGtB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,aAfW,MAAM,uBAGN,MAAM,sBAqChB;IAED;;;;OAIG;IACH,cA2BC;IAED,sBAIC;IAED;;;;;;OAMG;IACH,kBAqDC;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,4CAGC;IAED,eAAe;IACf,8BAaC;CACF"}
+{"version":3,"file":"BasePluginManager.d.ts","sourceRoot":"","sources":["../../src/common/BasePluginManager.js"],"names":[],"mappings":";AAIA;;;;GAIG;AACH;IACE,uBAcC;IAZC,eAAe;IACf,cAAiB;IACjB,eAAe;IACf,sBAA8B;IAC9B,eAAe;IACf,mBAA2B;IAC3B,eAAe;IACf,+BAAuC;IACvC,eAAe;IACf,gCAAwC;IAExC,eAAoB;IAGtB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,aAfW,MAAM,uBAGN,MAAM,sBA6ChB;IAED;;;;OAIG;IACH,sDAGC;IAED;;;OAGG;IACH,wBAFa,MAAM,EAAE,CAIpB;IAED;;;;OAIG;IACH,cAyBC;IAED,eAAe;IACf,aAIC;IAED;;;;;;OAMG;IACH,kBAqDC;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,4CAGC;IAED,eAAe;IACf,8BAaC;CACF"}

package/types/common/BaseSharedState.d.ts

@@ -1,9 +1,12 @@
 export default BaseSharedState;
 declare class BaseSharedState {
-    constructor(id: any, remoteId: any, schemaName: any, schema: any, client: any, isOwner: any, manager: any, initValues?: {});
-    id: any;
-    remoteId: any;
-    schemaName: any;
+    constructor(id: any, remoteId: any, schemaName: any, schema: any, client: any, isOwner: any, manager: any, initValues: any, filter: any);
+    /** @private */
+    private _id;
+    /** @private */
+    private _remoteId;
+    /** @private */
+    private _schemaName;
     /** @private */
     private _isOwner;
     /** @private */
@@ -11,6 +14,14 @@ declare class BaseSharedState {
     /** @private */
     private _manager;
     /** @private */
+    private _filter;
+    /**
+     * true is the state has been detached or deleted
+     * @private
+     */
+    private _detached;
+    _promiseStore: PromiseStore;
+    /** @private */
     private _parameters;
     /** @private */
     private _onUpdateCallbacks;
@@ -18,18 +29,31 @@ declare class BaseSharedState {
     private _onDetachCallbacks;
     /** @private */
     private _onDeleteCallbacks;
-    /** @private */
-    private _clearDetach;
     /**
-     * Detach from the state. If the client is the creator of the state, the state
-     * is deleted and all attached nodes get notified
-     *
-     * @example
-     * const state = await client.state.attach('globals');
-     * // later
-     * await state.detach();
+     * Id of the state
+     * @type {Number}
+     * @readonly
      */
-    detach(): Promise<any>;
+    readonly get id(): number;
+    /**
+     * Unique id of the state for the current node
+     * @readonly
+     * @type {Number}
+     * @private
+     */
+    private readonly get remoteId();
+    /**
+     * Name of the schema
+     * @type {String}
+     * @readonly
+     */
+    readonly get schemaName(): string;
+    /**
+     * Indicates if the node is the owner of the state
+     * @type {Boolean}
+     * @readonly
+     */
+    readonly get isOwner(): boolean;
     /** @private */
     private _clearTransport;
     /** @private */
@@ -72,31 +96,63 @@ declare class BaseSharedState {
      */
     set(updates: object, context?: mixed): Promise<any>;
     /**
-     * Get the value of a paramter of the state.
+     * Get the value of a parameter of the state. If the parameter is of `any` type,
+     * a deep copy is returned.
      *
      * @param {string} name - Name of the param.
      * @throws Throws if `name` does not correspond to an existing field
      *  of the state.
      * @return {mixed}
      * @example
-     * const value = state.get('name');
+     * const value = state.get('paramName');
      */
     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 param.
+     * @throws Throws if `name` does not correspond to an existing field
+     *  of the state.
+     * @return {mixed}
+     * @example
+     * const value = state.getUnsafe('paramName');
+     */
+    getUnsafe(name: string): mixed;
     /**
      * Get all the key / value pairs of the state.
      *
+     * If a parameter is of `any` type, a deep copy is made.
+     *
      * @return {object}
      * @example
      * const values = state.getValues();
      */
     getValues(): object;
     /**
-     * Get the schema from which the state has been created.
+     * Get all the key / value pairs of the state.
+     *
+     * 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}
+     * @example
+     * const values = state.getValues();
+     */
+    getValuesUnsafe(): object;
+    /**
+     * Definition of schema from which the state has been created.
      *
-     * @param {string} [name=null] - If given, returns only the definition corresponding
-     *  to the given param name.
+     * @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 state.
+     *  of the schema.
      * @return {object}
      * @example
      * const schema = state.getSchema();
@@ -119,11 +175,23 @@ declare class BaseSharedState {
      * const defaults = state.getDefaults();
      */
     getDefaults(): object;
+    /**
+     * Detach from the state. If the client is the creator of the state, the state
+     * is deleted and all attached nodes get notified.
+     *
+     * @example
+     * const state = await client.state.attach('globals');
+     * // later
+     * await state.detach();
+     */
+    detach(): Promise<any>;
     /**
      * Delete the state. Only the creator/owner of the state can use this method.
-     * All nodes attached to the state will be deteched, triggering the `onDetach`
-     * callback. The creator of the state will also have its `onDelete` callback
-     * triggered.
+     *
+     * All nodes attached to the state will be detached, triggering any registered
+     * `onDetach` callbacks. The creator of the state will also have its own `onDelete`
+     * callback triggered. The local `onDeatch` and `onDelete` callbacks will be
+     * executed *before* the returned Promise resolves
      *
      * @throws Throws if the method is called by a node which is not the owner of
      * the state.
@@ -136,7 +204,7 @@ declare class BaseSharedState {
     /**
      * Subscribe to state updates.
      *
-     * @param {client.SharedState~onUpdateCallback|client.SharedState~onUpdateCallback} callback
+     * @param {client.SharedState~onUpdateCallback|server.SharedState~onUpdateCallback} callback
      *  Callback to execute when an update is applied on the state.
      * @param {Boolean} [executeListener=false] - Execute the callback immediately
      *  with current state values. (`oldValues` will be set to `{}`, and `context` to `null`)
@@ -155,19 +223,22 @@ declare class BaseSharedState {
      */
     onUpdate(listener: any, executeListener?: boolean): client.SharedState;
     /**
-     * Register a function to execute when detaching from the state
+     * Register a function to execute when detaching from the state. The function
+     * will be executed before the `detach` promise resolves.
      *
-     * @param {Function} callback - callback to execute when detaching from the state.
-     *   wether the client as called `detach`, or the state has been deleted by its
+     * @param {Function} callback - Callback to execute when detaching from the state.
+     *   Whether the client as called `detach`, or the state has been deleted by its
      *   creator.
      */
     onDetach(callback: Function): () => boolean;
     /**
      * Register a function to execute when the state is deleted. Only called if the
-     * node was the creator of the state. Is called after `onDetach`
+     * node was the creator of the state. Is called after `onDetach` and executed
+     * before the `delete` Promise resolves.
      *
-     * @param {Function} callback - callback to execute when the state is deleted.
+     * @param {Function} callback - Callback to execute when the state is deleted.
      */
     onDelete(callback: Function): () => boolean;
 }
+import PromiseStore from './PromiseStore.js';
 //# sourceMappingURL=BaseSharedState.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"BaseSharedState.d.ts","sourceRoot":"","sources":["../../src/common/BaseSharedState.js"],"names":[],"mappings":";AAoBA;IACE,4HAwHC;IAvHC,QAAY;IACZ,cAAwB;IACxB,gBAA4B;IAE5B,eAAe;IACf,iBAAuB;IACvB,eAAe;IACf,gBAAqB;IACrB,eAAe;IACf,iBAAuB;IAGrB,eAAe;IACf,oBAAuD;IAQzD,eAAe;IACf,2BAAmC;IACnC,eAAe;IACf,2BAAmC;IACnC,eAAe;IACf,2BAAmC;IA+FrC,eAAe;IACf,qBASC;IAsND;;;;;;;;OAQG;IACH,uBAcC;IA3OD,eAAe;IACf,wBAOC;IAED,eAAe;IACf,gBAoDC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,aATW,MAAM,oBAIJ,YAAe,CAmD3B;IAED;;;;;;;;;OASG;IACH,UAPW,MAAM,SAShB;IAED;;;;;;OAMG;IACH,aAJY,MAAM,CAMjB;IAED;;;;;;;;;;OAUG;IACH,iBARW,MAAM,GAIL,MAAM,CAMjB;IAED;;;;;;;OAOG;IACH,iBAJY,MAAM,CAMjB;IAED;;;;;;OAMG;IACH,eAJY,MAAM,CAMjB;IA2BD;;;;;;;;;;;;OAYG;IACH,uBAMC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,uEAaC;IAED;;;;;;OAMG;IACH,4CAGC;IAED;;;;;OAKG;IACH,4CAGC;CACF"}
+{"version":3,"file":"BaseSharedState.d.ts","sourceRoot":"","sources":["../../src/common/BaseSharedState.js"],"names":[],"mappings":";AAyBA;IACE,yIA8JC;IA7JC,eAAe;IACf,YAAa;IACb,eAAe;IACf,kBAAyB;IACzB,eAAe;IACf,oBAA6B;IAC7B,eAAe;IACf,iBAAuB;IACvB,eAAe;IACf,gBAAqB;IACrB,eAAe;IACf,iBAAuB;IACvB,eAAe;IACf,gBAAqB;IAErB;;;OAGG;IACH,kBAAsB;IAEtB,4BAA4D;IAG1D,eAAe;IACf,oBAAuD;IAQzD,eAAe;IACf,2BAAmC;IACnC,eAAe;IACf,2BAAmC;IACnC,eAAe;IACf,2BAAmC;IAyHrC;;;;OAIG;IACH,0BAEC;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;OAIG;IACH,kCAEC;IAED;;;;OAIG;IACH,gCAEC;IAED,eAAe;IACf,wBAcC;IAED,eAAe;IACf,gBAoDC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,aATW,MAAM,oBAIJ,YAAe,CA8G3B;IAED;;;;;;;;;;OAUG;IACH,UAPW,MAAM,SAmBhB;IAED;;;;;;;;;;;;;OAaG;IACH,gBAPW,MAAM,SAmBhB;IAED;;;;;;;;OAQG;IACH,aAJY,MAAM,CAgBjB;IAED;;;;;;;;;;;;OAYG;IACH,mBAJY,MAAM,CAgBjB;IAED;;;;;;;;;;OAUG;IACH,iBARW,MAAM,GAIL,MAAM,CAMjB;IAED;;;;;;;OAOG;IACH,iBAJY,MAAM,CAMjB;IAED;;;;;;OAMG;IACH,eAJY,MAAM,CAMjB;IAED;;;;;;;;OAQG;IACH,uBAmBC;IAED;;;;;;;;;;;;;;OAcG;IACH,uBAUC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,uEAaC;IAED;;;;;;;OAOG;IACH,4CAGC;IAED;;;;;;OAMG;IACH,4CAGC;CACF;yBArrBwB,mBAAmB"}