@soundworks/core 3.7.0 → 4.0.0-alpha.0

package/types/client/Client.d.ts

@@ -0,0 +1,194 @@
+export default Client;
+/**
+ * The `Client` class is the main entry point for  the client-side of soundworks
+ * application.
+ *
+ * A `Client` instance allows to access soundworks components such as {@link client.StateManager},
+ * {@link client.PluginManager},{@link client.Socket} or {@link client.ContextManager}.
+ * Its is also responsible for handling the initialization lifecycles of the different
+ * soundworks components.
+ *
+ * ```
+ * import { Client } from '@soundworks/core/client.js';
+ * // create a new soundworks `Client` instance
+ * const client = new Client({ role: 'player' });
+ * // init and start the client
+ * await client.start();
+ * ```
+ *
+ * @memberof client
+ */
+declare class Client {
+    /**
+     * @param {client.BrowserClientConfig|client.NodeClientConfig} config -
+     *  Configuration of the soundworks client.
+     * @throws Will throw if the given config object is invalid.
+     */
+    constructor(config: client.BrowserClientConfig | client.NodeClientConfig);
+    /**
+     * Role of the client in the application.
+     *
+     * @type {string}
+     */
+    role: string;
+    /**
+     * Configuration object.
+     *
+     * @type {client.BrowserClientConfig|client.NodeClientConfig}
+     */
+    config: client.BrowserClientConfig | client.NodeClientConfig;
+    /**
+     * Session id of the client (incremeted positive number), generated and
+     * retrieved by the server during `client.init`. The counter is reset when
+     * the server restarts.
+     *
+     * @type {number}
+     */
+    id: number;
+    /**
+     * Unique session uuid of the client (uuidv4), generated and retrieved by
+     * the server during {@link client.Client#init}.
+     *
+     * @type {string}
+     */
+    uuid: string;
+    /**
+     * Instance of the {@link client.Socket} class that handle websockets communications with
+     * the server.
+     *
+     * @see {@link client.Socket}
+     * @type {client.Socket}
+     */
+    socket: client.Socket;
+    /**
+     * Runtime platform on which the client is executed, i.e. 'browser' or 'node'.
+     *
+     * @type {string}
+     */
+    target: string;
+    /**
+     * Instance of the {@link client.ContextManager} class.
+     *
+     * The context manager can be safely used after `client.init()` has been fulfilled.
+     *
+     * @see {@link client.ContextManager}
+     * @type {client.ContextManager}
+     */
+    contextManager: client.ContextManager;
+    /**
+     * Instance of the {@link client.PluginManager} class.
+     *
+     * The context manager can be safely used after `client.init()` has been fulfilled.
+     *
+     * @see {@link client.PluginManager}
+     * @type {client.PluginManager}
+     */
+    pluginManager: client.PluginManager;
+    /**
+     * Instance of the {@link client.StateManager} class.
+     *
+     * The context manager can be safely used after `client.init()` has been fulfilled.
+     *
+     * @see {@link client.StateManager}
+     * @type {client.StateManager}
+     */
+    stateManager: client.StateManager;
+    /**
+     * Status of the client, 'idle', 'inited', 'started' or 'errored'.
+     *
+     * @type {string}
+     */
+    status: string;
+    /** @private */
+    private _onStatusChangeCallbacks;
+    /** @private */
+    private _auditState;
+    /**
+     * The `init` method is part of the initialization lifecycle of the `soundworks`
+     * client. Most of the time, the `init` method will be implicitly called by the
+     * {@link client.Client#start} method.
+     *
+     * In some situations you might want to call this method manually, in such cases
+     * the method should be called before the {@link client.Client#start} method.
+     *
+     * What it does:
+     * - connect the sockets to be server
+     * - perform the handshake with soundworks server (retrieve id, etc.)
+     * - launch the state manager
+     * - initialize all registered plugin
+     *
+     * After `await client.init()` is fulfilled, the {@link client.Client#stateManager},
+     * the {@link client.Client#pluginManager} and the {@link client.Client#socket}
+     * can be safely used.
+     *
+     * @example
+     * import { Client } from '@soundworks/core/client.js'
+     *
+     * const client = new Client(config);
+     * // optionnal explicit call of `init` before `start`
+     * await client.init();
+     * await client.start();
+     */
+    init(): Promise<void>;
+    /**
+     * The `start` method is part of the initialization lifecycle of the `soundworks`
+     * client. The `start` method will implicitly call the {@link client.Client#init}
+     * method if it has not been called manually.
+     *
+     * What it does:
+     * - optionnaly call {@link client.Client#init}
+     * - starts all the already created contexts (see {@link client.Context})
+     *
+     * @example
+     * import { Client } from '@soundworks/core/client.js'
+     *
+     * const client = new Client(config);
+     * await client.start();
+     */
+    start(): Promise<void>;
+    /**
+     * Stops all started contexts, plugins and terminates the socket connections.
+     *
+     * In most situations, you might not need to call this method. However, it can
+     * be usefull for unit testing or similar situations where you want to create
+     * and delete several clients in the same process.
+     *
+     * @example
+     * import { Client } from '@soundworks/core/client.js'
+     *
+     * const client = new Client(config);
+     * await client.start();
+     *
+     * await new Promise(resolve => setTimeout(resolve, 1000));
+     * await client.stop();
+     */
+    stop(): Promise<void>;
+    /**
+     * Attach and retrieve the global audit state of the application.
+     *
+     * The audit state is a {@link client.SharedState} instance that keeps track of
+     * global informations about the application such as, the number of connected
+     * clients, network latency estimation, etc. It is usefull for controller client
+     * roles to give the user an overview about the state of the application.
+     *
+     * The audit state is lazily attached to the client only if this method is called.
+     *
+     * @returns {Promise<client.SharedState>}
+     * @throws Will throw if called before `client.init()`
+     * @see {@link client.SharedState}
+     * @example
+     * const auditState = await client.getAuditState();
+     * auditState.onUpdate(() => console.log(auditState.getValues()), true);
+     */
+    getAuditState(): Promise<client.SharedState>;
+    /**
+     * Listen for the status change ('inited', 'started', 'stopped') of the client.
+     *
+     * @param {Function} callback - Listener to the status change.
+     * @returns {Function} Delete the listener.
+     */
+    onStatusChange(callback: Function): Function;
+    /** @private */
+    private _dispatchStatus;
+}
+//# sourceMappingURL=Client.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Client.d.ts","sourceRoot":"","sources":["../../src/client/Client.js"],"names":[],"mappings":";AAeA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACE;;;;OAIG;IACH,oBAJW,oDAAkD,EA0I5D;IApGC;;;;OAIG;IACH,MAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,QAFU,oDAAkD,CAExC;IAYpB;;;;;;OAMG;IACH,IAFU,MAAM,CAEF;IAEd;;;;;OAKG;IACH,MAFU,MAAM,CAEA;IAEhB;;;;;;OAMG;IACH,sBAA0B;IAE1B;;;;OAIG;IACH,QAFU,MAAM,CAE8B;IAE9C;;;;;;;OAOG;IACH,sCAA0C;IAE1C;;;;;;;OAOG;IACH,oCAA4C;IAE5C;;;;;;;OAOG;IACH,kCAAwB;IAExB;;;;OAIG;IACH,QAFU,MAAM,CAEI;IAEpB,eAAe;IACf,iCAAyC;IACzC,eAAe;IACf,oBAAuB;IAKzB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,sBA6DC;IAED;;;;;;;;;;;;;;OAcG;IACH,uBAmBC;IAED;;;;;;;;;;;;;;;OAeG;IACH,sBAUC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,iBAPa,2BAA2B,CAiBvC;IAED;;;;;OAKG;IACH,6CAIC;IAED,eAAe;IACf,wBAgBC;CACF"}

package/types/client/Context.d.ts

@@ -0,0 +1,139 @@
+export default Context;
+/**
+ * Base class to extend in order to implement a new Context.
+ *
+ * In the `soundworks` paradigm, a client has a "role" (e.g. _player_, _controller_)
+ * see {@link client.Client#role}) and can be in different "contexts" (e.g. different
+ * part of the experience such as sections of a music piece, etc.). This class
+ * provides a simple and unified way to model these reccuring aspects of an application.
+ *
+ * You can also think of a `Context` as a state of a state machine from which a
+ * client can `enter()` or `exit()` (be aware that `soundworks` does not provide
+ * an implementation for the state machine).
+ *
+ * Optionally, a `Context` can also have a server-side counterpart to perform
+ * some logic (e.g. updating some global shared state) when a client enters or exits
+ * the context. In such case, `soundworks` guarantees that the server-side
+ * logic is executed before the `enter()` and `exit()` promises are fulfilled.
+ *
+ * ```
+ * import { Client, Context } from '@soundworks/core/index.js'
+ *
+ * const client = new Client(config);
+ *
+ * class MyContext extends Context {
+ *   async enter() {
+ *     await super.enter();
+ *     console.log(`client ${this.client.id} entered my context`);
+ *   }
+ *
+ *   async exit() {
+ *     await super.exit();
+ *     console.log(`client ${this.client.id} exited my context`);
+ *   }
+ * }
+ * const myContext = new MyContext(client);
+ *
+ * await client.start();
+ * await myContext.enter();
+ *
+ * await new Promise(resolve => setTimeout(resolve, 2000));
+ * await myContext.exit();
+ * ```
+ *
+ * @memberof client
+ */
+declare class Context {
+    /**
+     * @param {client.Client} client - The soundworks client instance.
+     * @throws Will throw if the first argument is not a soundworks client instance.
+     */
+    constructor(client: client.Client);
+    /**
+     * The soundworks client instance.
+     */
+    client: Client;
+    /**
+     * Status of the context, i.e. 'idle', 'inited', 'started', 'errored'
+     */
+    status: string;
+    /**
+     * Name of the context. Defaults to the class name, override to use a user-defined name.
+     *
+     * @returns {string} - Name of the context.
+     * @example
+     * class MyContext extends Context {
+     *   get name() {
+     *     return 'my-user-defined-context-name';
+     *   }
+     * }
+     */
+    get name(): string;
+    /**
+     * Start the context. This method is automatically called when `await client.start()`
+     * is called, or lazilly called when entering the context (i.e. `context.enter()`)
+     * if the context has been created after `client.start()`.
+     *
+     * In some situation, you might want to implement this method to handle application
+     * wise behavior regardeless the client enters or exists the context.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the context. This method is automatically called when `await client.stop()`
+     * is called.
+     *
+     * In some situation, you might want to implement this method to handle application
+     * wise behavior regardeless the client enters or exists the context.
+     */
+    stop(): Promise<void>;
+    /**
+     * Enter the context. Implement this method to define the logic that should be
+     * done (e.g. creating a shared state, etc.) when the context is entered.
+     *
+     * If a server-side part of the context is defined (i.e. a context with the same
+     * {@link client.Context#name}), the corresponding server-side `enter()` method
+     * will be executed before the returned Promise is fulfilled.
+     *
+     * If the context has not been started yet, the `start` method is implicitely executed.
+     *
+     * @returns {Promise} - Promise that resolves when the context is entered.
+     * @example
+     * class MyContext extends Context {
+     *   async enter() {
+     *     await super.enter();
+     *     this.state = await this.client.stateManager.create('my-context-state');
+     *   }
+     *
+     *   async exit() {
+     *     await super.exit();
+     *     await this.state.delete();
+     *   }
+     * }
+     */
+    enter(): Promise<any>;
+    /**
+     * Exit the context. Implement this method to define the logic that should be
+     * done (e.g. delete a shared state, etc.) when the context is exited.
+     *
+     * If a server-side part of the context is defined (i.e. a context with the same
+     * {@link client.Context#name}), the corresponding server-side `exit()` method
+     * will be executed before the returned Promise is fulfilled.
+     *
+     * @returns {Promise} - Promise that resolves when the context is exited.
+     * @example
+     * class MyContext extends Context {
+     *   async enter() {
+     *     await super.enter();
+     *     this.state = await this.client.stateManager.create('my-context-state');
+     *   }
+     *
+     *   async exit() {
+     *     await super.exit();
+     *     await this.state.delete();
+     *   }
+     * }
+     */
+    exit(): Promise<any>;
+}
+import Client from "./Client.js";
+//# sourceMappingURL=Context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Context.d.ts","sourceRoot":"","sources":["../../src/client/Context.js"],"names":[],"mappings":";AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH;IACE;;;OAGG;IACH,mCAgDC;IA3CC;;OAEG;IACH,eAAoB;IAEpB;;OAEG;IACH,eAAoB;IAqCtB;;;;;;;;;;OAUG;IACH,mBAEC;IAED;;;;;;;OAOG;IACH,uBAAgB;IAEhB;;;;;;OAMG;IACH,sBAAe;IAEf;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,sBAeC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,qBAUC;CACF"}

package/types/client/ContextManager.d.ts

@@ -0,0 +1,45 @@
+export default ContextManager;
+/**
+ * Manage the different contexts and their lifecycle.
+ *
+ * See {@link client.Client#contextManager}
+ *
+ * _WARNING: In most cases, you should not have to manipulate the context manager directly._
+ *
+ * @memberof client
+ * @hideconstructor
+ */
+declare class ContextManager {
+    /** @private */
+    private _contexts;
+    /** @private */
+    private _contextStartPromises;
+    /**
+     * Register the context into the manager. Is called in context constructor.
+     *
+     * @param {client.Context} context - The context to be registered.
+     * @private
+     */
+    private register;
+    /**
+     * Retrieve a started context from its name.
+     *
+     * _WARNING: Most of the time, you should not have to call this method manually._
+     *
+     * @param {client.Context#name} contextName - Name of the context.
+     */
+    get(contextName: any): Promise<any>;
+    /**
+     * Start all registered contexts. Called during `client.start()`
+     *
+     * @private
+     */
+    private start;
+    /**
+     * Stop all registered contexts. Called during `client.stop()`
+     *
+     * @private
+     */
+    private stop;
+}
+//# sourceMappingURL=ContextManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ContextManager.d.ts","sourceRoot":"","sources":["../../src/client/ContextManager.js"],"names":[],"mappings":";AAuBA;;;;;;;;;GASG;AACH;IAEI,eAAe;IACf,kBAAwC;IACxC,eAAe;IACf,8BAAsC;IAGxC;;;;;OAKG;IACH,iBAMC;IAED;;;;;;OAMG;IACH,oCAyBC;IAED;;;;OAIG;IACH,cAGC;IAED;;;;OAIG;IACH,aAGC;CACF"}

package/types/client/Plugin.d.ts

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

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

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

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

package/types/client/SharedState.d.ts

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

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