@soundworks/core 4.0.0-alpha.9 → 5.0.1

package/types/server/Client.d.ts

@@ -1,40 +0,0 @@
-export default Client;
-/**
- * Server-side representation of a `soundworks` client.
- *
- * @memberof server
- * @hideconstructor
- * @see {@link client.Client}
- */
-declare class Client {
-    /**
-     * @param {String} role - Role of the client
-     * @param {server.Socket} socket - Socket connection with the client
-     */
-    constructor(role: string, socket: server.Socket);
-    /**
-     * Client role, as specified in client side config {@link client.Client}.
-     *
-     * @type {String}
-     */
-    role: string;
-    /**
-     * Session Id (incremented positive number).
-     *
-     * @type {Number}
-     */
-    id: number;
-    /**
-     * Unique session Id (uuidv4).
-     *
-     * @type {String}
-     */
-    uuid: string;
-    /**
-     * Socket connection with the remote client {@link client.Client}.
-     *
-     * @type {server.Socket}
-     */
-    socket: server.Socket;
-}
-//# sourceMappingURL=Client.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Client.d.ts","sourceRoot":"","sources":["../../src/server/Client.js"],"names":[],"mappings":";AAMA;;;;;;GAMG;AACH;IACE;;;OAGG;IACH,iDA4BC;IA3BC;;;;OAIG;IACH,aAAgB;IAEhB;;;;OAIG;IACH,WAAiC;IAEjC;;;;OAIG;IACH,aAAkB;IAElB;;;;OAIG;IACH,sBAAoB;CAEvB"}

package/types/server/Context.d.ts

@@ -1,59 +0,0 @@
-export default Context;
-/**
- * Base class to extend in order to create the server-side counterpart of
- * a {@link client.Context}. If not defined, a default context will be created
- * and used by the server.
- *
- * @memberof server
- */
-declare class Context {
-    constructor(server: any, roles?: any[]);
-    /**
-     * soundworks server
-     * @type {server.Server}
-     */
-    server: server.Server;
-    /**
-     * List of clients that are currently in this context
-     * @type {Client[]}
-     */
-    clients: Client[];
-    /**
-     * Status of the context ('idle', 'inited', 'started' or 'errored')
-     * @type {String}
-     */
-    status: string;
-    roles: Set<any>;
-    /**
-     * Name of the context, default to the class name.
-     * Override the `get name()` getter to use a user-defined context name.
-     */
-    get name(): string;
-    /**
-     * Method automatically called when the server starts, or lazilly called if
-     * the context is created after `server.start()`
-     *
-     * _WARNING: this method should never be called manually._
-     */
-    start(): Promise<void>;
-    /**
-     * Method automatically called when the server stops.
-     *
-     * _WARNING: this method should never be called manually._
-     */
-    stop(): Promise<void>;
-    /**
-     * Method automatically called when the client enters the context.
-     *
-     * _WARNING: this method should never be called manually._
-     */
-    enter(client: any): Promise<void>;
-    /**
-     * Method automatically called when the client exits the context.
-     *
-     * _WARNING: this method should never be called manually._
-     */
-    exit(client: any): Promise<void>;
-}
-import Client from "./Client.js";
-//# sourceMappingURL=Context.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Context.d.ts","sourceRoot":"","sources":["../../src/server/Context.js"],"names":[],"mappings":";AAGA;;;;;;GAMG;AACH;IACE,wCAmCC;IA1BC;;;OAGG;IACH,sBAAoB;IAEpB;;;OAGG;IACH,SAFU,MAAM,EAAE,CAEM;IAExB;;;OAGG;IACH,eAAoB;IAMpB,gBAA2B;IAM7B;;;OAGG;IACH,mBAEC;IAED;;;;;OAKG;IACH,uBAAgB;IAEhB;;;;OAIG;IACH,sBAAe;IAEf;;;;OAIG;IACH,kCAMC;IAED;;;;OAIG;IACH,iCAMC;CACF"}

package/types/server/ContextManager.d.ts

@@ -1,69 +0,0 @@
-export default ContextManager;
-/**
- * Manage the different server-side contexts and their lifecycle. The `ContextManager`
- * is automatically instantiated by the {@link server.Server}.
- *
- * _WARNING: Most of the time, you should not have to manipulate the context manager directly._
- *
- * @memberof server
- */
-declare class ContextManager {
-    /**
-     * @param {server.Server} server - Instance of the soundworks server.
-     */
-    constructor(server: server.Server);
-    /** @private */
-    private server;
-    /** @private */
-    private _contexts;
-    /** @private */
-    private _contextStartPromises;
-    /**
-     * Register a context in the manager.
-     * This method is called in the {@link server.Context} constructor
-     *
-     * @param {server.Context} context - Context instance to register.
-     *
-     * @private
-     */
-    private register;
-    /**
-     * Retrieve a started context from its name.
-     *
-     * @see {server.Context#name}
-     * @param {String} contextName - Name of the context.
-     *
-     * @private
-     */
-    private get;
-    /**
-     * Called when a client connects to the server (websocket handshake)
-     *
-     * @param {server.Client} client
-     *
-     * @private
-     */
-    private addClient;
-    /**
-     * Called when a client connects to the server (websocket 'close' event)
-     *
-     * @param {server.Client} client
-     *
-     * @private
-     */
-    private removeClient;
-    /**
-     * Start all contexts registered before `await server.start()`.
-     * Called on {@link server.Server#start}
-     *
-     * @private
-     */
-    private start;
-    /**
-     * Stop all contexts. Called on {@link server.Server#stop}
-     *
-     * @private
-     */
-    private stop;
-}
-//# sourceMappingURL=ContextManager.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ContextManager.d.ts","sourceRoot":"","sources":["../../src/server/ContextManager.js"],"names":[],"mappings":";AAoDA;;;;;;;GAOG;AACH;IACE;;OAEG;IACH,mCAOC;IANC,eAAe;IACf,eAAoB;IACpB,eAAe;IACf,kBAAwC;IACxC,eAAe;IACf,8BAAsC;IAGxC;;;;;;;OAOG;IACH,iBAOC;IAED;;;;;;;OAOG;IACH,YAyBC;IAED;;;;;;OAMG;IACH,kBA0FC;IAED;;;;;;OAMG;IACH,qBAUC;IAED;;;;;OAKG;IACH,cAGC;IAED;;;;OAIG;IACH,aAGC;CACF"}

package/types/server/Plugin.d.ts

@@ -1,70 +0,0 @@
-export default Plugin;
-export namespace server {
-    /**
-     * ~onStateChangeCallback
-     */
-    export type Plugin = (#state: server.Plugin) => any;
-    /**
-     * Callback executed when the plugin state is updated.
-     *
-     * @callback server.Plugin~onStateChangeCallback
-     * @param {server.Plugin#state} state - Current state of the plugin.
-     */
-    /**
-     * Delete the registered {@link server.Plugin~onStateChangeCallback}.
-     *
-     * @callback server.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 server
-     * @extends BasePlugin
-     * @inheritdoc
-     */
-    class Plugin extends BasePlugin {
-        /**
-         * @param {server.Server} server - The soundworks server instance.
-         * @param {string} id - User defined id of the plugin as defined in
-         *  {@link server.PluginManager#register}.
-         */
-        constructor(server: server.Server, id: string);
-        /**
-         * Instance of soundworks server.
-         * @type {server.Server}
-         * @see {@link server.Server}
-         */
-        server: server.Server;
-        /** @private */
-        private clients;
-        /**
-         * Method called when a client (which registered the client-side plugin),
-         * connects to the application. Override this method if you need to perform
-         * some particular logic (e.g. creating a shared state) for each clients.
-         *
-         * @param {server.Client} client
-         */
-        addClient(client: server.Client): Promise<void>;
-        /**
-         * Method called when a client (which registered the client-side plugin),
-         * disconnects from the application. Override this method if you need to perform
-         * some particular logic (e.g. creating a shared state) for each clients.
-         *
-         * @param {server.Client} client
-         */
-        removeClient(client: server.Client): Promise<void>;
-    }
-}
-import BasePlugin from "../common/BasePlugin.js";
-//# sourceMappingURL=Plugin.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Plugin.d.ts","sourceRoot":"","sources":["../../src/server/Plugin.js"],"names":[],"mappings":";;;;;kCAMW,aAAa;IAJxB;;;;;OAKG;IAEH;;;;OAIG;IAEH;;;;;;;;;;;;;;;;;OAiBG;IACH;QACE;;;;WAIG;QACH,uCAHW,MAAM,EAehB;QATC;;;;WAIG;QACH,sBAAoB;QAEpB,eAAe;QACf,gBAAwB;QAG1B;;;;;;WAMG;QACH,gDAEC;QAED;;;;;;WAMG;QACH,mDAEC;KACF"}

package/types/server/PluginManager.d.ts

@@ -1,91 +0,0 @@
-export default PluginManager;
-export namespace server {
-    /**
-     * ~onStateChangeCallback
-     */
-    type PluginManager = (: object, initiator: server.Plugin | null) => any;
-}
-/**
- * Callback executed when a plugin internal state is updated.
- *
- * @callback server.PluginManager~onStateChangeCallback
- * @param {object<server.Plugin#id, server.Plugin>} fullState - List of all plugins.
- * @param {server.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 server.PluginManager~onStateChangeCallback}.
- *
- * @callback server.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.
- *
- * ```
- * import { Server } from '@soundworks/core/server.js';
- * import platformPlugin from '@soundworks/plugin-sync/server.js';
- *
- * const server = new Server(config);
- * // register the plugin before `server.start()`
- * server.pluginManager.register('sync', pluginSync);
- *
- * 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 server
- * @extends BasePluginManager
- * @inheritdoc
- * @hideconstructor
- */
-declare class PluginManager extends BasePluginManager {
-    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 `server.init()` (or `server.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 {server.Plugin#id} id - Id of the plugin as defined when registered.
-     * @returns {server.Plugin}
-     * @see {@link server.PluginManager#onStateChange}
-     *
-     * @private
-     */
-    private get;
-    /** private */
-    checkRegisteredPlugins(registeredPlugins: any): void;
-    /** @private */
-    private addClient;
-    /** @private */
-    private removeClient;
-}
-import BasePluginManager from "../common/BasePluginManager.js";
-//# sourceMappingURL=PluginManager.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"PluginManager.d.ts","sourceRoot":"","sources":["../../src/server/PluginManager.js"],"names":[],"mappings":";;;;;4BAQW,MAAM,aACN,gBAAc,IAAI;;AAL7B;;;;;;;;GAQG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH;IASE,mEAQC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,YAMC;IAID,cAAc;IACd,qDAYC;IAED,eAAe;IACf,kBAUC;IAED,eAAe;IACf,qBAUC;CACF"}

package/types/server/Server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Server.d.ts","sourceRoot":"","sources":["../../src/server/Server.js"],"names":[],"mappings":";AA2EA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IACE,yBA2IC;IAvIC;;;;;;;;;;;;;;;;;;OAkBG;IACH,YAA+C;IAuC/C;;;OAGG;IACH,YAAuB;IAIvB;;;OAGG;IACH,gBAAsB;IAEtB;;;;OAIG;IACH,WAAyC;IAEzC;;;;;OAKG;IACH,wBAA4B;IAE5B;;;;OAIG;IACH,oCAA4C;IAE5C;;;;OAIG;IACH,kCAAsC;IAEtC;;;OAGG;IACH,+BAA8C;IAE9C;;;OAGG;IACH;;;;;;;;;;;;;;;;;;;;;;;;MAAsB;IAEtB;;OAEG;IACH,eAAoB;IAEpB,eAAe;IACf,mCAIC;IAED,eAAe;IACf,iCAAyC;IACzC,eAAe;IACf,oBAAuB;IASzB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,sBAwMC;IAED;;;;;;;;;;;;OAYG;IACH,sBAoFC;IAGD;;;OAGG;IACH,sBAgBC;IAED;;;OAGG;IACH,yBAgEC;IAED;;;OAGG;IACH,4BAmEC;IAED;;;;;;;OAOG;IACH,2BAmBC;IAED,6CAIC;IAED,eAAe;IACf,wBAgBC;IAED;;;;;;;;;;;;;;OAcG;IACH,iCAsBC;IAED;;;;;;OAMG;IACH,4CAEC;IAED;;;;OAIG;IACH,8BAMC;CACF"}

package/types/server/SharedState.d.ts

@@ -1,86 +0,0 @@
-export default SharedState;
-export namespace server {
-    /**
-     * ~onUpdateCallback
-     */
-    type SharedState = (newValues: any, oldValues: any, context?: Mixed) => any;
-}
-/**
- * @callback server.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 server.SharedState~onUpdateCallback}.
- *
- * @callback server.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 server
- * @extends BaseSharedState
- * @inheritdoc
- * @hideconstructor
- * @see {server.StateManager}
- */
-declare class SharedState extends BaseSharedState {
-}
-import BaseSharedState from "../common/BaseSharedState.js";
-//# sourceMappingURL=SharedState.d.ts.map

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

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

package/types/server/Socket.d.ts

@@ -1,128 +0,0 @@
-export default Socket;
-/**
- * Simple wrapper with simple pubsub system built on top of `ws` sockets.
- * The abstraction contains two different socket:
- * - one configured for string (JSON compatible) messages
- * - one configured with `binaryType=arraybuffer` for streaming data more
- *   efficiently.
- *
- * @see https://github.com/websockets/ws
- *
- * @memberof server
- */
-declare class Socket {
-    constructor(ws: any, binaryWs: any, rooms: any, sockets: any, options?: {});
-    /**
-     * Reference to the sockets object, is mainly dedicated to allow
-     * broadcasting from a given socket instance.
-     * @type {server.Sockets}
-     * @example
-     * socket.sockets.broadcast('my-room', this, 'update-value', 1);
-     */
-    sockets: server.Sockets;
-    /**
-     * `ws` socket instance configured with `binaryType=blob` (string)
-     * @private
-     * @type {Object}
-     */
-    private ws;
-    /**
-     * `ws` socket instance configured with `binaryType=arraybuffer` (TypedArray)
-     * @private
-     * @type {Object}
-     */
-    private binaryWs;
-    /**
-     * `ws` socket instance configured with `binaryType=arraybuffer` (TypedArray)
-     * @private
-     * @type {Map}
-     */
-    private rooms;
-    /**
-     * Configuration object
-     * @type {Object}
-     */
-    config: any;
-    _stringListeners: Map<any, any>;
-    _binaryListeners: Map<any, any>;
-    _isAlive: boolean;
-    _intervalId: NodeJS.Timeout;
-    /**
-     * Called when the string socket closes (aka client reload).
-     */
-    /** @private */
-    private terminate;
-    /** @private */
-    private _emit;
-    /** @private */
-    private _addListener;
-    /** @private */
-    private _removeListener;
-    /** @private */
-    private _removeAllListeners;
-    /**
-     * Add the socket to a room
-     * @param {String} roomId - Id of the room
-     */
-    addToRoom(roomId: string): void;
-    /**
-     * Remove the socket from a room
-     * @param {String} roomId - Id of the room
-     */
-    removeFromRoom(roomId: string): void;
-    /**
-     * Sends JSON compatible messages on a given channel
-     *
-     * @param {String} channel - Channel of the message
-     * @param {...*} args - Arguments of the message (as many as needed, of any type)
-     */
-    send(channel: string, ...args: any[]): void;
-    /**
-     * Listen JSON compatible messages on a given channel
-     *
-     * @param {String} channel - Channel 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 of the message
-     * @param {Function} callback - Callback to cancel
-     */
-    removeListener(channel: string, callback: Function): void;
-    /**
-     * Remove all listeners from JSON compatible messages on a given channel
-     *
-     * @param {String} channel - Channel of the message
-     */
-    removeAllListeners(channel: string): void;
-    /**
-     * Sends binary messages on a given channel
-     *
-     * @param {String} channel - Channel of the message
-     * @param {TypedArray} typedArray - Data to send
-     */
-    sendBinary(channel: string, typedArray: TypedArray): void;
-    /**
-     * Listen binary messages on a given channel
-     *
-     * @param {String} channel - Channel 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;
-}
-//# sourceMappingURL=Socket.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Socket.d.ts","sourceRoot":"","sources":["../../src/server/Socket.js"],"names":[],"mappings":";AAcA;;;;;;;;;;GAUG;AACH;IACE,4EA2HC;IAzHC;;;;;;OAMG;IACH,wBAAsB;IAEtB;;;;OAIG;IACH,WAAY;IAEZ;;;;OAIG;IACH,iBAAwB;IAExB;;;;OAIG;IACH,cAAkB;IAElB;;;OAGG;IACH,YAGC;IAED,gCAAiC;IACjC,gCAAiC;IAoDjC,kBAAoB;IAiBpB,4BAW4B;IAG9B;;OAEG;IACH,eAAe;IACf,kBAmCC;IAED,eAAe;IACf,cAOC;IAED,eAAe;IACf,qBAOC;IAED,eAAe;IACf,wBASC;IAED,eAAe;IACf,4BAIC;IAED;;;OAGG;IACH,gCAOC;IAED;;;OAGG;IACH,qCAKC;IAED;;;;;OAKG;IACH,4CAcC;IAED;;;;;OAKG;IACH,uDAEC;IAED;;;;;OAKG;IACH,0DAEC;IAED;;;;OAIG;IACH,0CAEC;IAED;;;;;OAKG;IACH,0DAQC;IAED;;;;;OAKG;IACH,6DAEC;IAED;;;;;OAKG;IACH,gEAEC;IAED;;;;OAIG;IACH,gDAEC;CACF"}

package/types/server/Sockets.d.ts

@@ -1,73 +0,0 @@
-export default Sockets;
-/**
- * Websocket server that creates and host all {@link server.Socket} instance.
- * Most of the time, you shouldn't have to use this class instance directely, but
- * it could be usefull in some situations, for broadcasting messages, creating rooms, etc.
- *
- * @memberof server
- */
-declare class Sockets {
-    /** @private */
-    private _wss;
-    /** @private */
-    private _rooms;
-    /** @private */
-    private _initializationCache;
-    /** @private */
-    private _latencyStatsWorker;
-    /** @private */
-    private _auditState;
-    /**
-     * Initialize sockets, all sockets are added by default added to two rooms:
-     * - to the room corresponding to the client `role`
-     * - to the '*' that holds all connected sockets
-     *
-     * @private
-     */
-    private start;
-    /** @protected */
-    protected terminate(): void;
-    /** @private */
-    private _broadcast;
-    /**
-     * Add a socket to a room
-     *
-     * @param {server.Socket} socket - Socket to add to the room.
-     * @param {String} roomId - Id of the room
-     */
-    addToRoom(socket: server.Socket, roomId: string): void;
-    /**
-     * Remove a socket from a room
-     *
-     * @param {server.Socket} socket - Socket to remove from the room.
-     * @param {String} [roomId=null] - Id of the room
-     */
-    removeFromRoom(socket: server.Socket, roomId?: string): void;
-    /**
-     * Send a string message to all client of given room(s). If no room
-     * not specified, the message is sent to all clients
-     *
-     * @param {String|Array} roomsIds - Ids of the rooms that must receive
-     *  the message. If null the message is sent to all clients
-     * @param {server.Socket} excludeSocket - Optionnal
-     *  socket to ignore when broadcasting the message, typically the client
-     *  at the origin of the message
-     * @param {String} channel - Channel of the message
-     * @param {...*} args - Arguments of the message (as many as needed, of any type)
-     */
-    broadcast(roomIds: any, excludeSocket: server.Socket, channel: string, ...args: any[]): void;
-    /**
-     * Send a binary message (TypedArray) to all client of given room(s). If no room
-     * not specified, the message is sent to all clients
-     *
-     * @param {String|Array} roomsIds - Ids of the rooms that must receive
-     *  the message. If null the message is sent to all clients
-     * @param {server.Socket} excludeSocket - Optionnal
-     *  socket to ignore when broadcasting the message, typically the client
-     *  at the origin of the message
-     * @param {String} channel - Channel of the message
-     * @param {...*} args - Arguments of the message (as many as needed, of any type)
-     */
-    broadcastBinary(roomIds: any, excludeSocket: server.Socket, channel: string, typedArray: any): void;
-}
-//# sourceMappingURL=Sockets.d.ts.map

package/types/server/Sockets.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Sockets.d.ts","sourceRoot":"","sources":["../../src/server/Sockets.js"],"names":[],"mappings":";AAYA;;;;;;GAMG;AACH;IAEI,eAAe;IACf,aAAgB;IAChB,eAAe;IACf,eAAuB;IAGvB,eAAe;IACf,6BAAqC;IAErC,eAAe;IACf,4BAA+B;IAC/B,eAAe;IACf,oBAAuB;IAIzB;;;;;;OAMG;IACH,cAwDC;IAED,iBAAiB;IACjB,4BAMC;IAED,eAAe;IACf,mBA8BC;IAED;;;;;OAKG;IACH,uDAEC;IAED;;;;;OAKG;IACH,6DAEC;IAED;;;;;;;;;;;OAWG;IACH,6FAEC;IAED;;;;;;;;;;;OAWG;IACH,oGAEC;CACF"}