@soundworks/core 5.4.3 → 5.6.0

package/src/server/Server.js

@@ -1,8 +1,6 @@
 import EventEmitter from 'node:events';
 import fs from 'node:fs';
 import path from 'node:path';
-import os from 'node:os';
-
 
 import {
   isPlainObject,
@@ -10,10 +8,12 @@ import {
   counter,
   getTime,
 } from '@ircam/sc-utils';
-import chalk from 'chalk';
 import Keyv from 'keyv';
 import { KeyvFile } from 'keyv-file';
-import _ from 'lodash';
+import { defu } from 'defu';
+
+import gatedLogger from '../common/logs/gated-logger.js';
+import warnings from '../common/logs/warnings.js';
 
 import auditClassDescription from './audit-state-class-description.js';
 import {
@@ -22,6 +22,7 @@ import {
 } from './crypto.js';
 import {
   createHttpServer,
+  logServerInfos,
 } from './create-http-server.js';
 import ServerClient, {
   kServerClientToken,
@@ -57,7 +58,6 @@ import ServerSockets, {
   kSocketsStart,
   kSocketsStop,
 } from './ServerSockets.js';
-import logger from '../common/logger.js';
 import {
   SERVER_ID,
   CLIENT_HANDSHAKE_REQUEST,
@@ -159,7 +159,7 @@ class Server {
       throw new TypeError(`Cannot construct 'Server': Parameter 1 must be an object`);
     }
 
-    config = _.merge({}, DEFAULT_CONFIG, config);
+    config = defu(config, DEFAULT_CONFIG);
 
     // ---------------------------------------------------------------------
     // Deprecation checks for config
@@ -170,7 +170,7 @@ class Server {
       const clientConfig = config.app.clients[role];
 
       if (clientConfig.target) {
-        logger.deprecated('ClientDescription#target', 'ClientDescription#runtime (or run `npx soundworks --upgrade-config` to upgrade your config files)', '4.0.0-alpha.29');
+        warnings.deprecated('ClientDescription#target', 'ClientDescription#runtime (or run `npx soundworks --upgrade-config` to upgrade your config files)', '4.0.0-alpha.29');
         clientConfig.runtime = clientConfig.target;
         delete clientConfig.target;
       }
@@ -178,7 +178,7 @@ class Server {
 
     // `env.subpath` to `env.baseUrl`
     if ('subpath' in config.env) {
-      logger.deprecated('ServerConfig#subpath', 'ServerConfig#baseUrl (or run `npx soundworks --upgrade-config` to upgrade your config files)', '4.0.0-alpha.29');
+      warnings.deprecated('ServerConfig#subpath', 'ServerConfig#baseUrl (or run `npx soundworks --upgrade-config` to upgrade your config files)', '4.0.0-alpha.29');
       config.env.baseUrl = config.env.subpath;
       delete config.env.subpath;
     }
@@ -240,7 +240,7 @@ class Server {
     // register audit state schema
     this.#stateManager.defineClass(AUDIT_STATE_NAME, auditClassDescription);
 
-    logger.configure(this.#config.env.verbose);
+    gatedLogger.verbose = !!this.#config.env.verbose;
   }
 
   /**
@@ -506,7 +506,7 @@ class Server {
         const { configureHttpRouter } = await import('@soundworks/helpers/server.js');
         configureHttpRouter(this);
       } catch (err) {
-        logger.warn('Could not apply patch for deprecated `useDefaultApplicationTemplate` method. Please use `configureHttpRouter` from helpers instead.');
+        console.warn('Could not apply patch for deprecated `useDefaultApplicationTemplate` method. Please use `configureHttpRouter` from helpers instead.');
         throw err;
       }
     }
@@ -516,7 +516,7 @@ class Server {
       this.#httpServer = await createHttpServer(this);
       await this.#dispatchStatus('http-server-ready');
     } catch (err) {
-      logger.error(err.message);
+      console.error(err.message);
       await this.#dispatchStatus('errored');
       throw err;
     }
@@ -564,31 +564,19 @@ class Server {
     // start `SocketServer`
     await this.#sockets[kSocketsStart]();
     // start httpServer
-    return new Promise(resolve => {
-      const port = this.#config.env.port;
-      const protocol = this.#config.env.useHttps ? 'https' : 'http';
-      const interfaces = os.networkInterfaces();
-
-      this.#httpServer.listen(port, async () => {
-        logger.title(`${protocol} server listening on`);
-
-        Object.keys(interfaces).forEach(dev => {
-          interfaces[dev].forEach(details => {
-            if (details.family === 'IPv4') {
-              logger.ip(protocol, details.address, port);
-            }
-          });
-        });
+    const { promise, resolve } = Promise.withResolvers();
 
-        await this.#dispatchStatus('started');
+    this.#httpServer.listen(this.#config.env.port, async () => {
+      if (this.#config.env.verbose) {
+        logServerInfos(this.#config.env);
+      }
 
-        if (this.#config.env.type === 'development') {
-          logger.log(`\n> press "${chalk.bold('Ctrl + C')}" to exit`);
-        }
+      await this.#dispatchStatus('started');
 
-        resolve();
-      });
+      resolve();
     });
+
+    return promise;
   }
 
   /**
@@ -709,7 +697,7 @@ class Server {
       }
 
       if (version !== this.#version) {
-        logger.warnVersionDiscrepancies(role, version, this.#version);
+        warnings.versionDiscrepancies(role, version, this.#version);
       }
 
       try {
@@ -872,7 +860,7 @@ class Server {
     // @note - keyv-file doesn't seems to works
     const store = new KeyvFile({ filename });
     const db = new Keyv({ namespace, store });
-    db.on('error', err => logger.error(`[soundworks:Server] db ${namespace} error: ${err}`));
+    db.on('error', err => console.error(`namespaced db ("${namespace}") error:`, err));
 
     return db;
   }
@@ -881,7 +869,7 @@ class Server {
    * @deprecated
    */
   useDefaultApplicationTemplate() {
-    logger.deprecated('Server#useDefaultApplicationTemplate', '`configureHttpRouter(server)` from the `@soundworks/helpers/server.js` package', '4.0.0-alpha.29');
+    warnings.deprecated('Server#useDefaultApplicationTemplate', '`configureHttpRouter(server)` from the `@soundworks/helpers/server.js` package', '4.0.0-alpha.29');
     this.#useDefaultApplicationTemplate = true;
   }
 }

package/src/server/ServerClient.js

@@ -1,5 +1,9 @@
-import { counter } from '@ircam/sc-utils';
-import { v4 as uuid } from 'uuid';
+import crypto from 'node:crypto';
+
+import {
+  counter,
+} from '@ircam/sc-utils';
+
 
 const generateId = counter();
 
@@ -24,7 +28,7 @@ class ServerClient {
   constructor(role, socket) {
     this.#role = role;
     this.#id = generateId();
-    this.#uuid = uuid();
+    this.#uuid = crypto.randomUUID();
     this.#socket = socket;
 
     /**

package/src/server/ServerStateManager.js

@@ -1,5 +1,9 @@
-import { counter, isString, isPlainObject, isFunction } from '@ircam/sc-utils';
-import clonedeep from 'lodash/cloneDeep.js';
+import {
+  counter,
+  isString,
+  isPlainObject,
+  isFunction,
+} from '@ircam/sc-utils';
 
 import BaseStateManager, {
   kStateManagerInit,
@@ -32,7 +36,7 @@ import SharedStatePrivate, {
   kSharedStatePrivateGetValues,
 } from './SharedStatePrivate.js';
 
-import logger from '../common/logger.js';
+import warnings from '../common/logs/warnings.js';
 
 
 const generateStateId = counter();
@@ -486,7 +490,7 @@ class ServerStateManager extends BaseStateManager {
       throw new TypeError(`Cannot execute 'defineClass' (${className}) on ServerStateManager: ${err.message}`);
     }
 
-    this.#classes.set(className, clonedeep(classDescription));
+    this.#classes.set(className, structuredClone(classDescription));
     // create hooks list
     this.#createHooksByClassName.set(className, new Set());
     this.#updateHooksByClassName.set(className, new Set());
@@ -497,7 +501,7 @@ class ServerStateManager extends BaseStateManager {
    * @deprecated Use {@link ServerStateManager#defineClass} instead.
    */
   registerSchema(className, classDescription) {
-    logger.deprecated('ServerStateManager#registerSchema', 'ServerStateManager#defineClass', '4.0.0-alpha.29');
+    warnings.deprecated('ServerStateManager#registerSchema', 'ServerStateManager#defineClass', '4.0.0-alpha.29');
     this.defineClass(className, classDescription);
   }
 
@@ -543,7 +547,7 @@ class ServerStateManager extends BaseStateManager {
    * @deprecated Use {@link ServerStateManager#defineClass} instead.
    */
   deleteSchema(className) {
-    logger.deprecated('ServerStateManager#deleteSchema', 'ServerStateManager#deleteClass', '4.0.0-alpha.29');
+    warnings.deprecated('ServerStateManager#deleteSchema', 'ServerStateManager#deleteClass', '4.0.0-alpha.29');
     this.deleteClass(className);
   }
 

package/src/server/SharedStatePrivate.js

@@ -9,6 +9,7 @@ import {
   UPDATE_RESPONSE,
   UPDATE_ABORT,
   UPDATE_NOTIFICATION,
+  HAS_SIBLINGS_NOTIFICATION,
 } from '../common/constants.js';
 import {
   kServerStateManagerDeletePrivateState,
@@ -297,6 +298,8 @@ class SharedStatePrivate {
         this[kSharedStatePrivateDetachClient](instanceId, client);
         client.transport.emit(`${DETACH_RESPONSE}-${this.id}-${instanceId}`, reqId);
       });
+
+      this.#updateHasSiblings();
     }
   }
 
@@ -306,6 +309,22 @@ class SharedStatePrivate {
     client.transport.removeAllListeners(`${UPDATE_REQUEST}-${this.id}-${instanceId}`);
     client.transport.removeAllListeners(`${DELETE_REQUEST}-${this.id}-${instanceId}`);
     client.transport.removeAllListeners(`${DETACH_REQUEST}-${this.id}-${instanceId}`);
+
+    this.#updateHasSiblings();
+  }
+
+  /**
+   * Update hasSiblings property on owner
+   */
+  #updateHasSiblings() {
+    for (let [instanceId, clientInfos] of this.attachedClients) {
+      const { client, isOwner } = clientInfos;
+
+      if (isOwner) {
+        const hasSiblings = this.attachedClients.size > 1;
+        client.transport.emit(`${HAS_SIBLINGS_NOTIFICATION}-${this.id}-${instanceId}`, hasSiblings);
+      }
+    }
   }
 }
 

package/src/server/create-http-server.js

@@ -1,32 +1,26 @@
-import http from 'node:http';
-import https from 'node:https';
-import fs from 'node:fs';
 import {
   X509Certificate,
   createPrivateKey,
 } from 'node:crypto';
+import fs from 'node:fs';
+import http from 'node:http';
+import https from 'node:https';
+import os from 'node:os';
+import {
+  styleText,
+} from 'node:util';
 
-import pem from 'pem';
-import equal from 'fast-deep-equal';
-
-import logger from '../common/logger.js';
-
-/**
- * @private
- * @return {HttpServer|HttpsServer}
- */
-export async function createHttpServer(server) {
-  const serverConfig = server.config;
-
-  if (serverConfig.env.useHttps !== true) {
-    return http.createServer();
-  }
+import selfsigned from 'selfsigned';
 
+async function createHttpsServer(server) {
   // https is more tricky
-  const httpsInfos = serverConfig.env.httpsInfos;
+  const httpsInfos = server.config.env.httpsInfos;
   let useSelfSigned = false;
 
-  if (!httpsInfos || equal(httpsInfos, { cert: null, key: null })) {
+  if (!httpsInfos
+    || !fs.existsSync(httpsInfos.cert)
+    || !fs.existsSync(httpsInfos.key)
+  ) {
     useSelfSigned = true;
   }
 
@@ -77,7 +71,7 @@ export async function createHttpServer(server) {
 
       httpsServer = https.createServer({ key, cert });
     } catch (err) {
-      logger.error(`
+      console.error(`
 Invalid certificate files, please check your:
 - key file: ${httpsInfos.key}
 - cert file: ${httpsInfos.cert}
@@ -86,33 +80,23 @@ Invalid certificate files, please check your:
       throw err;
     }
   } else {
+
     // generate self signed certs or reused already existing ones
     let cert = await server.db.get('httpsCert');
     let key = await server.db.get('httpsKey');
 
     if (!cert || !key) {
       try {
-        const result = await new Promise((resolve, reject) => {
-          pem.createCertificate({ days: 1, selfSigned: true }, async (err, keys) => {
-            if (err) {
-              reject(err);
-              return;
-            }
-
-            resolve({
-              cert: keys.certificate,
-              key: keys.serviceKey,
-            });
-          });
-        });
+        const result = await selfsigned.generate(null);
 
         cert = result.cert;
-        key = result.key;
+        key = result.private;
+
         // store the generated certs to reuse on next start
-        await server.db.set('httpsCert', cert);
-        await server.db.set('httpsKey', key);
+        await server.db.set('httpsCert', cert); // -----BEGIN CERTIFICATE-----
+        await server.db.set('httpsKey', key); // -----BEGIN RSA PRIVATE KEY-----
       } catch (err) {
-        logger.error(err.stack);
+        console.error(err.stack);
         throw err;
       }
     }
@@ -121,7 +105,65 @@ Invalid certificate files, please check your:
     httpsServer = https.createServer({ cert, key });
   }
 
-  logger.httpsCertsInfos(httpsCertsInfos);
+  // Log certificate information, just be verbose
+  console.log(styleText('cyan', `https certificates infos`));
+
+  if (httpsCertsInfos.selfSigned) {
+    console.warn(styleText('yellow', `    -------------------------------------------`));
+    console.warn(styleText('yellow', `    > USING SELF-SIGNED CERTIFICATE.           `));
+    console.warn(styleText('yellow', `    users will face a unsafe web page warning  `));
+    console.warn(styleText('yellow', `    -------------------------------------------`));
+  } else {
+    console.log(`    valid from: ${httpsCertsInfos.validFrom}`);
+    console.log(`    valid to:   ${httpsCertsInfos.validTo}`);
+
+    if (!httpsCertsInfos.isValid) {
+      console.error(styleText('red', `    -------------------------------------------`));
+      console.error(styleText('red', `    > INVALID CERTIFICATE                      `));
+      console.error(styleText('red', `    i.e. you pretend to be safe but you are not`));
+      console.error(styleText('red', `    -------------------------------------------`));
+    } else {
+      if (httpsCertsInfos.daysRemaining < 5) {
+        console.log(styleText('red', `    > CERTIFICATE IS VALID... BUT ONLY ${httpsCertsInfos.daysRemaining} DAYS LEFT, PLEASE CONSIDER UPDATING YOUR CERTS!`));
+      } else if (httpsCertsInfos.daysRemaining < 15) {
+        console.log(styleText('yellow', `    > CERTIFICATE IS VALID - only ${httpsCertsInfos.daysRemaining} days left, be careful...`));
+      } else {
+        console.log(styleText('green', `    > CERTIFICATE IS VALID (${httpsCertsInfos.daysRemaining} days left)`));
+      }
+    }
+  }
 
   return httpsServer;
 }
+
+/**
+ * @private
+ * @return {HttpServer|HttpsServer}
+ */
+export async function createHttpServer(server) {
+  const serverConfig = server.config;
+
+  const httpServer = serverConfig.env.useHttps !== true
+    ? http.createServer()
+    : await createHttpsServer(server);
+
+  return httpServer;
+}
+
+export function logServerInfos(envConfig) {
+  const protocol = envConfig.useHttps ? 'https' : 'http';
+  const port = envConfig.port;
+  const interfaces = os.networkInterfaces();
+
+  console.log(styleText('cyan', `${protocol} server listening on`));
+
+  Object.keys(interfaces).forEach(dev => {
+    interfaces[dev].forEach(details => {
+      if (details.family === 'IPv4') {
+        console.log(`    ${protocol}://${details.address}:${styleText('green', `${port}`)}`);
+      }
+    });
+  });
+
+  console.log(`\n> press "${styleText('bold', 'Ctrl + C')}" to exit`);
+}

package/src/server/crypto.js

@@ -1,11 +1,10 @@
 import crypto from 'node:crypto';
-import { v4 as uuidv4 } from 'uuid';
 
 // adapted from https://dev.to/jobizil/encrypt-and-decrypt-data-in-nodejs-using-aes-256-cbc-2l6d
 // generate a new key and init vector each time the server restart, we don't need
 // any persistency here
-const secretKey = uuidv4();
-const secretIv = uuidv4();
+const secretKey = crypto.randomUUID();
+const secretIv = crypto.randomUUID();
 const encryptionMethod = 'aes-256-cbc';
 
 const key = crypto

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

@@ -1 +1 @@
-{"version":3,"file":"Client.d.ts","sourceRoot":"","sources":["../../src/client/Client.js"],"names":[],"mappings":"AA6BA,+CAA2E;AAC3E,2DAAqG;;AAErG;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAeE;;;OAGG;IACH,oBAHW,YAAY,EA+DtB;IAED;;;;OAIG;IACH,eAFU,MAAM,CAIf;IAED;;;;OAIG;IACH,YAFU,MAAM,CAIf;IAED;;;;OAIG;IACH,cAFU,YAAY,CAIrB;IAED;;;;;;;OAOG;IACH,UAFU,MAAM,CAIf;IAED;;;;;OAKG;IACH,YAFU,MAAM,CAIf;IAED;;;;;;;OAOG;IACH,aAFU,MAAM,CAIf;IAED;;;;OAIG;IACH,eAFU,MAAM,GAAC,SAAS,CAIzB;IAED;;OAEG;IACH,iCAGC;IAED;;;;;OAKG;IACH,cAFU,YAAY,CAIrB;IAED;;;;;;;OAOG;IACH,sBAFU,oBAAoB,CAI7B;IAED;;;;;;;OAOG;IACH,8CAEC;IAED;;;;;;;OAOG;IACH,oBAFU,kBAAkB,CAI3B;IAED;;;;OAIG;IACH,cAFU,MAAM,GAAC,QAAQ,GAAC,SAAS,GAAC,SAAS,CAI5C;IAqBD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,sBA0DC;IAED;;;;;;;;;;;;;;;OAeG;IACH,uBAgBC;IAED;;;;;;;;;;;;;;;OAeG;IACH,sBAcC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,iBAPa,OAAO,CAAC,WAAW,CAAC,CAiBhC;IAED;;;;;OAKG;IACH,6CAGC;IA3VC,2CAAgD;;CA4VnD;yBAndM,mBAAmB;iCARnB,2BAA2B;gCACF,0BAA0B;+BAQ3B,yBAAyB"}
+{"version":3,"file":"Client.d.ts","sourceRoot":"","sources":["../../src/client/Client.js"],"names":[],"mappings":"AAgCA,+CAA2E;AAC3E,2DAAqG;;AAErG;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAeE;;;OAGG;IACH,oBAHW,YAAY,EA+DtB;IAED;;;;OAIG;IACH,eAFU,MAAM,CAIf;IAED;;;;OAIG;IACH,YAFU,MAAM,CAIf;IAED;;;;OAIG;IACH,cAFU,YAAY,CAIrB;IAED;;;;;;;OAOG;IACH,UAFU,MAAM,CAIf;IAED;;;;;OAKG;IACH,YAFU,MAAM,CAIf;IAED;;;;;;;OAOG;IACH,aAFU,MAAM,CAIf;IAED;;;;OAIG;IACH,eAFU,MAAM,GAAC,SAAS,CAIzB;IAED;;OAEG;IACH,iCAGC;IAED;;;;;OAKG;IACH,cAFU,YAAY,CAIrB;IAED;;;;;;;OAOG;IACH,sBAFU,oBAAoB,CAI7B;IAED;;;;;;;OAOG;IACH,8CAEC;IAED;;;;;;;OAOG;IACH,oBAFU,kBAAkB,CAI3B;IAED;;;;OAIG;IACH,cAFU,MAAM,GAAC,QAAQ,GAAC,SAAS,GAAC,SAAS,CAI5C;IAqBD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,sBA0DC;IAED;;;;;;;;;;;;;;;OAeG;IACH,uBAgBC;IAED;;;;;;;;;;;;;;;OAeG;IACH,sBAcC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,iBAPa,OAAO,CAAC,WAAW,CAAC,CAiBhC;IAED;;;;;OAKG;IACH,6CAGC;IA3VC,2CAAgD;;CA4VnD;yBAtdM,mBAAmB;iCARnB,2BAA2B;gCACF,0BAA0B;+BAQ3B,yBAAyB"}

package/types/client/ClientPluginManager.d.ts

@@ -86,7 +86,7 @@ declare class ClientPluginManager<T> extends BasePluginManager {
      * // server-side
      * server.pluginManager.register('user-defined-id', pluginFactory);
      */
-    register(id: string, ctor: T<ClientPlugin>, options?: object, deps?: any[]): void;
+    register(id: string, ctor: T<ClientPlugin>, options?: object, deps?: array): void;
     /**
      * Retrieve an fully started instance of a registered plugin.
      *

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

@@ -1 +1 @@
-{"version":3,"file":"ClientPluginManager.d.ts","sourceRoot":"","sources":["../../src/client/ClientPluginManager.js"],"names":[],"mappings":";AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,kCAFa,CAAC;IAGZ;;;OAGG;IACH,oBAHW,MAAM,EAShB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,aAfW,MAAM,QAEN,CAAC,CAAC,YAAY,CAAC,YACf,MAAM,sBAmBhB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,QAHW,MAAM,GACJ,OAAO,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAQpC;CACF;8BAnI6B,gCAAgC;mBAD3C,aAAa"}
+{"version":3,"file":"ClientPluginManager.d.ts","sourceRoot":"","sources":["../../src/client/ClientPluginManager.js"],"names":[],"mappings":";AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,kCAFa,CAAC;IAGZ;;;OAGG;IACH,oBAHW,MAAM,EAShB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,aAfW,MAAM,QAEN,CAAC,CAAC,YAAY,CAAC,YACf,MAAM,SACN,KAAK,QAkBf;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,QAHW,MAAM,GACJ,OAAO,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAQpC;CACF;8BAnI6B,gCAAgC;mBAD3C,aAAa"}

package/types/client/ClientSocket.d.ts

@@ -61,6 +61,10 @@ declare class ClientSocket {
      * @param {string} channel - Channel name.
      */
     removeAllListeners(channel?: string): void;
+    /**
+     * Close the socket, will dispatch the close event. For debug testing purpose
+     */
+    close(): void;
     /**
      * Removes all listeners and immediately close the two sockets. Is automatically
      * called on `client.stop()`

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

@@ -1 +1 @@
-{"version":3,"file":"ClientSocket.d.ts","sourceRoot":"","sources":["../../src/client/ClientSocket.js"],"names":[],"mappings":"AAaA,6CAAsE;;AAEtE;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAOE,wDAIC;IAED;;;;;;;OAOG;IACH,aA4HC;IAoCD;;;;;;OAMG;IACH,cAJW,MAAM,WACH,GAAC,EAAA,QAQd;IAED;;;;;;;OAOG;IACH,qBALW,MAAM,4BAYhB;IAED;;;;;OAKG;IACH,wBAHW,MAAM,4BAYhB;IAED;;;;OAIG;IACH,6BAFW,MAAM,QAQhB;IA7FD;;;;;;;;;OASG;IACH,2BAWC;;CAyEF"}
+{"version":3,"file":"ClientSocket.d.ts","sourceRoot":"","sources":["../../src/client/ClientSocket.js"],"names":[],"mappings":"AAYA,6CAAsE;;AAEtE;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAOE,wDAIC;IAED;;;;;;;OAOG;IACH,aA4HC;IAoCD;;;;;;OAMG;IACH,cAJW,MAAM,WACH,GAAC,EAAA,QAQd;IAED;;;;;;;OAOG;IACH,qBALW,MAAM,4BAYhB;IAED;;;;;OAKG;IACH,wBAHW,MAAM,4BAYhB;IAED;;;;OAIG;IACH,6BAFW,MAAM,QAQhB;IAED;;OAEG;IACH,cAEC;IApGD;;;;;;;;;OASG;IACH,2BAWC;;CAgFF"}

package/types/client/index.d.ts

@@ -9,11 +9,11 @@ export type ClientAppConfig = {
     /**
      * - Name of the application.
      */
-    name?: string;
+    name?: string | undefined;
     /**
      * - Name of the author.
      */
-    author?: string;
+    author?: string | undefined;
 };
 /**
  * Environment configuration object.
@@ -35,7 +35,7 @@ export type ClientEnvConfig = {
     /**
      * - If running behind a proxy, base URL of the application.
      */
-    baseUrl?: string;
+    baseUrl?: string | undefined;
 };
 /**
  * Configuration object for a client running in a browser runtime.

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.js"],"names":[],"mappings":";;;;;;;;;;;WAac,MAAM;;;;aACN,MAAM;;;;;;;;;UAON,MAAM;;;;;mBACN,MAAM;;;;cAEN,OAAO;;;;cACP,MAAM;;;;;;;;;UAON,MAAM;;;;SACN,eAAe;;;;SACf,eAAe"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;UAqBc,MAAM;;;;;mBACN,MAAM;;;;cAEN,OAAO;;;;;;;;;;;;;UAQP,MAAM;;;;SACN,eAAe;;;;SACf,eAAe"}

package/types/common/BasePluginManager.d.ts

@@ -81,7 +81,7 @@ declare class BasePluginManager {
      * // server-side
      * server.pluginManager.register('user-defined-id', pluginFactory);
      */
-    register(id: string, ctor: Function, options?: object, deps?: any[]): void;
+    register(id: string, ctor: Function, options?: object, deps?: array): void;
     /**
      * Manually add a dependency to a given plugin.
      *

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

@@ -1 +1 @@
-{"version":3,"file":"BasePluginManager.d.ts","sourceRoot":"","sources":["../../src/common/BasePluginManager.js"],"names":[],"mappings":"AAQA,gDAA6E;AAC7E,+CAA2E;AAC3E,oDAAqF;;;;;oDAM1E,MAAM,aACN,YAAY,GAAC,YAAY,GAAC,IAAI;;;;;AALzC;;;;;;;;GAQG;AAEH;;;;GAIG;AAEH,eAAe;AACf;IAQE,uBAIC;IA8DD;;;;OAIG;IACH,cAFU,MAAM,GAAC,QAAQ,GAAC,SAAS,GAAC,SAAS,CAI5C;IAED;;;;OAIG;IACH,kBAEC;IAED;;;;;;;;;OASG;IACH,iCAqDC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,aAfW,MAAM,4BAGN,MAAM,sBA6ChB;IAED;;;;OAIG;IACH,sDAGC;IAED;;;OAGG;IACH,wBAFa,MAAM,EAAE,CAIpB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,wBAhBW,kCAAkC,GAChC,wCAAwC,CAkBpD;IA9OD;;;;;;OAMG;IACH,8BAyBC;IAED,eAAe;IACf,6BAQC;IA9DC,eAAe;IACf,kCAAyC;;CAiQ5C"}
+{"version":3,"file":"BasePluginManager.d.ts","sourceRoot":"","sources":["../../src/common/BasePluginManager.js"],"names":[],"mappings":"AAQA,gDAA6E;AAC7E,+CAA2E;AAC3E,oDAAqF;;;;;oDAM1E,MAAM,aACN,YAAY,GAAC,YAAY,GAAC,IAAI;;;;;AALzC;;;;;;;;GAQG;AAEH;;;;GAIG;AAEH,eAAe;AACf;IAQE,uBAIC;IA8DD;;;;OAIG;IACH,cAFU,MAAM,GAAC,QAAQ,GAAC,SAAS,GAAC,SAAS,CAI5C;IAED;;;;OAIG;IACH,kBAEC;IAED;;;;;;;;;OASG;IACH,iCAqDC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,aAfW,MAAM,4BAGN,MAAM,SACN,KAAK,QA4Cf;IAED;;;;OAIG;IACH,sDAGC;IAED;;;OAGG;IACH,wBAFa,MAAM,EAAE,CAIpB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,wBAhBW,kCAAkC,GAChC,wCAAwC,CAkBpD;IA9OD;;;;;;OAMG;IACH,8BAyBC;IAED,eAAe;IACf,6BAQC;IA9DC,eAAe;IACf,kCAAyC;;CAiQ5C"}

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

@@ -1 +1 @@
-{"version":3,"file":"BaseStateManager.d.ts","sourceRoot":"","sources":["../../src/common/BaseStateManager.js"],"names":[],"mappings":"AA2BA,8CAAyE;AACzE,qDAAwF;AAExF,gDAA6E;;;;;;;;;;;AAE7E;;;;;;;;GAQG;AACH;;;;;GAKG;AAEH,eAAe;AACf;IAuLE;;;;;;OAMG;IACH,2CAHW,GAAC,QAKX;IAED;;;;;;;;OAQG;IACH,+BANW,oBAAoB,GAEnB,2BAA2B,CAatC;IAED;;OAEG;IACH,wCAGC;IAED;;;;;;;;OAQG;IACH,kBANW,oBAAoB;;QAElB,OAAO,CAAC,WAAW,CAAC,CAahC;;;;;;;;;;;IAKE,kBACQ,oBAAoB,GAClB,OAAO,CAAC,WAAW,CAAC,CAE9B;;;;;;;;;;;;IAMA,kBACQ,oBAAoB,WACpB,MAAM,GACJ,OAAO,CAAC,WAAW,CAAC,CAE9B;;;;;;;;;;;;IAMA,kBACQ,oBAAoB,UACpB,MAAM,EAAE,GACN,OAAO,CAAC,WAAW,CAAC,CAE9B;;;;;;;;;;;;;IAMA,kBACQ,oBAAoB,WACpB,MAAM,UACN,MAAM,EAAE,GACN,OAAO,CAAC,WAAW,CAAC,CAE9B;;;;;;;;;;;;;;IAsEA,kBACQ,2BAA2B,OAEnC;;;;;;;;;;;;;;;IAWA,mBACQ,oBAAoB,YAEpB,2BAA2B,OAEnC;;;;;;;;;;;;;;;;;;IASA,kBACQ,2BAA2B,WAGnC;QAAyB,YAAY,EAA7B,OAAO;KAEf,OAAA;;;;;;;;;;;;;;;;;;IAWA,mBACQ,oBAAoB,YAEpB,2BAA2B,WAGnC;QAAyB,YAAY,EAA7B,OAAO;KAEf,OAAA;;;;;;;;;;;IAwJA,yBACQ,oBAAoB,GAClB,OAAO,CAAC,qBAAqB,CAAC,CAExC;;;;;;;;;;;;;IAMA,yBACQ,oBAAoB,UACpB,wBAAwB,EAAE,GAExB,OAAO,CAAC,qBAAqB,CAAC,CAExC;;;;;;;;;;;;;;IAMA,yBACQ,oBAAoB,WAE5B;QAAyB,YAAY,EAA7B,OAAO;KAEf,GAAU,OAAO,CAAC,qBAAqB,CAAC,CAExC;;;;;;;;;;;;;;;;IAMA,yBACQ,oBAAoB,UACpB,wBAAwB,EAAE,WAGlC;QAAyB,YAAY,EAA7B,OAAO;KAEf,GAAU,OAAO,CAAC,qBAAqB,CAAC,CAExC;IA7jBH,eAAe;IACf,mCAEC;IAED;;;;;;;OAOG;IACH,4BA2IC;IA5KC,eAAe;IACf,8BAAgC;;CAupBnC;wBAjtBuB,kBAAkB;kCAGnC,4BAA4B"}
+{"version":3,"file":"BaseStateManager.d.ts","sourceRoot":"","sources":["../../src/common/BaseStateManager.js"],"names":[],"mappings":"AAgCA,8CAAyE;AACzE,qDAAwF;AAExF,gDAA6E;;;;;;;;;;;AAE7E;;;;;;;;GAQG;AACH;;;;;GAKG;AAEH,eAAe;AACf;IAuLE;;;;;;OAMG;IACH,2CAHW,GAAC,QAKX;IAED;;;;;;;;OAQG;IACH,+BANW,oBAAoB,GAEnB,2BAA2B,CAatC;IAED;;OAEG;IACH,wCAGC;IAED;;;;;;;;OAQG;IACH,kBANW,oBAAoB;;QAElB,OAAO,CAAC,WAAW,CAAC,CAahC;;;;;;;;;;;IAKE,kBACQ,oBAAoB,GAClB,OAAO,CAAC,WAAW,CAAC,CAE9B;;;;;;;;;;;;IAMA,kBACQ,oBAAoB,WACpB,MAAM,GACJ,OAAO,CAAC,WAAW,CAAC,CAE9B;;;;;;;;;;;;IAMA,kBACQ,oBAAoB,UACpB,MAAM,EAAE,GACN,OAAO,CAAC,WAAW,CAAC,CAE9B;;;;;;;;;;;;;IAMA,kBACQ,oBAAoB,WACpB,MAAM,UACN,MAAM,EAAE,GACN,OAAO,CAAC,WAAW,CAAC,CAE9B;;;;;;;;;;;;;;IAsEA,kBACQ,2BAA2B,OAEnC;;;;;;;;;;;;;;;IAWA,mBACQ,oBAAoB,YAEpB,2BAA2B,OAEnC;;;;;;;;;;;;;;;;;;IASA,kBACQ,2BAA2B,WAGnC;QAAyB,YAAY,EAA7B,OAAO;KAEf,OAAA;;;;;;;;;;;;;;;;;;IAWA,mBACQ,oBAAoB,YAEpB,2BAA2B,WAGnC;QAAyB,YAAY,EAA7B,OAAO;KAEf,OAAA;;;;;;;;;;;IAwJA,yBACQ,oBAAoB,GAClB,OAAO,CAAC,qBAAqB,CAAC,CAExC;;;;;;;;;;;;;IAMA,yBACQ,oBAAoB,UACpB,wBAAwB,EAAE,GAExB,OAAO,CAAC,qBAAqB,CAAC,CAExC;;;;;;;;;;;;;;IAMA,yBACQ,oBAAoB,WAE5B;QAAyB,YAAY,EAA7B,OAAO;KAEf,GAAU,OAAO,CAAC,qBAAqB,CAAC,CAExC;;;;;;;;;;;;;;;;IAMA,yBACQ,oBAAoB,UACpB,wBAAwB,EAAE,WAGlC;QAAyB,YAAY,EAA7B,OAAO;KAEf,GAAU,OAAO,CAAC,qBAAqB,CAAC,CAExC;IA7jBH,eAAe;IACf,mCAEC;IAED;;;;;;;OAOG;IACH,4BA2IC;IA5KC,eAAe;IACf,8BAAgC;;CAupBnC;wBAjtBuB,kBAAkB;kCAGnC,4BAA4B"}

package/types/common/BatchedTransport.d.ts

@@ -8,7 +8,7 @@ declare class BatchedTransport {
     addListener(channel: any, callback: any): void;
     emit(channel: any, ...args: any[]): Promise<void>;
     removeListener(channel: any, callback: any): void;
-    removeAllListeners(channel?: any): void;
+    removeAllListeners(channel?: null): void;
     #private;
 }
 //# sourceMappingURL=BatchedTransport.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"BatchedTransport.d.ts","sourceRoot":"","sources":["../../src/common/BatchedTransport.js"],"names":[],"mappings":";AAEA;;;GAGG;AACH;IAME,4BAeC;IAED,+CAOC;IAED,kDAWC;IAED,kDAKC;IAED,wCAOC;;CACF"}
+{"version":3,"file":"BatchedTransport.d.ts","sourceRoot":"","sources":["../../src/common/BatchedTransport.js"],"names":[],"mappings":";AAEA;;;GAGG;AACH;IAME,4BAeC;IAED,+CAOC;IAED,kDAWC;IAED,kDAKC;IAED,yCAOC;;CACF"}

package/types/common/ParameterBag.d.ts

@@ -11,13 +11,13 @@ export namespace types {
     export namespace boolean {
         let required_1: string[];
         export { required_1 as required };
-        export const defaultOptions: any;
-        export function coerceFunction(name: any, def: any, value: any): boolean;
+        export namespace defaultOptions { }
+        export function coerceFunction(name: any, def: any, value: any): value is true;
     }
     export namespace string {
         let required_2: string[];
         export { required_2 as required };
-        const defaultOptions_1: any;
+        export namespace defaultOptions_1 { }
         export { defaultOptions_1 as defaultOptions };
         export function coerceFunction_1(name: any, def: any, value: any): string;
         export { coerceFunction_1 as coerceFunction };
@@ -25,7 +25,18 @@ export namespace types {
     export namespace integer {
         let required_3: string[];
         export { required_3 as required };
-        const defaultOptions_2: any;
+        const defaultOptions_2: {
+            nullable: boolean;
+            event: boolean;
+            required: boolean;
+            metas: {};
+            filterChange: boolean;
+            immediate: boolean;
+            acknowledge: boolean;
+        } & {
+            min: number;
+            max: number;
+        };
         export { defaultOptions_2 as defaultOptions };
         export function sanitizeDescription(def: any): any;
         export function coerceFunction_2(name: any, def: any, value: any): number;
@@ -34,7 +45,18 @@ export namespace types {
     export namespace float {
         let required_4: string[];
         export { required_4 as required };
-        const defaultOptions_3: any;
+        const defaultOptions_3: {
+            nullable: boolean;
+            event: boolean;
+            required: boolean;
+            metas: {};
+            filterChange: boolean;
+            immediate: boolean;
+            acknowledge: boolean;
+        } & {
+            min: number;
+            max: number;
+        };
         export { defaultOptions_3 as defaultOptions };
         export function sanitizeDescription_1(def: any): any;
         export { sanitizeDescription_1 as sanitizeDescription };
@@ -44,7 +66,7 @@ export namespace types {
     export namespace _enum {
         let required_5: string[];
         export { required_5 as required };
-        const defaultOptions_4: any;
+        export namespace defaultOptions_4 { }
         export { defaultOptions_4 as defaultOptions };
         export function coerceFunction_4(name: any, def: any, value: any): any;
         export { coerceFunction_4 as coerceFunction };
@@ -53,7 +75,7 @@ export namespace types {
     export namespace any {
         let required_6: string[];
         export { required_6 as required };
-        const defaultOptions_5: any;
+        export namespace defaultOptions_5 { }
         export { defaultOptions_5 as defaultOptions };
         export function coerceFunction_5(name: any, def: any, value: any): any;
         export { coerceFunction_5 as coerceFunction };
@@ -135,7 +157,7 @@ declare class ParameterBag {
     /**
      * @return {object}
      */
-    getDescription(name?: any): object;
+    getDescription(name?: null): object;
     getInitValues(): {};
     getDefaults(): {};
     getParamListByDescriptor(descriptorName: any, descriptorValue: any): string[];

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

@@ -1 +1 @@
-{"version":3,"file":"ParameterBag.d.ts","sourceRoot":"","sources":["../../src/common/ParameterBag.js"],"names":[],"mappings":";;;;;;;;;;;;;;QAuBoB,yEAMf;;;;;;;QAOe,0EAMf;;;;;;;;QAUoB,mDAgBpB;QACe,0EAMf;;;;;;;;QAUoB,qDAgBpB;;QACe,0EAMf;;;;;;;;QAOe,uEAOf;;;;;;;;;QAOe,uEAGf;;;;;AAKL,eAAe;AACf;IACE,mDAoCC;IAED,iDAyBC;IAKD,+CAyCC;IAED;;;;;OAKG;IACH,UAHW,MAAM,WAKhB;IAED;;;;;OAKG;IACH,aAFY,MAAM,CAUjB;IAED;;;;;;;;OAQG;IACH,mBAFY,MAAM,CAUjB;IAED;;;;;;OAMG;IACH,UAHW,MAAM,GACL,KAAK,CAchB;IAED;;;;;;;;;OASG;IACH,gBAHW,MAAM,GACL,KAAK,CAQhB;IAED;;;;;OAKG;IACH,iCAFW,KAAK,SAmBf;IAED;;;;;;;;OAQG;IACH,UAJW,MAAM,SACN,KAAK,SAqBf;IAED;;;;;;OAMG;IAWH;;OAEG;IACH,4BAFY,MAAM,CAYjB;IAGD,oBAQC;IAGD,kBAQC;IAGD,8EAUC;;CACF"}
+{"version":3,"file":"ParameterBag.d.ts","sourceRoot":"","sources":["../../src/common/ParameterBag.js"],"names":[],"mappings":";;;;;;;;;;;;;;QAuBoB,+EAMf;;;;;;;QAOe,0EAMf;;;;;;;;;;;;;;;;;;;QAUoB,mDAgBpB;QACe,0EAMf;;;;;;;;;;;;;;;;;;;QAUoB,qDAgBpB;;QACe,0EAMf;;;;;;;;QAOe,uEAOf;;;;;;;;;QAOe,uEAGf;;;;;AAKL,eAAe;AACf;IACE,mDAoCC;IAED,iDAyBC;IAKD,+CAyCC;IAED;;;;;OAKG;IACH,UAHW,MAAM,WAKhB;IAED;;;;;OAKG;IACH,aAFY,MAAM,CAUjB;IAED;;;;;;;;OAQG;IACH,mBAFY,MAAM,CAUjB;IAED;;;;;;OAMG;IACH,UAHW,MAAM,GACL,KAAK,CAchB;IAED;;;;;;;;;OASG;IACH,gBAHW,MAAM,GACL,KAAK,CAQhB;IAED;;;;;OAKG;IACH,iCAFW,KAAK,SAmBf;IAED;;;;;;;;OAQG;IACH,UAJW,MAAM,SACN,KAAK,SAqBf;IAED;;;;;;OAMG;IAWH;;OAEG;IACH,6BAFY,MAAM,CAYjB;IAGD,oBAQC;IAGD,kBAQC;IAGD,8EAUC;;CACF"}

package/types/common/PromiseStore.d.ts

@@ -3,7 +3,7 @@ export default class PromiseStore {
     constructor(name: any);
     name: any;
     store: Map<any, any>;
-    generateId: any;
+    generateId: Function;
     createPromise(): {
         id: any;
         promise: any;

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

@@ -1 +1 @@
-{"version":3,"file":"PromiseStore.d.ts","sourceRoot":"","sources":["../../src/common/PromiseStore.js"],"names":[],"mappings":"AAKA,eAAe;AACf;IACE,uBAIC;IAHC,UAAgB;IAChB,qBAAsB;IACtB,gBAA2B;IAG7B;;;MAYC;IAID,yDAGC;IAED,kCAcC;IAED,gCASC;IAGD,cAMC;CACF"}
+{"version":3,"file":"PromiseStore.d.ts","sourceRoot":"","sources":["../../src/common/PromiseStore.js"],"names":[],"mappings":"AAKA,eAAe;AACf;IACE,uBAIC;IAHC,UAAgB;IAChB,qBAAsB;IACtB,qBAA2B;IAG7B;;;MAYC;IAID,yDAGC;IAED,kCAcC;IAED,gCASC;IAGD,cAMC;CACF"}