@soundworks/core 5.5.0 → 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/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;IAED;;OAEG;IACH,cAEC;IApGD;;;;;;;;;OASG;IACH,2BAWC;;CAgFF"}
+{"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/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/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 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 };

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

@@ -1 +1 @@
-{"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"}
+{"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/SharedState.d.ts

@@ -108,6 +108,13 @@ declare class SharedState {
      * @type {Boolean}
      */
     get isOwner(): boolean;
+    /**
+     * Indicates if the node as siblings, i.e. if several versions of the same state
+     * exists on the network
+     * Always return true if the state instance is attached
+     * @type {Boolean}
+     */
+    get hasSiblings(): boolean;
     /**
      * Return the underlying {@link SharedStateClassDescription} or the
      * {@link SharedStateParameterDescription} if `paramName` is given.

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

@@ -1 +1 @@
-{"version":3,"file":"SharedState.d.ts","sourceRoot":"","sources":["../../src/common/SharedState.js"],"names":[],"mappings":"AA0BA,qDAAwF;;;;;sDAM7E,MAAM,aAEN,MAAM;;;;;AANjB;;;;;;;;GAQG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH;IAeE;;;;;;;;;OA4JC;IAED;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;OAEG;IACH,yBAGC;IAED;;;OAGG;IACH,uBAEC;IAwED;;;;;;;;;;;OAWG;IACH,2BARW,MAAM,GAEL,2BAA2B,GAAC,+BAA+B,CAYtE;IAED;;OAEG;IACH,iCAGC;;;;;;;;;;;IAQE,aACQ,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAC3B;;;;;;;;;;;;IAOE,UACQ,wBAAwB,SACxB,GAAC,GACC,OAAO,CAAC,MAAM,CAAC,CAC3B;IAyKD;;;;;;;;;;;;;;OAcG;IACH,UANW,wBAAwB,GACvB,GAAG,CAiBd;IAED;;;;;;;;;;;;;;OAcG;IACH,gBANW,wBAAwB,GACvB,GAAG,CAiBd;IAED;;;;;;;;OAQG;IACH,aAJY,MAAM,CAgBjB;IAED;;;;;;;;;;;;OAYG;IACH,mBAJY,MAAM,CAgBjB;IAED;;;;;;;OAOG;IACH,iBAJY,MAAM,CAMjB;IAED;;;;;;OAMG;IACH,eAJY,MAAM,CAMjB;IAED;;;;;;;;OAQG;IACH,uBAiBC;IAED;;;;;;;;;;;;;;OAcG;IACH,uBAUC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,oDAba,iCAAiC,CAkC7C;IAED;;;;;;;OAOG;IACH,4CAGC;IAED;;;;;;OAMG;IACH,4CAOC;IArsBC,eAAe;IACf,mCAAwE;;CAqsB3E"}
+{"version":3,"file":"SharedState.d.ts","sourceRoot":"","sources":["../../src/common/SharedState.js"],"names":[],"mappings":"AA2BA,qDAAwF;;;;;sDAM7E,MAAM,aAEN,MAAM;;;;;AANjB;;;;;;;;GAQG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH;IAiBE;;;;;;;;;OAkKC;IAED;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;OAEG;IACH,yBAGC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;;OAKG;IACH,2BAUC;IAwED;;;;;;;;;;;OAWG;IACH,2BARW,MAAM,GAEL,2BAA2B,GAAC,+BAA+B,CAYtE;IAED;;OAEG;IACH,iCAGC;;;;;;;;;;;IAQE,aACQ,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAC3B;;;;;;;;;;;;IAOE,UACQ,wBAAwB,SACxB,GAAC,GACC,OAAO,CAAC,MAAM,CAAC,CAC3B;IA8KD;;;;;;;;;;;;;;OAcG;IACH,UANW,wBAAwB,GACvB,GAAG,CAiBd;IAED;;;;;;;;;;;;;;OAcG;IACH,gBANW,wBAAwB,GACvB,GAAG,CAiBd;IAED;;;;;;;;OAQG;IACH,aAJY,MAAM,CAgBjB;IAED;;;;;;;;;;;;OAYG;IACH,mBAJY,MAAM,CAgBjB;IAED;;;;;;;OAOG;IACH,iBAJY,MAAM,CAMjB;IAED;;;;;;OAMG;IACH,eAJY,MAAM,CAMjB;IAED;;;;;;;;OAQG;IACH,uBAiBC;IAED;;;;;;;;;;;;;;OAcG;IACH,uBAUC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,oDAba,iCAAiC,CAkC7C;IAED;;;;;;;OAOG;IACH,4CAGC;IAED;;;;;;OAMG;IACH,4CAOC;IAluBC,eAAe;IACf,mCAAwE;;CAkuB3E"}

package/types/common/constants.d.ts

@@ -29,6 +29,7 @@ export const DELETE_SHARED_STATE_CLASS: "s:d:s";
 export const GET_CLASS_DESCRIPTION_REQUEST: "s:s:req";
 export const GET_CLASS_DESCRIPTION_RESPONSE: "s:s:res";
 export const GET_CLASS_DESCRIPTION_ERROR: "s:s:err";
+export const HAS_SIBLINGS_NOTIFICATION: "s:hs:not";
 export const CONTEXT_ENTER_REQUEST: "c:en:req";
 export const CONTEXT_ENTER_RESPONSE: "c:en:res";
 export const CONTEXT_ENTER_ERROR: "c:en:err";

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

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/common/constants.js"],"names":[],"mappings":"AACA,wBAAyB,CAAC,CAAC,CAAC;AAE5B,mCAAuC;AACvC,2BAA4B,QAAQ,CAAC;AACrC,2BAA4B,QAAQ,CAAC;AAGrC,wCAAyC,KAAK,CAAC;AAG/C,6BAA8B,SAAS,CAAC;AACxC,8BAA+B,SAAS,CAAC;AACzC,2BAA4B,SAAS,CAAC;AAEtC,6BAA8B,UAAU,CAAC;AACzC,8BAA+B,UAAU,CAAC;AAC1C,2BAA4B,UAAU,CAAC;AACvC,kCAAmC,UAAU,CAAC;AAE9C,6BAA8B,SAAS,CAAC;AACxC,8BAA+B,SAAS,CAAC;AACzC,2BAA4B,SAAS,CAAC;AAEtC,6BAA8B,UAAU,CAAC;AACzC,8BAA+B,UAAU,CAAC;AAC1C,2BAA4B,UAAU,CAAC;AAEvC,8BAA+B,SAAS,CAAC;AACzC,+BAAgC,SAAS,CAAC;AAC1C,4BAA6B,SAAS,CAAC;AACvC,mCAAoC,SAAS,CAAC;AAE9C,qCAAsC,UAAU,CAAC;AAEjD,6BAA8B,SAAS,CAAC;AACxC,8BAA+B,SAAS,CAAC;AACzC,2BAA4B,QAAQ,CAAC;AACrC,kCAAmC,SAAS,CAAC;AAE7C,wCAAyC,OAAO,CAAC;AAEjD,4CAA6C,SAAS,CAAC;AACvD,6CAA8C,SAAS,CAAC;AACxD,0CAA2C,SAAS,CAAC;AAGrD,oCAAqC,UAAU,CAAC;AAChD,qCAAsC,UAAU,CAAC;AACjD,kCAAmC,UAAU,CAAC;AAE9C,mCAAoC,UAAU,CAAC;AAC/C,oCAAqC,UAAU,CAAC;AAChD,iCAAkC,UAAU,CAAC;AAG7C,uCAAwC,UAAU,CAAC;AACnD,wCAAyC,UAAU,CAAC;AACpD,qCAAsC,UAAU,CAAC;AAGjD,+BAAgC,WAAW,CAAC;AAC5C,sCAAiD"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/common/constants.js"],"names":[],"mappings":"AACA,wBAAyB,CAAC,CAAC,CAAC;AAE5B,mCAAuC;AACvC,2BAA4B,QAAQ,CAAC;AACrC,2BAA4B,QAAQ,CAAC;AAGrC,wCAAyC,KAAK,CAAC;AAG/C,6BAA8B,SAAS,CAAC;AACxC,8BAA+B,SAAS,CAAC;AACzC,2BAA4B,SAAS,CAAC;AAEtC,6BAA8B,UAAU,CAAC;AACzC,8BAA+B,UAAU,CAAC;AAC1C,2BAA4B,UAAU,CAAC;AACvC,kCAAmC,UAAU,CAAC;AAE9C,6BAA8B,SAAS,CAAC;AACxC,8BAA+B,SAAS,CAAC;AACzC,2BAA4B,SAAS,CAAC;AAEtC,6BAA8B,UAAU,CAAC;AACzC,8BAA+B,UAAU,CAAC;AAC1C,2BAA4B,UAAU,CAAC;AAEvC,8BAA+B,SAAS,CAAC;AACzC,+BAAgC,SAAS,CAAC;AAC1C,4BAA6B,SAAS,CAAC;AACvC,mCAAoC,SAAS,CAAC;AAE9C,qCAAsC,UAAU,CAAC;AAEjD,6BAA8B,SAAS,CAAC;AACxC,8BAA+B,SAAS,CAAC;AACzC,2BAA4B,QAAQ,CAAC;AACrC,kCAAmC,SAAS,CAAC;AAE7C,wCAAyC,OAAO,CAAC;AAEjD,4CAA6C,SAAS,CAAC;AACvD,6CAA8C,SAAS,CAAC;AACxD,0CAA2C,SAAS,CAAC;AAErD,wCAAyC,UAAU,CAAC;AAGpD,oCAAqC,UAAU,CAAC;AAChD,qCAAsC,UAAU,CAAC;AACjD,kCAAmC,UAAU,CAAC;AAE9C,mCAAoC,UAAU,CAAC;AAC/C,oCAAqC,UAAU,CAAC;AAChD,iCAAkC,UAAU,CAAC;AAG7C,uCAAwC,UAAU,CAAC;AACnD,wCAAyC,UAAU,CAAC;AACpD,qCAAsC,UAAU,CAAC;AAGjD,+BAAgC,WAAW,CAAC;AAC5C,sCAAiD"}

package/types/common/isomorphic/colored-logger.browser.d.ts

@@ -0,0 +1,8 @@
+declare namespace _default {
+    function title(msg: any): void;
+    function log(msg: any): void;
+    function warn(msg: any): void;
+    function error(msg: any): void;
+}
+export default _default;
+//# sourceMappingURL=colored-logger.browser.d.ts.map

package/types/common/isomorphic/colored-logger.browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colored-logger.browser.d.ts","sourceRoot":"","sources":["../../../src/common/isomorphic/colored-logger.browser.js"],"names":[],"mappings":";IAIE,+BAEC;IACD,6BAEC;IACD,8BAEC;IACD,+BAEC"}

package/types/common/isomorphic/colored-logger.node.d.ts

@@ -0,0 +1,8 @@
+declare namespace _default {
+    function title(msg: any): void;
+    function log(msg: any): void;
+    function warn(msg: any): void;
+    function error(msg: any): void;
+}
+export default _default;
+//# sourceMappingURL=colored-logger.node.d.ts.map

package/types/common/isomorphic/colored-logger.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colored-logger.node.d.ts","sourceRoot":"","sources":["../../../src/common/isomorphic/colored-logger.node.js"],"names":[],"mappings":";IAME,+BAEC;IACD,6BAEC;IACD,8BAEC;IACD,+BAEC"}

package/types/common/isomorphic/web-socket.browser.d.ts

@@ -0,0 +1,10 @@
+declare const _default: {
+    new (url: string | URL, protocols?: string | string[]): WebSocket;
+    prototype: WebSocket;
+    readonly CONNECTING: 0;
+    readonly OPEN: 1;
+    readonly CLOSING: 2;
+    readonly CLOSED: 3;
+};
+export default _default;
+//# sourceMappingURL=web-socket.browser.d.ts.map

package/types/common/isomorphic/web-socket.browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-socket.browser.d.ts","sourceRoot":"","sources":["../../../src/common/isomorphic/web-socket.browser.js"],"names":[],"mappings":""}

package/types/common/isomorphic/web-socket.node.d.ts

@@ -0,0 +1,2 @@
+export default WebSocket;
+//# sourceMappingURL=web-socket.node.d.ts.map

package/types/common/isomorphic/web-socket.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-socket.node.d.ts","sourceRoot":"","sources":["../../../src/common/isomorphic/web-socket.node.js"],"names":[],"mappings":""}

package/types/common/logs/gated-logger.d.ts

@@ -0,0 +1,9 @@
+declare namespace _default {
+    let verbose: boolean;
+    function title(msg: any): void;
+    function log(msg: any): void;
+    function warn(msg: any): void;
+    function error(msg: any): void;
+}
+export default _default;
+//# sourceMappingURL=gated-logger.d.ts.map

package/types/common/logs/gated-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gated-logger.d.ts","sourceRoot":"","sources":["../../../src/common/logs/gated-logger.js"],"names":[],"mappings":";;IASE,+BAIC;IACD,6BAIC;IACD,8BAIC;IACD,+BAIC"}