@soundworks/core 4.0.0-alpha.28 → 4.0.0-alpha.29

package/types/server/Client.d.ts

@@ -1,45 +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;
-    /**
-     * Is set in server._onSocketConnection
-     * @private
-     */
-    private token;
-}
-//# 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":";AAKA;;;;;;GAMG;AACH;IACE;;;OAGG;IACH,iDAkCC;IAjCC;;;;OAIG;IACH,aAAgB;IAEhB;;;;OAIG;IACH,WAAiC;IAEjC;;;;OAIG;IACH,aAAkB;IAElB;;;;OAIG;IACH,sBAAoB;IAEpB;;;OAGG;IACH,cAAiB;CAEpB"}

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgEG;AACH;IACE;;;;;;;;OAQG;IACH,iCAPW,MAAM,GAAC,MAAM,EAAE,EA+CzB;IAnCC;;;;OAIG;IACH,+BAAoB;IAEpB;;;OAGG;IACH,SAFU,eAAe,CAED;IAExB;;;;OAIG;IACH,iBAHU,MAAM,CAGI;IAapB,mBAA2B;IAM7B;;;;;;;;;;;;;;;;OAgBG;IACH,4BAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,uBAAgB;IAEhB;;;;;;OAMG;IACH,sBAAe;IAEf;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,2CAMC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,0CAMC;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
- * @hideconstructor
- */
-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.
-     *
-     * _WARNING: Most of the time, you should not have to call this method manually._
-     *
-     * @param {server.Context#name} contextName - Name of the context.
-     */
-    get(contextName: any): Promise<any>;
-    /**
-     * 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;;;;;;;;GAQG;AACH;IACE;;OAEG;IACH,mCAOC;IANC,eAAe;IACf,eAAoB;IACpB,eAAe;IACf,kBAAwC;IACxC,eAAe;IACf,8BAAsC;IAGxC;;;;;;;OAOG;IACH,iBAOC;IAED;;;;;;OAMG;IACH,oCAyBC;IAED;;;;;;OAMG;IACH,kBAyFC;IAED;;;;;;OAMG;IACH,qBAUC;IAED;;;;;OAKG;IACH,cAGC;IAED;;;;OAIG;IACH,aAGC;CACF"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"Plugin.d.ts","sourceRoot":"","sources":["../../src/server/Plugin.js"],"names":[],"mappings":";;;;;2BAMW,aAAa;;AAJxB;;;;;GAKG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACE;;;;OAIG;IACH,uCAHW,MAAM,EAehB;IATC;;;;OAIG;IACH,sBAAoB;IAEpB,eAAe;IACf,gBAAwB;IAG1B;;;;;;OAMG;IACH,gDAEC;IAED;;;;;;OAMG;IACH,mDAEC;CACF;uBA3EsB,yBAAyB"}

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH;IASE,mEAQC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,YAMC;IAID,cAAc;IACd,qDAYC;IAED,eAAe;IACf,kBAUC;IAED,eAAe;IACf,qBAUC;CACF;8BAvK6B,gCAAgC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"Server.d.ts","sourceRoot":"","sources":["../../src/server/Server.js"],"names":[],"mappings":";;;;;AAuGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH;IACE;;;;;;;;OAQG;IACH,yCAoLC;IA/KC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,YAA+C;IAuC/C,gBAAsB;IAEtB;;;;;;;;;;;;;;;;OAgBG;IAGH,YAAuB;IAIvB;;;;;OAKG;IACH,gBAAsB;IAEtB;;;;;OAKG;IACH,wBAA4B;IAE5B;;;;;OAKG;IACH,oCAA4C;IAE5C;;;;;OAKG;IACH,kCAAsC;IAEtC;;;;;OAKG;IACH,sCAA8C;IAE9C;;;OAGG;IACH;;;;;;;;;;;;;;;;;;;;;;;;MAAsB;IAEtB;;;;OAIG;IACH,QAFU,MAAM,CAEI;IAEpB;;;;;;OAMG;IACH,WAAyC;IAEzC,eAAe;IACf,oCAIC;IAED,eAAe;IACf,iCAAyC;IACzC,eAAe;IACf,kCAA0C;IAC1C,eAAe;IACf,qCAA6C;IAC7C,eAAe;IACf,oBAAuB;IACvB,eAAe;IACf,iCAAyC;IACzC,eAAe;IACf,wBAAgC;IASlC;;;;OAIG;IACH,0BAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,sBAgPC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,sBAwFC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,sBAgBC;IAED;;;OAGG;IACH,yBA2EC;IAED,8CAIC;IAED,iDAIC;IAED;;;OAGG;IACH,4BAkHC;IAED;;;;;;;OAOG;IACH,2BAmBC;IAED,6CAIC;IAED,eAAe;IACf,wBAgBC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,sCAkDC;IAED;;;;;OAKG;IACH,wDAEC;IAED;;;;;;;;;;;;;;;OAeG;IACH,iBAPa,2BAA2B,CAavC;IAED,eAAe;IACf,oBAMC;IAED,eAAe;IACf,+BAkBC;IAED;;;;;;OAMG;IACH,gDAMC;IAED;;;;;;;;OAQG;IAEH,2EAkBC;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;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH;CAA4C;4BAjFhB,8BAA8B"}

package/types/server/SharedStateCollection.d.ts

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

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

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

package/types/server/Socket.d.ts

@@ -1,164 +0,0 @@
-export default Socket;
-/**
- * The Socket class is a simple publish / subscribe wrapper built on top of the
- * [ws](https://github.com/websockets/ws) library. An instance of {@link server.Socket}
- * is automatically created per client when it connects (see {@link server.Client#socket}).
- *
- * _Important: In most cases, you should consider using a {@link client.SharedState}
- * rather than directly using the sockets._
- *
- * The Socket class contains two different WebSockets:
- * - a socket configured with `binaryType = 'blob'` for JSON compatible data
- *  types (i.e. string, number, boolean, object, array and null).
- * - a socket configured with `binaryType= 'arraybuffer'` for efficient streaming
- *  of binary data.
- *
- * @memberof server
- * @hideconstructor
- */
-declare class Socket {
-    constructor(ws: any, binaryWs: any, rooms: any, sockets: any);
-    /**
-     * `ws` socket instance configured with `binaryType=blob` (string)
-     *
-     * @type {object}
-     * @private
-     */
-    private ws;
-    /**
-     * `ws` socket instance configured with `binaryType=arraybuffer` (TypedArray)
-     *
-     * @type {object}
-     * @private
-     */
-    private binaryWs;
-    /**
-     * 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;
-    /**
-     * Reference to the rooms object
-     *
-     * @type {Map}
-     * @private
-     */
-    private rooms;
-    /** @private */
-    private _stringListeners;
-    /** @private */
-    private _binaryListeners;
-    /** @private */
-    private _heartbeatId;
-    /** @private */
-    private _isAlive;
-    /**
-     * Removes all listeners and immediately close the two sockets. Is automatically
-     * called on `server.stop()`
-     *
-     * @private
-     */
-    private terminate;
-    /**
-     * @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;
-    /**
-     * 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;
-    /**
-     * Send messages with JSON compatible data types on a given channel.
-     *
-     * @param {string} channel - Channel name.
-     * @param {...*} args - Payload of the message. As many arguments as needed, of
-     *  JSON compatible data types (i.e. string, number, boolean, object, array and null).
-     */
-    send(channel: string, ...args: any[]): void;
-    /**
-     * Listen messages with JSON compatible data types on a given channel.
-     *
-     * @param {string} channel - Channel name.
-     * @param {Function} callback - Callback to execute when a message is received,
-     *  arguments of the callback function will match the arguments sent using the
-     *  {@link server.Socket#send} method.
-     */
-    addListener(channel: string, callback: Function): void;
-    /**
-     * Remove a listener of messages with JSON compatible data types from a given channel.
-     *
-     * @param {string} channel - Channel name.
-     * @param {Function} callback - Callback to remove.
-     */
-    removeListener(channel: string, callback: Function): void;
-    /**
-     * Remove all listeners of messages with JSON compatible data types.
-     *
-     * @param {string} channel - Channel name.
-     */
-    removeAllListeners(channel?: string): void;
-    /**
-     * Send binary messages on a given channel.
-     *
-     * @param {string} channel - Channel name.
-     * @param {TypedArray} typedArray - Binary data to be sent.
-     */
-    sendBinary(channel: string, typedArray: TypedArray): void;
-    /**
-     * Listen binary messages on a given channel
-     *
-     * @param {string} channel - Channel name.
-     * @param {Function} callback - Callback to execute when a message is received.
-     */
-    addBinaryListener(channel: string, callback: Function): void;
-    /**
-     * Remove a listener of binary compatible messages from a given channel
-     *
-     * @param {string} channel - Channel name.
-     * @param {Function} callback - Callback to remove.
-     */
-    removeBinaryListener(channel: string, callback: Function): void;
-    /**
-     * Remove all listeners of 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":";AAqBA;;;;;;;;;;;;;;;;GAgBG;AACH;IACE,8DAiIC;IAhIC;;;;;OAKG;IACH,WAAY;IAEZ;;;;;OAKG;IACH,iBAAwB;IAExB;;;;;;;OAOG;IACH,wBAAsB;IAEtB;;;;;OAKG;IACH,cAAkB;IAElB,eAAe;IACf,yBAAiC;IACjC,eAAe;IACf,yBAAiC;IACjC,eAAe;IACf,qBAAwB;IAIxB,eAAe;IACf,iBAAoB;IAsFtB;;;;;OAKG;IACH,kBAoCC;IAED;;;;;OAKG;IACH,cAOC;IAED;;;;;OAKG;IACH,qBAOC;IAED;;;;;OAKG;IACH,wBASC;IAED;;;;;OAKG;IACH,4BAMC;IAED;;;;OAIG;IACH,kBAFW,MAAM,QAShB;IAED;;;;OAIG;IACH,uBAFW,MAAM,QAOhB;IAED;;;;;;OAMG;IACH,cAJW,MAAM,wBAkBhB;IAED;;;;;;;OAOG;IACH,qBALW,MAAM,4BAOhB;IAED;;;;;OAKG;IACH,wBAHW,MAAM,4BAKhB;IAED;;;;OAIG;IACH,6BAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,oBAHW,MAAM,gCAWhB;IAED;;;;;OAKG;IACH,2BAHW,MAAM,4BAKhB;IAED;;;;;OAKG;IACH,8BAHW,MAAM,4BAKhB;IAED;;;;OAIG;IACH,mCAFW,MAAM,QAIhB;CACF"}

package/types/server/Sockets.d.ts

@@ -1,80 +0,0 @@
-export default Sockets;
-/**
- * Manager all {@link server.Socket} instances.
- *
- * 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;
-    /** @private */
-    private _DEBUG_PREVENT_HEARTBEAT;
-    /**
-     * Initialize sockets, all sockets are added to two rooms by default:
-     * - to the room corresponding to the client `role`
-     * - to the '*' room that holds all connected sockets
-     *
-     * @private
-     */
-    private start;
-    /**
-     * Terminate all existing sockets
-     *
-     * @private
-     */
-    private terminate;
-    /** @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 - Id of the room.
-     */
-    removeFromRoom(socket: server.Socket, roomId: string): void;
-    /**
-     * Send a message of JSON compatible data types to all client of given room(s).
-     * If no room is 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 name.
-     * @param {...*} args - Payload of the message. As many arguments as needed, of
-     *  JSON compatible data types (i.e. string, number, boolean, object, array and null).
-     */
-    broadcast(roomIds: any, excludeSocket: server.Socket, channel: string, ...args: any[]): void;
-    /**
-     * Send a binary message to all client of given room(s). If no room is specified
-     * 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 name.
-     * @param {TypedArray} typedArray - Binary data to be sent.
-     */
-    broadcastBinary(roomIds: any, excludeSocket: server.Socket, channel: string, typedArray: TypedArray): 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":";AAUA;;;;;;;GAOG;AACH;IAEI,eAAe;IACf,aAAgB;IAChB,eAAe;IACf,eAAuB;IAGvB,eAAe;IACf,6BAAqC;IAErC,eAAe;IACf,4BAA+B;IAC/B,eAAe;IACf,oBAAuB;IAEvB,eAAe;IACf,iCAAqC;IAGvC;;;;;;OAMG;IACH,cA8EC;IAED;;;;OAIG;IACH,kBAMC;IAED,eAAe;IACf,mBA8BC;IAED;;;;;OAKG;IACH,uDAEC;IAED;;;;;OAKG;IACH,4DAEC;IAED;;;;;;;;;;;;OAYG;IACH,6FAEC;IAED;;;;;;;;;;OAUG;IACH,qEAHW,MAAM,gCAKhB;CACF"}