@soundworks/core 3.6.0 → 4.0.0-alpha.0

package/types/common/BaseStateManager.d.ts

@@ -0,0 +1,70 @@
+export default BaseStateManager;
+/**
+ * @private
+ */
+declare class BaseStateManager {
+    /**
+     * @param {Number} id - Id of the node.
+     * @param {Object} transport - Transport to use for synchronizing the state.
+     *  Must implement a basic EventEmitter API.
+     */
+    constructor(id: number, transport: any);
+    client: {
+        id: number;
+        transport: any;
+    };
+    _statesById: Map<any, any>;
+    _observeListeners: Set<any>;
+    _cachedSchemas: Map<any, any>;
+    _observeRequestCallbacks: Map<any, any>;
+    /**
+     * Create a `SharedState` instance from a registered schema.
+     *
+     * @param {String} schemaName - Name of the schema as given on registration
+     *  (cf. ServerStateManager)
+     * @param {Object} [initValues={}] - Default values for the state.
+     * @returns {client.SharedState|server.SharedState}
+     * @see {@link client.SharedState}
+     * @see {@link server.SharedState}
+     * @example
+     * const state = await client.stateManager.create('my-schema');
+     */
+    create(schemaName: string, initValues?: any): client.SharedState | server.SharedState;
+    /**
+     * Attach to an existing `SharedState` instance.
+     *
+     * @param {String} schemaName - Name of the schema as given on registration
+     *  (cf. ServerStateManager)
+     * @param {Object} [stateId=null] - Id of the state to attach to. If `null`,
+     *  attach to the first state found with the given schema name (usefull for
+     *  globally shared states owned by the server).
+     * @returns {client.SharedState|server.SharedState}
+     * @see {@link client.SharedState}
+     * @see {@link server.SharedState}
+     * @example
+     * const state = await client.stateManager.attach('my-schema');
+     */
+    attach(schemaName: string, stateId?: any): client.SharedState | server.SharedState;
+    /**
+     * Observe all the `SharedState` instances that are created on the network.
+     * This can be usefull for clients with some controller role that might want to track
+     * the state of all other clients of the application, to monitor them and/or take
+     * control over them from a single point.
+     *
+     * @todo Optionnal schema name
+     * @param {server.StateManager~ObserveCallback|client.StateManager~ObserveCallback}
+     *  callback - Function to be called when a new state is created on the network.
+     * @returns {Promise<Function>} - Return a Promise that resolves when the callback
+     *  as been executed for the first time. The promise value is a function which
+     *  allows to stop observing the network.
+     * @example
+     * client.stateManager.observe(async (schemaName, stateId, nodeId) => {
+     *   if (schemaName === 'something') {
+     *     const state = await this.client.stateManager.attach(schemaName, stateId);
+     *     console.log(state.getValues());
+     *   }
+     * });
+     */
+    observe(callback: any): Promise<Function>;
+}
+//# sourceMappingURL=BaseStateManager.d.ts.map

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

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

@@ -0,0 +1,143 @@
+export namespace sharedOptions {
+    const nullable: boolean;
+    const event: boolean;
+    const metas: {};
+    const filterChange: boolean;
+    const immediate: boolean;
+}
+export namespace types {
+    export namespace boolean {
+        const required: string[];
+        function coerceFunction(name: any, def: any, value: any): boolean;
+    }
+    export namespace string {
+        const required_1: string[];
+        export { required_1 as required };
+        export function coerceFunction_1(name: any, def: any, value: any): string;
+        export { coerceFunction_1 as coerceFunction };
+    }
+    export namespace integer {
+        const required_2: string[];
+        export { required_2 as required };
+        export function sanitizeSchema(def: any): any;
+        export function coerceFunction_2(name: any, def: any, value: any): number;
+        export { coerceFunction_2 as coerceFunction };
+    }
+    export namespace float {
+        const required_3: string[];
+        export { required_3 as required };
+        export function sanitizeSchema_1(def: any): any;
+        export { sanitizeSchema_1 as sanitizeSchema };
+        export function coerceFunction_3(name: any, def: any, value: any): number;
+        export { coerceFunction_3 as coerceFunction };
+    }
+    export namespace _enum {
+        const required_4: string[];
+        export { required_4 as required };
+        export function coerceFunction_4(name: any, def: any, value: any): any;
+        export { coerceFunction_4 as coerceFunction };
+    }
+    export { _enum as enum };
+    export namespace any {
+        const required_5: string[];
+        export { required_5 as required };
+        export function coerceFunction_5(name: any, def: any, value: any): any;
+        export { coerceFunction_5 as coerceFunction };
+    }
+}
+export default ParameterBag;
+export namespace server {
+    /**
+     * ~schema
+     *
+     * Description of a schema to be register by the {@link server.ServerStateManagerServer }
+     * A schema consists of a combinaison of key value pairs where the key is the
+     * name of the parameter, and the value is an object describing the parameter.
+     *
+     * Available types are:
+     * - {@link server.SharedStateManagerServer ~schemaBooleanDef}
+     * - {@link server.SharedStateManagerServer ~schemaStringDef}
+     * - {@link server.SharedStateManagerServer ~schemaIntegerDef}
+     * - {@link server.SharedStateManagerServer ~schemaFloatDef}
+     * - {@link server.SharedStateManagerServer ~schemaEnumDef}
+     * - {@link server.SharedStateManagerServer ~schemaAnyDef}
+     */
+    type SharedStateManagerServer = any;
+}
+/**
+ * Bag of parameters.
+ * @private
+ */
+declare class ParameterBag {
+    static validateSchema(schema: any): void;
+    constructor(schema: any, initValues?: {});
+    /**
+     * List of parameters.
+     *
+     * @type {Object<String, Param>}
+     * @name _params
+     * @memberof ParameterBag
+     * @instance
+     * @private
+     */
+    private _values;
+    /**
+     * List of schema with init values.
+     *
+     * @type {Object<String, paramDefinition>}
+     * @name _schema
+     * @memberof ParameterBag
+     * @instance
+     * @private
+     */
+    private _schema;
+    /**
+     * Define if the parameter exists.
+     *
+     * @param {String} name - Name of the parameter.
+     * @return {Boolean}
+     */
+    has(name: string): boolean;
+    /**
+     * Return values of all parameters as a flat object.
+     *
+     * @return {Object}
+     */
+    getValues(): any;
+    /**
+     * Return the value of the given parameter. If the parameter is of `any` type,
+     * a deep copy is returned.
+     *
+     * @param {String} name - Name of the parameter.
+     * @return {Mixed} - Value of the parameter.
+     */
+    get(name: string): Mixed;
+    /**
+     * Set the value of a parameter. If the value of the parameter is updated
+     * (aka if previous value is different from new value) all registered
+     * callbacks are registered.
+     *
+     * @param {String} name - Name of the parameter.
+     * @param {Mixed} value - Value of the parameter.
+     * @param {Boolean} [forcePropagation=false] - if true, propagate value even
+     *    if the value has not changed.
+     * @return {Array} - [new value, updated flag].
+     */
+    set(name: string, value: Mixed): any[];
+    /**
+     * Reset a parameter to its initialization values. Reset all parameters if no argument.
+     * @note - prefer `state.set(state.getInitValues())`
+     *         or     `state.set(state.getDefaultValues())`
+     *
+     * @param {String} [name=null] - Name of the parameter to reset.
+     */
+    /**
+     * Return the given schema along with the initialization values.
+     *
+     * @return {Object}
+     */
+    getSchema(name?: any): any;
+    getInitValues(): {};
+    getDefaults(): {};
+}
+//# sourceMappingURL=ParameterBag.d.ts.map

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

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

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

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

@@ -0,0 +1,35 @@
+export const SERVER_ID: -1;
+export const CREATE_REQUEST: "s:c:req";
+export const CREATE_RESPONSE: "s:c:res";
+export const CREATE_ERROR: "s:c:err";
+export const DELETE_REQUEST: "s:dl:req";
+export const DELETE_RESPONSE: "s:dl:res";
+export const DELETE_ERROR: "s:dl:err";
+export const DELETE_NOTIFICATION: "s:dl:not";
+export const ATTACH_REQUEST: "s:a:req";
+export const ATTACH_RESPONSE: "s:a:res";
+export const ATTACH_ERROR: "s:a:err";
+export const DETACH_REQUEST: "s:dt:req";
+export const DETACH_RESPONSE: "s:dt:res";
+export const DETACH_ERROR: "s:dt:err";
+export const OBSERVE_REQUEST: "s:o:req";
+export const OBSERVE_RESPONSE: "s:o:res";
+export const OBSERVE_NOTIFICATION: "s:o:not";
+export const UNOBSERVE_NOTIFICATION: "s:uo:not";
+export const UPDATE_REQUEST: "s:u:req";
+export const UPDATE_RESPONSE: "s:u:res";
+export const UPDATE_ABORT: "s:u:ab";
+export const UPDATE_NOTIFICATION: "s:u:not";
+export const DELETE_SCHEMA: "s:d:s";
+export const CONTEXT_ENTER_REQUEST: "c:en:req";
+export const CONTEXT_ENTER_RESPONSE: "c:en:res";
+export const CONTEXT_ENTER_ERROR: "c:en:err";
+export const CONTEXT_EXIT_REQUEST: "c:ex:req";
+export const CONTEXT_EXIT_RESPONSE: "c:ex:res";
+export const CONTEXT_EXIT_ERROR: "c:ex:err";
+export const CLIENT_HANDSHAKE_REQUEST: "cl:h:req";
+export const CLIENT_HANDSHAKE_RESPONSE: "cl:h:res";
+export const CLIENT_HANDSHAKE_ERROR: "cl:h:err";
+export const AUDIT_STATE_NAME: "s:c:audit";
+export const PRIVATE_STATES: string[];
+//# sourceMappingURL=constants.d.ts.map

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

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

@@ -0,0 +1,16 @@
+export default logger;
+declare namespace logger {
+    const verbose: boolean;
+    function configure(verbose: any): void;
+    function title(msg: any): void;
+    function clientConfigAndRouting(routes: any, config: any): void;
+    function ip(protocol: any, address: any, port: any): void;
+    function pluginStart(name: any): void;
+    function pluginStarted(name: any): void;
+    function pluginReady(name: any): void;
+    function pluginErrored(name: any): void;
+    function log(msg: any): void;
+    function warn(msg: any): void;
+    function error(msg: any): void;
+}
+//# sourceMappingURL=logger.d.ts.map

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

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

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

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

@@ -0,0 +1,9 @@
+/** @private */
+export function packBinaryMessage(channel: any, data: any): ArrayBufferLike;
+/** @private */
+export function unpackBinaryMessage(buffer: any): any[];
+/** @private */
+export function packStringMessage(channel: any, ...args: any[]): string;
+/** @private */
+export function unpackStringMessage(data: any): any;
+//# sourceMappingURL=sockets-utils.d.ts.map

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

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

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

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

package/types/server/Client.d.ts

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

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

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

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

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

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

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

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