@soundworks/core 3.7.0 → 4.0.0-alpha.1

package/types/client/Socket.d.ts

@@ -0,0 +1,138 @@
+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`.
+ *
+ * _Important: In most cases, you should consider using a {@link client.SharedState} rather than
+ * sending messages directly through 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
+ *  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'`.
+     *
+     * @private
+     */
+    private ws;
+    /**
+     * WebSocket instance w/ binary protocol, i.e. `binaryType = 'arraybuffer'`.
+     *
+     * @private
+     */
+    private binaryWs;
+    /** @private */
+    private _stringListeners;
+    /** @private */
+    private _binaryListeners;
+    /**
+     * Initialize a websocket connection with the server. Automatically called
+     * during `client.init()`
+     *
+     * @param {string} role - Role of the client (see {@link client.Client#role})
+     * @param {object} config - Configuration of the sockets
+     * @protected
+     * @ignore
+     */
+    protected init(role: string, config: object): Promise<void>;
+    /**
+     * @param {boolean} binary - Emit to either the string or binary socket.
+     * @param {string} channel - Channel name.
+     * @param {...*} args - Content of the message.
+     * @private
+     */
+    private _emit;
+    /**
+     * @param {Function[]} listeners - List of listeners, either for the string or binary socket.
+     * @param {string} channel - Channel name.
+     * @param {Function} callback - The function to be added to the listeners.
+     * @private
+     */
+    private _addListener;
+    /**
+     * @param {Function[]} listeners - List of listeners, either for the string or binary socket.
+     * @param {string} channel - Channel name.
+     * @param {Function} callback - The function to be removed from the listeners.
+     * @private
+     */
+    private _removeListener;
+    /**
+     * @param {Function[]} listeners - List of listeners, either for the string or binary socket.
+     * @param {string} [channel=null] - Channel name of the listeners to remove. If null
+     *  all the listeners are cleared.
+     * @private
+     */
+    private _removeAllListeners;
+    /**
+     * Send JSON compatible messages on a given channel.
+     *
+     * @param {string} channel - Channel name of the message.
+     * @param {...*} args - Message list, as many as needed, of any serializable type).
+     */
+    send(channel: string, ...args: any[]): void;
+    /**
+     * Listen to JSON compatible messages on a given channel.
+     *
+     * @param {string} channel - Channel name of the message.
+     * @param {Function} callback - Callback to execute when a message is received.
+     */
+    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 {Function} callback - Callback to remove.
+     */
+    removeListener(channel: string, callback: Function): void;
+    /**
+     * Remove all listeners from JSON compatible messages on a given channel.
+     *
+     * @param {string} channel - Channel name of the message.
+     */
+    removeAllListeners(channel?: string): void;
+    /**
+     * Send binary messages on a given channel.
+     *
+     * @param {string} channel - Channel name of the message.
+     * @param {TypedArray} typedArray - Binary data to be sent.
+     */
+    sendBinary(channel: string, typedArray: TypedArray): void;
+    /**
+     * Listen binary messages on a given channel.
+     *
+     * @param {string} channel - Channel name of the message.
+     * @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
+     *
+     * @param {string} channel - Channel of the message.
+     * @param {Function} callback - Callback to cancel.
+     */
+    removeBinaryListener(channel: string, callback: Function): void;
+    /**
+     * Remove all listeners from 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

@@ -0,0 +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"}

package/types/client/StateManager.d.ts

@@ -0,0 +1,72 @@
+export default StateManager;
+export namespace client {
+    /**
+     * ~ObserveCallback
+     */
+    type StateManager = () => any;
+}
+/**
+ * @callback client.StateManager~ObserveCallback
+ * @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
+ */
+/**
+ * The `StateManager` allows to create new {@link client.SharedState}s, or attach
+ * to {@link client.SharedState}s created by other nodes (clients or server). It
+ * can also track all the {@link client.SharedState}s created by other nodes.
+ *
+ * An instance of `StateManager` is automatically created by the `soundworks.Client`
+ * at initialization (cf. {@link client.Client#stateManager}).
+ *
+ * See {@link client.Client#stateManager}
+ *
+ * Tutorial: {@link https://soundworks.dev/guide/state-manager.html}
+ *
+ * ```
+ * // server-side
+ * import { Server } from '@soundworks/server/index.js';
+ *
+ * const server = new Server(config);
+ * // declare and register the schema of a shared state.
+ * server.stateManager.registerSchema('some-global-state', {
+ *   myRandom: {
+ *     type: 'float',
+ *     default: 0,
+ *   }
+ * });
+ *
+ * await server.start();
+ *
+ * // create a global state server-side
+ * const globalState = await server.stateManager.create('some-global-state');
+ * // listen and react to the changes made by the clients
+ * globalState.onUpdate(updates => console.log(updates));
+ * ```
+ *
+ * ```
+ * // client-side
+ * import { Client } from '@soundworks/client.index.js';
+ *
+ * const client = new Client(config);
+ * await client.start();
+ *
+ * // attach to the global state created by the server
+ * const globalState = await client.stateManager.attach('some-global-state');
+ *
+ * // update the value of a `myRandom` parameter every seconds
+ * setInterval(() => {
+ *   globalState.set({ myRandom: Math.random() });
+ * }, 1000);
+ * ```
+ *
+ * @memberof client
+ * @extends BaseStateManager
+ * @inheritdoc
+ * @hideconstructor
+ */
+declare class StateManager extends BaseStateManager {
+}
+import BaseStateManager from "../common/BaseStateManager.js";
+//# sourceMappingURL=StateManager.d.ts.map

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

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

package/types/client/index.d.ts

@@ -0,0 +1,11 @@
+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/client/index.d.ts.map

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

package/types/common/BasePlugin.d.ts

@@ -0,0 +1,145 @@
+export default BasePlugin;
+/**
+ * @private
+ */
+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;
+    /**
+     * Options of the plugin.
+     *
+     * @type {object}
+     */
+    options: object;
+    /**
+     * Placeholder that stores internal (local) state of the plugin. The state
+     * should be modified through the `propagateStateChange` method to ensure
+     * the change to be properly propagated to `onStateChange` callbacks.
+     *
+     * @type {object}
+     * @protected
+     * @see {@link client.Plugin#onStateChange}
+     * @see {@link server.Plugin#onStateChange}
+     * @see {@link client.Plugin#propagateStateChange}
+     * @see {@link server.Plugin#propagateStateChange}
+     */
+    protected state: object;
+    /**
+     * Current status of the plugin, i.e. 'idle', 'inited', 'started', 'errored'
+     *
+     * @type {string}
+     */
+    status: string;
+    /** @private */
+    private _onStateChangeCallbacks;
+    /**
+     * Start the plugin. This method is automatically called during the client or
+     * server `init()` lifecyle step. After `start()` is fulfilled the plugin should
+     * be ready to use.
+     *
+     * @example
+     * // server-side couterpart of a plugin that creates a dedicated global shared
+     * // state on which the server-side part can attach.
+     * class MyPlugin extends Plugin {
+     *   constructor(server, id) {
+     *     super(server, id);
+     *
+     *     this.server.stateManager.registerSchema(`my-plugin:${this.id}`, {
+     *       someParam: {
+     *         type: 'boolean',
+     *         default: false,
+     *       },
+     *       // ...
+     *     });
+     *   }
+     *
+     *   async start() {
+     *     await super.start()
+     *     this.sharedState = await this.server.stateManager.create(`my-plugin:${this.id}`);
+     *   }
+     *
+     *   async stop() {
+     *     await this.sharedState.delete();
+     *   }
+     * }
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the plugin. This method is automatically called during the client or server
+     * `stop()` lifecyle step.
+     *
+     * @example
+     * // server-side couterpart of a plugin that creates a dedicated global shared
+     * // state on which the server-side part can attach.
+     * class MyPlugin extends Plugin {
+     *   constructor(server, id) {
+     *     super(server, id);
+     *
+     *     this.server.stateManager.registerSchema(`my-plugin:${this.id}`, {
+     *       someParam: {
+     *         type: 'boolean',
+     *         default: false,
+     *       },
+     *       // ...
+     *     });
+     *   }
+     *
+     *   async start() {
+     *     await super.start()
+     *     this.sharedState = await this.server.stateManager.create(`my-plugin:${this.id}`);
+     *     this.sharedState.onUpdate(updates => this.doSomething(updates));
+     *   }
+     *
+     *   async stop() {
+     *     await this.sharedState.delete();
+     *   }
+     * }
+     */
+    stop(): Promise<void>;
+    /**
+     * Listen to the state changes propagated by {@link BasePlugin.propagateStateChange}
+     *
+     * @param {client.Plugin~onStateChangeCallback|server.Plugin~onStateChangeCallback} callback -
+     *  Callback to execute when a state change is propagated.
+     * @returns {client.Plugin~deleteOnStateChangeCallback|server.Plugin~deleteOnStateChangeCallback}
+     *  Execute the function to delete the listener from the callback list.
+     * @see {@link client.Plugin#propagateStateChange}
+     * @see {@link server.Plugin#propagateStateChange}
+     * @example
+     * const unsubscribe = plugin.onStateChange(pluginState => console.log(pluginState));
+     * // stop listening state changes
+     * unsubscribe();
+     */
+    onStateChange(callback: any): client.Plugin;
+    /**
+     * Apply updates to the plugin state and propagate the updated state to the
+     * `onStateChange` listeners. The state changes will also be propagated
+     * through the `PluginManager#onStateChange` listeners.
+     *
+     * @param {object} updates - Updates to be merged in the plugin state.
+     * @see {@link client.Plugin#onStateChange}
+     * @see {@link server.Plugin#onStateChange}
+     * @see {@link client.PluginManager#onStateChange}
+     * @see {@link server.PluginManager#onStateChange}
+     */
+    propagateStateChange(updates: object): void;
+}
+//# sourceMappingURL=BasePlugin.d.ts.map

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

@@ -0,0 +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"}

package/types/common/BasePluginManager.d.ts

@@ -0,0 +1,88 @@
+export default BasePluginManager;
+/**
+ * Shared functionnality between server-side and client-size plugin manager
+ *
+ * @private
+ */
+declare class BasePluginManager {
+    constructor(node: any);
+    /** @private */
+    private _node;
+    /** @private */
+    private _registeredPlugins;
+    /** @private */
+    private _instances;
+    /** @private */
+    private _instanceStartPromises;
+    /** @private */
+    private _onStateChangeCallbacks;
+    status: string;
+    /**
+     * Register a plugin into soundworks.
+     *
+     * _A plugin must always be registered both on client-side and on server-side_
+     *
+     * Refer to the plugin documentation to check its options and proper way of
+     * registering it.
+     *
+     * @param {string} id - Unique id of the plugin. Enables the registration of the
+     *  same plugin factory under different ids.
+     * @param {Function} factory - Factory function that returns the Plugin class.
+     * @param {object} [options={}] - Options to configure the plugin.
+     * @param {array} [deps=[]] - List of plugins' names the plugin depends on, i.e.
+     *  the plugin initialization will start only after the plugins it depends on are
+     *  fully started themselves.
+     * @see {@link client.PluginManager#register}
+     * @see {@link server.PluginManager#register}
+     * @example
+     * // client-side
+     * client.pluginManager.register('user-defined-id', pluginFactory);
+     * // server-side
+     * server.pluginManager.register('user-defined-id', pluginFactory);
+     */
+    register(id: string, ctor: any, options?: object, deps?: any[]): void;
+    /**
+     * Initialize all the registered plugin. Executed during the `Client.init()` or
+     * `Server.init()` initialization step.
+     * @private
+     */
+    private start;
+    stop(): Promise<void>;
+    /**
+     * 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.
+     *
+     * @private
+     */
+    private getUnsafe;
+    /**
+     * 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
+     * plugin instance that initiated the state change event as second parameter.
+     *
+     * _In most cases, you should not have to rely on this method._
+     *
+     * @param {client.PluginManager~onStateChangeCallback|server.PluginManager~onStateChangeCallback} callback
+     *  Callback to be executed on state change
+     * @param {client.PluginManager~deleteOnStateChangeCallback|client.PluginManager~deleteOnStateChangeCallback}
+     *  Function to execute to listening for changes.
+     * @example
+     * const unsubscribe = client.pluginManager.onStateChange(pluginList, initiator => {
+     *   // log the current status of all plugins
+     *   for (let name in pluginList) {
+     *     console.log(name, pluginList[name].status);
+     *   }
+     *   // if the change was initiated by a plugin, log its status and state
+     *   if (initiator !== null) {
+     *.    console.log(initiator.name, initiator.status, initiator.state);
+     *   }
+     * });
+     * // stop listening for updates later
+     * unsubscribe();
+     */
+    onStateChange(callback: any): () => boolean;
+    /** @private */
+    private _propagateStateChange;
+}
+//# sourceMappingURL=BasePluginManager.d.ts.map

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

@@ -0,0 +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"}

package/types/common/BaseSharedState.d.ts

@@ -0,0 +1,173 @@
+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;
+    /** @private */
+    private _isOwner;
+    /** @private */
+    private _client;
+    /** @private */
+    private _manager;
+    /** @private */
+    private _parameters;
+    /** @private */
+    private _onUpdateCallbacks;
+    /** @private */
+    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();
+     */
+    detach(): Promise<any>;
+    /** @private */
+    private _clearTransport;
+    /** @private */
+    private _commit;
+    /**
+     * Update values of the state.
+     *
+     * The returned `Promise` resolves on the applied updates, when all the `onUpdate`
+     * callbacks have resolved themselves, i.e.:
+     *
+     * ```js
+     * server.stateManager.registerSchema('test', {
+     *   myBool: { type: 'boolean', default: false },
+     * });
+     * const a = await server.stateManager.create('a');
+     * let asyncCallbackCalled = false;
+     *
+     * a.onUpdate(updates => {
+     *   return new Promise(resolve => {
+     *     setTimeout(() => {
+     *       asyncCallbackCalled = true;
+     *       resolve();
+     *     }, 100);
+     *   });
+     * });
+     *
+     * const updates = await a.set({ myBool: true });
+     * assert.equal(asyncCallbackCalled, true);
+     * assert.deepEqual(updates, { myBool: true });
+     * ```
+     *
+     * @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.
+     * @returns {Promise<Object>} A promise to the (coerced) updates.
+     * @example
+     * const state = await client.state.attach('globals');
+     * const updates = await state.set({ myParam: Math.random() });
+     */
+    set(updates: object, context?: mixed): Promise<any>;
+    /**
+     * Get the value of a paramter of the state.
+     *
+     * @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');
+     */
+    get(name: string): mixed;
+    /**
+     * Get all the key / value pairs of the state.
+     *
+     * @return {object}
+     * @example
+     * const values = state.getValues();
+     */
+    getValues(): object;
+    /**
+     * Get the schema from which the state 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 state.
+     * @return {object}
+     * @example
+     * const schema = state.getSchema();
+     */
+    getSchema(name?: string): object;
+    /**
+     * Get the values with which the state has been created. May defer from the
+     * default values declared in the schema.
+     *
+     * @return {object}
+     * @example
+     * const initValues = state.getInitValues();
+     */
+    getInitValues(): object;
+    /**
+     * Get the default values as declared in the schema.
+     *
+     * @return {object}
+     * @example
+     * const defaults = state.getDefaults();
+     */
+    getDefaults(): object;
+    /**
+     * 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.
+     *
+     * @throws Throws if the method is called by a node which is not the owner of
+     * the state.
+     * @example
+     * const state = await client.state.create('my-schema-name');
+     * // later
+     * await state.delete();
+     */
+    delete(): Promise<any>;
+    /**
+     * Subscribe to state updates.
+     *
+     * @param {client.SharedState~onUpdateCallback|client.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`)
+     * @returns {client.SharedState~deleteOnUpdateCallback|server.SharedState~deleteOnUpdateCallback}
+     * @example
+     * const unsubscribe = state.onUpdate(async (newValues, oldValues, context) =>  {
+     *   for (let [key, value] of Object.entries(newValues)) {
+     *      switch (key) {
+     *        // do something
+     *      }
+     *   }
+     * });
+     *
+     * // later
+     * unsubscribe();
+     */
+    onUpdate(listener: any, executeListener?: boolean): client.SharedState;
+    /**
+     * Register a function to execute when detaching from the state
+     *
+     * @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
+     *   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`
+     *
+     * @param {Function} callback - callback to execute when the state is deleted.
+     */
+    onDelete(callback: Function): () => boolean;
+}
+//# sourceMappingURL=BaseSharedState.d.ts.map

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

@@ -0,0 +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"}