@soundworks/core 4.0.0-alpha.21 → 4.0.0-alpha.23

package/src/server/Sockets.js

@@ -1,39 +1,42 @@
-import { Worker } from 'node:worker_threads';
-import querystring from 'querystring';
-import { default as WebSocket, WebSocketServer } from 'ws';
+import querystring from 'node:querystring';
+import {
+  Worker,
+} from 'node:worker_threads';
 
-import Socket from './Socket.js';
+import {
+  default as WebSocket,
+  WebSocketServer,
+} from 'ws';
+
+import Socket, {
+  kSocketTerminate,
+} from './Socket.js';
+
+// @note - fs.readFileSync creates some cwd() issues...
 import networkLatencyWorker from './audit-network-latency.worker.js';
 
-// this crashes when bundling server to cjs module for Max, fallback to cjs worker
-// const __dirname = fileURLToPath(new URL('.', import.meta.url));
+export const kSocketsRemoveFromAllRooms = Symbol('soundworks:sockets-remove-from-all-rooms');
+export const kSocketsLatencyStatsWorker = Symbol('soundworks:sockets-latency-stats-worker');
+export const kSocketsDebugPreventHeartBeat = Symbol('soundworks:sockets-debug-prevent-heartbeat');
 
 /**
- * Manager all {@link server.Socket} instances.
+ * Manage 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.
+ * _Important: In most cases, you should consider using a {@link client.SharedState}
+ * rather than directly using the Socket instance._
  *
  * @memberof server
  */
 class Sockets {
+  #wsServer = null;
+  #rooms = new Map();
+
   constructor() {
-    /** @private */
-    this._wss = null;
-    /** @private */
-    this._rooms = new Map();
-    // The special `'*'` romm stores all current connections.
-    this._rooms.set('*', new Set());
-    /** @private */
-    this._initializationCache = new Map();
-
-    /** @private */
-    this._latencyStatsWorker = null; // protected - used in Socket instances
-    /** @private */
-    this._auditState = null;
-
-    /** @private */
-    this._DEBUG_PREVENT_HEARTBEAT = false;
+    // Init special `'*'` room which stores all current connections.
+    this.#rooms.set('*', new Set());
+
+    this[kSocketsLatencyStatsWorker] = null;
+    this[kSocketsDebugPreventHeartBeat] = false;
   }
 
   /**
@@ -44,15 +47,15 @@ class Sockets {
    * @private
    */
   async start(server, config, onConnectionCallback) {
-    // init audit stuff for network latency estimation
-    // @see note about __dirname
-    // const workerPathname = path.join(__dirname, 'audit-network-latency.worker.js');
-    this._latencyStatsWorker = new Worker(networkLatencyWorker, { eval: true });
-    this._auditState = await server.getAuditState();
+    // Audit for network latency estimation, the worker is written in cjs so that we
+    // can make builds for Max, move back to modules once Max support modules
+    this[kSocketsLatencyStatsWorker] = new Worker(networkLatencyWorker, { eval: true });
 
-    this._auditState.onUpdate(updates => {
+    const auditState = await server.getAuditState();
+
+    auditState.onUpdate(updates => {
       if ('averageNetworkLatencyWindow' in updates || 'averageNetworkLatencyPeriod' in updates) {
-        this._latencyStatsWorker.postMessage({
+        this[kSocketsLatencyStatsWorker].postMessage({
           type: 'config',
           value: {
             averageLatencyWindow: updates.averageNetworkLatencyWindow,
@@ -62,137 +65,104 @@ class Sockets {
       }
     }, true);
 
-    this._latencyStatsWorker.on('message', msg => {
+    this[kSocketsLatencyStatsWorker].on('message', msg => {
       if (msg.type === 'computed-average-latency') {
-        this._auditState.set({ averageNetworkLatency: msg.value });
+        auditState.set({ averageNetworkLatency: msg.value });
       }
     });
 
-    // init ws server
-    this._wss = new WebSocketServer({
+    // Init ws server
+    this.#wsServer = new WebSocketServer({
       noServer: true,
-      path: `/${config.path}`, // @note - update according to existing config files (aka cosima-apps)
+      path: `/${config.path}`,
     });
 
-    this._wss.on('connection', (ws, req) => {
-      const queryString = querystring.decode(req.url.split('?')[1]);
-      const { role, key, token } = queryString;
-      const binary = !!(parseInt(queryString.binary));
-
-      if (binary) {
-        ws.binaryType = 'arraybuffer';
-      }
-
-      if (!this._initializationCache.has(key)) {
-        this._initializationCache.set(key, { ws, binary });
-      } else {
-        const cached = this._initializationCache.get(key);
-        this._initializationCache.delete(key);
+    this.#wsServer.on('connection', (ws, req) => {
+      const { role, token } = querystring.parse(req.url.split('?')[1]);
+      const socket = new Socket(ws, this);
 
-        // should be in order, but just to be sure
-        const stringWs = cached.binary ? ws : cached.ws;
-        const binaryWs = cached.binary ? cached.ws : ws;
-        const socket = new Socket(stringWs, binaryWs, this._rooms, this, config);
+      socket.addToRoom('*');
+      socket.addToRoom(role);
 
-        socket.addToRoom('*');
-        socket.addToRoom(role);
-
-        onConnectionCallback(role, socket, token);
-      }
+      onConnectionCallback(role, socket, token);
     });
 
-    // check if client can connect
+    // Prevent socket with protected role to connect is token is invalid
     server.httpServer.on('upgrade', async (req, socket, head) => {
-      const queryString = querystring.decode(req.url.split('?')[1]);
-
-      const { role, token } = queryString;
+      const { role, token } = querystring.parse(req.url.split('?')[1]);
 
       if (server.isProtected(role)) {
-        // we don't have any ip in the upgrade request, so we just check the
-        // connection token is pending
-        const allowed = server.isValidConnectionToken(token);
-
-        if (!allowed) {
+        // we don't have any IP in the upgrade request object,
+        // so we just check the connection token is pending and valid
+        if (!server.isValidConnectionToken(token)) {
           socket.destroy('not allowed');
         }
       }
 
-      this._wss.handleUpgrade(req, socket, head, (ws) => {
-        this._wss.emit('connection', ws, req);
+      this.#wsServer.handleUpgrade(req, socket, head, (ws) => {
+        this.#wsServer.emit('connection', ws, req);
       });
     });
   }
 
   /**
-   * Terminate all existing sockets
-   *
+   * Terminate all existing sockets.
    * @private
    */
   terminate() {
     // terminate stat worker thread
-    this._latencyStatsWorker.terminate();
+    this[kSocketsLatencyStatsWorker].terminate();
     // clean sockets
-    const sockets = this._rooms.get('*');
-    sockets.forEach(socket => socket.terminate());
+    const sockets = this.#rooms.get('*');
+    sockets.forEach(socket => socket[kSocketTerminate]());
   }
 
-  /** @private */
-  _broadcast(binary, roomIds, excludeSocket, channel, ...args) {
-    const method = binary ? 'sendBinary' : 'send';
-    let targets = new Set();
-
-    if (typeof roomIds === 'string' || Array.isArray(roomIds)) {
-      if (typeof roomIds === 'string') {
-        roomIds = [roomIds];
-      }
-
-      roomIds.forEach(roomId => {
-        if (this._rooms.has(roomId)) {
-          const room = this._rooms.get(roomId);
-          room.forEach(socket => targets.add(socket));
-        }
-      });
-    } else {
-      targets = this._rooms.get('*');
+  /**
+   * Remove given socket from all rooms.
+   */
+  [kSocketsRemoveFromAllRooms](socket) {
+    for (let [_, room] of this.#rooms) {
+      room.delete(socket);
     }
-
-    targets.forEach(socket => {
-      if (socket.ws.readyState === WebSocket.OPEN) {
-        if (excludeSocket !== null) {
-          if (socket !== excludeSocket) {
-            socket[method](channel, ...args);
-          }
-        } else {
-          socket[method](channel, ...args);
-        }
-      }
-    });
   }
 
   /**
-   * Add a socket to a room
+   * Add a socket to a room.
+   *
+   * _Note that in most cases, you should use a shared state instead_
    *
    * @param {server.Socket} socket - Socket to add to the room.
    * @param {String} roomId - Id of the room.
    */
   addToRoom(socket, roomId) {
-    socket.addToRoom(roomId);
+    if (!this.#rooms.has(roomId)) {
+      this.#rooms.set(roomId, new Set());
+    }
+
+    const room = this.#rooms.get(roomId);
+    room.add(socket);
   }
 
   /**
-   * Remove a socket from a room
+   * Remove a socket from a room.
+   *
+   * _Note that in most cases, you should use a shared state instead_
    *
    * @param {server.Socket} socket - Socket to remove from the room.
    * @param {String} roomId - Id of the room.
    */
   removeFromRoom(socket, roomId) {
-    socket.removeFromRoom(roomId);
+    if (this.#rooms.has(roomId)) {
+      const room = this.#rooms.get(roomId);
+      room.delete(socket);
+    }
   }
 
   /**
-   * 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.
+   * Send a message to all clients os given room(s). If no room is specified,
+   * the message is sent to all clients.
    *
+   * _Note that in most cases, you should use a shared state instead_
    *
    * @param {String|Array} roomsIds - Ids of the rooms that must receive
    *  the message. If `null` the message is sent to all clients.
@@ -203,22 +173,28 @@ class Sockets {
    *  JSON compatible data types (i.e. string, number, boolean, object, array and null).
    */
   broadcast(roomIds, excludeSocket, channel, ...args) {
-    this._broadcast(false, roomIds, excludeSocket, channel, ...args);
-  }
+    const targets = new Set();
 
-  /**
-   * 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, excludeSocket, channel, typedArray) {
-    this._broadcast(true, roomIds, excludeSocket, channel, typedArray);
+    if (typeof roomIds === 'string' || Array.isArray(roomIds)) {
+      if (typeof roomIds === 'string') {
+        roomIds = [roomIds];
+      }
+
+      roomIds.forEach(roomId => {
+        if (this.#rooms.has(roomId)) {
+          const room = this.#rooms.get(roomId);
+          room.forEach(socket => targets.add(socket));
+        }
+      });
+    } else {
+      targets = this.#rooms.get('*');
+    }
+
+    targets.forEach(socket => {
+      if (socket.readyState === WebSocket.OPEN && socket !== excludeSocket) {
+        socket.send(channel, ...args);
+      }
+    });
   }
 }
 

package/src/server/audit-network-latency.worker.js

@@ -1,5 +1,6 @@
-// NOTICE: we use this syntax so that the server can be bundled to cjs
-// with esbuild, so we can ship a cjs server bundle into Max.
+// @note - We use this common js syntax so that the server can be bundled to cjs
+// which allows to build a server that can be accepted by Max `node.script`
+//
 // Should move back to regular esm module once Max has fixed its loader
 export default `
 const { parentPort } = require('node:worker_threads');
@@ -11,6 +12,7 @@ let averageLatencyPeriod = 2;
 let intervalId = null;
 let meanLatency = 0;
 
+// workaround that sc-utils is pure emascript module
 let getTime;
 let inited = new Promise(async (resolve) => {
   module = await import('@ircam/sc-utils');
@@ -25,7 +27,6 @@ parentPort.on('message', async msg => {
       averageLatencyPeriod = msg.value.averageLatencyPeriod;
 
       await inited;
-
       // launch compute in its own loop so that the number of computation is
       // decoupled from the number of connected clients
       clearInterval(intervalId);

package/src/server/index.js

@@ -1,3 +1,9 @@
+/**
+ * @license
+ * Copyright (c) 2014-present IRCAM – Centre Pompidou (France, Paris)
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
 /**
  * Server-side part of the *soundworks* framework.
  *

package/types/client/Client.d.ts

@@ -1,6 +1,28 @@
 export default Client;
 /**
- * The `Client` class is the main entry point for  the client-side of soundworks
+ * Configuration object for a client running in a browser runtime.
+ */
+export type ClientConfig = any;
+/**
+ * Configuration object for a client running in a browser runtime.
+ *
+ * @typedef ClientConfig
+ * @memberof client
+ * @type {object}
+ * @property {string} role - Role of the client in the application (e.g. 'player', 'controller').
+ * @property {object} [app] - Application configration object.
+ * @property {string} [app.name=''] - Name of the application.
+ * @property {string} [app.author=''] - Name of the author.
+ * @property {object} [env] - Environment configration object.
+ * @property {boolean} env.useHttps - Define if the websocket should use secure connection.
+ * @property {boolean} [env.serverAddress=''] - Address the socket server. Mandatory for
+ *  node clients. For browser clients, use `window.location.domain` as fallback if empty.
+ * @property {boolean} env.port - Port of the socket server.
+ * @property {string} [env.websockets={}] - Configuration options for websockets.
+ * @property {string} [env.subpath=''] - If running behind a proxy, path to the application.
+ */
+/**
+ * The `Client` class is the main entry point for the client-side of a soundworks
  * application.
  *
  * A `Client` instance allows to access soundworks components such as {@link client.StateManager},
@@ -20,11 +42,16 @@ export default Client;
  */
 declare class Client {
     /**
-     * @param {client.BrowserClientConfig|client.NodeClientConfig} config -
-     *  Configuration of the soundworks client.
+     * @param {client.ClientConfig} config - Configuration of the soundworks client.
      * @throws Will throw if the given config object is invalid.
      */
-    constructor(config: client.BrowserClientConfig | client.NodeClientConfig);
+    constructor(config: client.ClientConfig);
+    /**
+     * package version
+     * @type string
+     * @readonly
+     */
+    readonly version: string;
     /**
      * Role of the client in the application.
      *
@@ -34,9 +61,9 @@ declare class Client {
     /**
      * Configuration object.
      *
-     * @type {client.BrowserClientConfig|client.NodeClientConfig}
+     * @type {client.ClientConfig}
      */
-    config: client.BrowserClientConfig | client.NodeClientConfig;
+    config: client.ClientConfig;
     /**
      * Session id of the client (incremeted positive number), generated and
      * retrieved by the server during `client.init`. The counter is reset when
@@ -99,6 +126,11 @@ declare class Client {
      * @type {string}
      */
     status: string;
+    /**
+     * Token of the client if connected through HTTP authentication.
+     * @private
+     */
+    private token;
     /** @private */
     private _onStatusChangeCallbacks;
     /** @private */
@@ -136,8 +168,9 @@ declare class Client {
      * 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})
+     * - implicitly call {@link client.Client#init} if not done manually
+     * - start all created contexts. For that to happen, you will have to call `client.init`
+     * manually and instantiate the contexts between `client.init()` and `client.start()`
      *
      * @example
      * import { Client } from '@soundworks/core/client.js'

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

@@ -1 +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"}
+{"version":3,"file":"Client.d.ts","sourceRoot":"","sources":["../../src/client/Client.js"],"names":[],"mappings":";;;;;AAeA;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACE;;;OAGG;IACH,yCAmJC;IAjHC;;;;OAIG;IACH,kBAHS,MAAM,CAGO;IAEtB;;;;OAIG;IACH,MAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,4BAAoB;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,kCAAsC;IAEtC;;;;OAIG;IACH,QAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,cAAiB;IAEjB,eAAe;IACf,iCAAyC;IACzC,eAAe;IACf,oBAAuB;IAKzB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,sBA8EC;IAED;;;;;;;;;;;;;;;OAeG;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

@@ -51,39 +51,66 @@ declare class Context {
     constructor(client: client.Client);
     /**
      * The soundworks client instance.
+     * @type {client.Client}
+     * @readonly
      */
-    client: Client;
+    readonly client: client.Client;
     /**
      * Status of the context, i.e. 'idle', 'inited', 'started', 'errored'
+     * @type {string}
+     * @readonly
      */
-    status: string;
+    readonly status: string;
     /**
-     * Name of the context. Defaults to the class name, override to use a user-defined name.
+     * Optionnal user-defined name of the context (defaults to the class name).
      *
-     * @returns {string} - Name of the context.
+     * The context manager will match the client-side and server-side contexts based
+     * on this name. If the {@link server.ContextManager} don't find a corresponding
+     * user-defined context with the same name, it will use a default (noop) context.
+     *
+     * @readonly
+     * @type {string}
      * @example
+     * // server-side and client-side contexts are matched based on their respective `name`
      * class MyContext extends Context {
      *   get name() {
      *     return 'my-user-defined-context-name';
      *   }
      * }
      */
-    get name(): string;
+    readonly 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()`.
+     * Start the context. This method is lazilly called when the client enters the
+     * context for the first time (cf. ${client.Context#enter}). If you know some
+     * some heavy and/or potentially long job has to be done  when starting the context
+     * (e.g. call to a web service) it may be a good practice to call it explicitely.
+     *
+     * This method should be implemented to perform operations that are valid for the
+     * whole lifetime of the context, regardless the client enters or exits the context.
+     *
+     * @example
+     * import { Context } from '@soundworks/core/client.js';
+     *
+     * class MyContext extends Context {
+     *   async start() {
+     *     await super.start();
+     *     await this.doSomeLongJob();
+     *   }
+     * }
      *
-     * In some situation, you might want to implement this method to handle application
-     * wise behavior regardeless the client enters or exists the context.
+     * // Instantiate the context
+     * const myContext = new Context(client);
+     * // manually start the context to perform the long operation before the client
+     * // enters the context.
+     * await myContext.start();
      */
     start(): Promise<void>;
     /**
      * Stop the context. This method is automatically called when `await client.stop()`
-     * is called.
+     * is called. It should be used to cleanup context wise operations made in `start()`
+     * (e.g. destroy the reusable audio graph).
      *
-     * In some situation, you might want to implement this method to handle application
-     * wise behavior regardeless the client enters or exists the context.
+     * _WARNING: this method should never be called manually._
      */
     stop(): Promise<void>;
     /**
@@ -135,5 +162,4 @@ declare class Context {
      */
     exit(): Promise<any>;
 }
-import Client from "./Client.js";
 //# sourceMappingURL=Context.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"Context.d.ts","sourceRoot":"","sources":["../../src/client/Context.js"],"names":[],"mappings":";AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH;IACE;;;OAGG;IACH,mCAoDC;IA/CC;;;;OAIG;IACH,+BAAoB;IAEpB;;;;OAIG;IACH,iBAHU,MAAM,CAGI;IAqCtB;;;;;;;;;;;;;;;;OAgBG;IACH,4BAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,uBAAgB;IAEhB;;;;;;OAMG;IACH,sBAAe;IAEf;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,sBAeC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,qBAUC;CACF"}

package/types/client/Plugin.d.ts

@@ -3,51 +3,52 @@ 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.
-     */
+    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 the client-side counterpart of a
+ * `soundworks` plugin.
+ *
+ * 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
+ */
+declare class Plugin extends BasePlugin {
     /**
-     * Delete the registered {@link client.Plugin~onStateChangeCallback}.
-     *
-     * @callback client.Plugin~deleteOnStateChangeCallback
+     * @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);
     /**
-     * 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._
+     * Instance of soundworks client.
      *
-     * @memberof client
-     * @extends BasePlugin
-     * @inheritdoc
+     * @type {client.Client}
+     * @see {@link client.Client}
      */
-    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;
-    }
+    client: client.Client;
 }
-import BasePlugin from "../common/BasePlugin.js";
+import BasePlugin from '../common/BasePlugin.js';
 //# sourceMappingURL=Plugin.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"Plugin.d.ts","sourceRoot":"","sources":["../../src/client/Plugin.js"],"names":[],"mappings":";;;;;2BAMW,aAAa;;AAJxB;;;;;GAKG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACE;;;;OAIG;IACH,uCAHW,MAAM,EAahB;IAPC;;;;;OAKG;IACH,sBAAoB;CAevB;uBAhEsB,yBAAyB"}