@soundworks/core 4.0.0-alpha.9 → 5.0.1

package/types/client/Plugin.d.ts

@@ -1,53 +0,0 @@
-export default Plugin;
-export namespace client {
-    /**
-     * ~onStateChangeCallback
-     */
-    export type Plugin = (#state: client.Plugin) => any;
-    /**
-     * Callback executed when the plugin state is updated.
-     *
-     * @callback client.Plugin~onStateChangeCallback
-     * @param {client.Plugin#state} state - Current state of the plugin.
-     */
-    /**
-     * Delete the registered {@link client.Plugin~onStateChangeCallback}.
-     *
-     * @callback client.Plugin~deleteOnStateChangeCallback
-     */
-    /**
-     * Base class to extend in order to create new `soundworks` plugins.
-     *
-     * In the `soundworks` paradigm, a plugin is a component that allows to extend
-     * the framework capabilities by encapsulating common and reusable logic in
-     * an application wise perspective. For example, plugins are available to handle
-     * clock synchronization, to deal with the file system, etc. Plugin should always
-     * have both a client-side and a server-side part.
-     *
-     * See [https://soundworks.dev/guide/ecosystem](https://soundworks.dev/guide/ecosystem)
-     * for more informations on the available plugins.
-     *
-     * _Creating new plugins should be considered an advanced usage._
-     *
-     * @memberof client
-     * @extends BasePlugin
-     * @inheritdoc
-     */
-    class Plugin extends BasePlugin {
-        /**
-         * @param {client.Client} client - The soundworks client instance.
-         * @param {string} id - User defined id of the plugin as defined in
-         *  {@link client.PluginManager#register}.
-         */
-        constructor(client: client.Client, id: string);
-        /**
-         * Instance of soundworks client.
-         *
-         * @type {client.Client}
-         * @see {@link client.Client}
-         */
-        client: client.Client;
-    }
-}
-import BasePlugin from "../common/BasePlugin.js";
-//# sourceMappingURL=Plugin.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Plugin.d.ts","sourceRoot":"","sources":["../../src/client/Plugin.js"],"names":[],"mappings":";;;;;kCAMW,aAAa;IAJxB;;;;;OAKG;IAEH;;;;OAIG;IAEH;;;;;;;;;;;;;;;;;OAiBG;IACH;QACE;;;;WAIG;QACH,uCAHW,MAAM,EAahB;QAPC;;;;;WAKG;QACH,sBAAoB;KAevB"}

package/types/client/PluginManager.d.ts

@@ -1,96 +0,0 @@
-export default PluginManager;
-export namespace client {
-    /**
-     * ~onStateChangeCallback
-     */
-    type PluginManager = (: object, initiator: client.Plugin | null) => any;
-}
-/**
- * Callback executed when a plugin internal state is updated.
- *
- * @callback client.PluginManager~onStateChangeCallback
- * @param {object<client.Plugin#id, client.Plugin>} fullState - List of all plugins.
- * @param {client.Plugin|null} initiator - Plugin that initiated the update or `null`
- *  if the change was initiated by the state manager (i.e. when the initialization
- *  of the plugins starts).
- */
-/**
- * Delete the registered {@link client.PluginManager~onStateChangeCallback}.
- *
- * @callback client.PluginManager~deleteOnStateChangeCallback
- */
-/**
- * The `PluginManager` allows to register and retrieve `soundworks` plugins.
- *
- * 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.
- *
- * 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.).
- *
- * Refer to the plugins' documentation for more precise examples, and the specific API
- * they expose. See [https://soundworks.dev/guide/ecosystem](https://soundworks.dev/guide/ecosystem)
- * for more informations on the available plugins.
- *
- * See {@link client.Client#pluginManager}
- *
- * ```
- * import { Client } from '@soundworks/core/client.js';
- * import platformPlugin from '@soundworks/plugin-sync/client.js';
- *
- * const client = new Client(config);
- * // register the plugin before `client.start()`
- * client.pluginManager.register('sync', pluginSync);
- *
- * await client.start();
- *
- * const sync = await client.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
- * @hideconstructor
- */
-declare class PluginManager extends BasePluginManager {
-    /**
-     * @param {client.Client} client - The soundworks client instance.
-     */
-    constructor(client: client.Client);
-    register(id: any, factory: any, options?: {}, deps?: any[]): void;
-    /**
-     * Retrieve an fully started instance of a registered plugin.
-     *
-     * Be aware that the `get` method resolves only when the plugin is fully 'started',
-     * which is what we want 99.99% of the time. As such, and to prevent the application
-     * to be stuck in some kind of Promise dead lock, this method will throw if
-     * used before `client.init()` (or `client.start()`).
-     *
-     * To handle the remaining 0.01% cases and access plugin instances during their
-     * 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._
-     *
-     * @param {client.Plugin#id} id - Id of the plugin as defined when registered.
-     * @returns {client.Plugin}
-     * @see {@link client.PluginManager#onStateChange}
-     *
-     * @private
-     */
-    private get;
-    /**
-     * @protected
-     * @ignore
-     */
-    protected getRegisteredPlugins(): any[];
-}
-import BasePluginManager from "../common/BasePluginManager.js";
-//# sourceMappingURL=PluginManager.d.ts.map

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

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

package/types/client/SharedState.d.ts

@@ -1,85 +0,0 @@
-export default SharedState;
-export namespace client {
-    /**
-     * ~onUpdateCallback
-     */
-    type SharedState = (newValues: any, oldValues: any, context?: Mixed) => any;
-}
-/**
- * @callback client.SharedState~onUpdateCallback
- * @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.
- */
-/**
- * Delete the registered {@link client.SharedState~onUpdateCallback}.
- *
- * @callback client.SharedState~deleteOnUpdateCallback
- */
-/**
- * The `SharedState` is one of the most important and versatile abstraction provided
- * by `soundworks`. It represents a set of parameters that are synchronized accross
- * every nodes of the application (clients and server) that declared some interest
- * to the shared state.
- *
- * A `SharedState` is created according to a "schema" (in the sense of a database
- * schema) that must be declared and registered server-side. Any number of `SharedState`s
- * can be created from a single schema.
- *
- * A shared state can be created both by the clients or by the server (in which case
- * it is generally considered as a global state of the application). Similarly any
- * node of the application (clients or server) can declare interest and "attach" to
- * a state created by another node. All node attached to a state can modify its values
- * and/or react to the modifications applied by other nodes.
- *
- * 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 BaseSharedState
- * @inheritdoc
- * @hideconstructor
- */
-declare class SharedState extends BaseSharedState {
-}
-import BaseSharedState from "../common/BaseSharedState.js";
-//# sourceMappingURL=SharedState.d.ts.map

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

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

package/types/client/Socket.d.ts

@@ -1,138 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

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

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

@@ -1 +0,0 @@
-{"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.map

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

@@ -1,173 +0,0 @@
-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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"BaseStateManager.d.ts","sourceRoot":"","sources":["../../src/common/BaseStateManager.js"],"names":[],"mappings":";AAoBA;;GAEG;AACH;IACE;;;;OAIG;IACH,wCA4FC;IA3FC;;;MAA+B;IAE/B,2BAA4B;IAC5B,4BAAkC;IAClC,8BAA+B;IAC/B,wCAAyC;IAwF3C;;;;;;;;;;;OAWG;IACH,8CANa,uCAAqC,CAYjD;IAED;;;;;;;;;;;;;OAaG;IACH,2CANa,uCAAqC,CAajD;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,wBAXa,iBAAiB,CAoB7B;CACF"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"ParameterBag.d.ts","sourceRoot":"","sources":["../../src/common/ParameterBag.js"],"names":[],"mappings":";;;;;;;;;;QA8MoB,kEAMf;;;;;QAOe,0EAMf;;;;;;QAUe,8CAgBf;QACe,0EAMf;;;;;;QAUe,gDAgBf;;QACe,0EAMf;;;;;;QAOe,uEAOf;;;;;;;QAOe,uEAGf;;;;;;;;;;;;;;;;;;;;;;;AAKL;;;GAGG;AACH;IACE,yCAsBC;IAED,0CAsEC;IA9DC;;;;;;;;OAQG;IACH,gBAAiB;IAEjB;;;;;;;;OAQG;IACH,gBAAiB;IA4CnB;;;;;OAKG;IACH,2BAEC;IAED;;;;OAIG;IACH,iBAQC;IAED;;;;;;OAMG;IACH,yBAUC;IAED;;;;;;;;;;OAUG;IACH,uCAuBC;IAED;;;;;;OAMG;IAWH;;;;OAIG;IACH,2BAUC;IAGD,oBAMC;IAGD,kBAMC;CACF"}

package/types/common/SharedStatePrivate.d.ts

@@ -1,20 +0,0 @@
-export default SharedStatePrivate;
-/**
- * The "real" state, this instance is kept private by the server.StateManager.
- * It cannot be accessed without a SharedState proxy
- * @private
- */
-declare class SharedStatePrivate {
-    constructor(id: any, schemaName: any, schema: any, manager: any, initValues?: {});
-    id: any;
-    schemaName: any;
-    _manager: any;
-    _parameters: ParameterBag;
-    _attachedClients: Map<any, any>;
-    _creatorRemoteId: any;
-    _creatorId: any;
-    _attachClient(remoteId: any, client: any, isOwner?: boolean): void;
-    _detachClient(remoteId: any, client: any): void;
-}
-import ParameterBag from "../common/ParameterBag.js";
-//# sourceMappingURL=SharedStatePrivate.d.ts.map

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

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

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/common/logger.js"],"names":[],"mappings":";;;IASE,uCAEC;IAED,+BAOC;IAED,gEAgEC;IAED,0DAMC;IAED,sCAMC;IAED,wCAMC;IAED,sCAMC;IAED,wCAMC;IAED,6BAMC;IAED,8BAMC;IAED,+BAMC"}

package/types/common/promise-store.d.ts

@@ -1,4 +0,0 @@
-export function storeRequestPromise(resolve: any, reject: any): number | void;
-export function resolveRequest(reqId: any, data: any): void;
-export function rejectRequest(reqId: any, data: any): void;
-//# sourceMappingURL=promise-store.d.ts.map

package/types/common/promise-store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"promise-store.d.ts","sourceRoot":"","sources":["../../src/common/promise-store.js"],"names":[],"mappings":"AAKA,8EAKC;AAED,4DAKC;AAED,2DAKC"}

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

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

package/types/common/utils.d.ts

@@ -1,5 +0,0 @@
-export function idGenerator(): Generator<number, void, unknown>;
-export function isString(val: any): boolean;
-export function isFunction(func: any): boolean;
-export const isBrowser: Function;
-//# sourceMappingURL=utils.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/common/utils.js"],"names":[],"mappings":"AAGA,gEAQC;AAED,4CAEC;AAED,+CAGC;AAnBD,iCAA6F"}