@soundworks/core 3.5.1 → 3.7.0

package/client/AbstractPlugin.js

@@ -93,7 +93,7 @@ class AbstractPlugin {
 
     }; // start when all required signals are fired
 
-    this.signals.start.addObserver(value => this.start());
+    this.signals.start.addObserver(() => this.start());
     this.started = this.started.bind(this);
     this.ready = this.ready.bind(this);
     this.error = this.error.bind(this);

package/client/Client.js

@@ -137,14 +137,9 @@ class Client {
 
   async start() {
     this._ready = new Promise((resolve, reject) => {
-      const payload = {};
-
-      if (this.config.env !== 'production') {
-        Object.assign(payload, {
-          requiredPlugins: Object.keys(this.pluginManager.getValues())
-        });
-      } // wait for handshake response to mark client as `ready`
-
+      const payload = {
+        requiredPlugins: this.pluginManager.getRequiredPlugins()
+      }; // wait for handshake response to mark client as `ready`
 
       this.socket.addListener('s:client:start', ({
         id,
@@ -164,15 +159,24 @@ class Client {
         this.pluginManager.start().then(() => resolve());
       });
       this.socket.addListener('s:client:error', err => {
+        let msg = ``;
+
         switch (err.type) {
           case 'plugins':
-            // can only append if env !== 'production'
-            const msg = `"${err.data.join(', ')}" required client-side but not server-side`;
-            throw new Error(msg);
+            msg = `"${err.data.join(', ')}" required client-side but not server-side`;
+            break;
+
+          case 'no-activity':
+            msg = `[soundworks:core] No activity registered server-side for "${this.type}", make sure an Experience has been created for this client`;
+            break;
+
+          default:
+            msg = `Unknown error`;
             break;
         }
 
-        reject();
+        this.socket.terminate();
+        reject(msg);
       });
       this.socket.send('s:client:handshake', payload);
     });
@@ -185,6 +189,5 @@ class Client {
 
 }
 
-;
 var _default = Client;
 exports.default = _default;

package/client/PluginManager.js

@@ -45,7 +45,7 @@ class PluginManager {
     this._observers = new Set();
     /** @private */
 
-    this._pluginsStatus = {};
+    this._pluginsStatuses = {};
     /** @private */
 
     this._client = client;
@@ -54,7 +54,7 @@ class PluginManager {
       start: new _Signal.default(),
       ready: new _SignalAll.default()
     };
-    this.ready = new Promise((resolve, reject) => {
+    this.ready = new Promise(resolve => {
       this._resolveReadyPromise = resolve;
     });
   }
@@ -70,7 +70,10 @@ class PluginManager {
       log('> pluginManager ready');
 
       this._resolveReadyPromise();
-    }); // start before ready, even if no deps
+    });
+
+    this._propagateStatusChange(); // start before ready, even if no deps
+
 
     this.signals.start.value = true;
 
@@ -79,17 +82,23 @@ class PluginManager {
     }
 
     return this.ready;
-  } // ------------------
-  // @unstable
-  // mimic state manager API, so we can change this later...
-
+  }
   /** @private */
 
 
-  _emitChange() {
-    const status = this.getValues();
+  _propagateStatusChange(name = null, status = null) {
+    if (name != null && status != null) {
+      this._pluginsStatuses[name] = status;
+      const statuses = this.getStatuses();
+
+      this._observers.forEach(observer => observer(statuses, {
+        [name]: status
+      }));
+    } else {
+      const statuses = this.getStatuses();
 
-    this._observers.forEach(observer => observer(status));
+      this._observers.forEach(observer => observer(statuses, {}));
+    }
   }
   /** @private */
 
@@ -102,15 +111,12 @@ class PluginManager {
     };
   }
   /** @private */
+  // @todo rename to `getStatuses`
 
 
-  getValues() {
-    return Object.assign({}, this._pluginsStatus);
-  } // end @unstable
-  // ------------------
-
-  /** @private */
-
+  getStatuses() {
+    return Object.assign({}, this._pluginsStatuses);
+  }
   /**
    * Register the client-side part of a plugin into soundworks instance.
    *
@@ -200,30 +206,33 @@ ${Object.keys(this._registeredPlugins).map(n => `> - ${n}\n`).join('')}
       } // handle plugin status for reporting
 
 
-      this._pluginsStatus[name] = 'idle';
+      this._pluginsStatuses[name] = 'idle';
       let unsubscribe;
 
       const onPluginStarted = () => {
-        this._pluginsStatus[name] = 'started';
+        this._pluginsStatuses[name] = 'started';
         /**
-         * @fixme - relying on `instance.state` is very weak...
+         * @FIXME
+         * relying on `instance.state` is very weak...
          * we should find a better solution, to declare that we want the
          * pluginManager to watch and propagate initialization steps.
+         *
+         * This is probably a dirty hack to make the init views working...
          */
 
         if (instance.state) {
           unsubscribe = instance.state.subscribe(() => {
-            this._emitChange();
+            this._propagateStatusChange();
           });
         }
 
-        this._emitChange();
+        this._propagateStatusChange();
       };
 
       const onPluginErrored = () => {
-        this._pluginsStatus[name] = 'errored';
+        this._pluginsStatuses[name] = 'errored';
 
-        this._emitChange();
+        this._propagateStatusChange();
 
         if (unsubscribe) {
           unsubscribe();
@@ -235,9 +244,9 @@ ${Object.keys(this._registeredPlugins).map(n => `> - ${n}\n`).join('')}
       };
 
       const onPluginReady = () => {
-        this._pluginsStatus[name] = 'ready';
+        this._pluginsStatuses[name] = 'ready';
 
-        this._emitChange();
+        this._propagateStatusChange();
 
         if (unsubscribe) {
           unsubscribe();
@@ -260,8 +269,11 @@ ${Object.keys(this._registeredPlugins).map(n => `> - ${n}\n`).join('')}
     return instance;
   }
 
+  getRequiredPlugins() {
+    return Object.keys(this._pluginsStatuses);
+  }
+
 }
 
-;
 var _default = PluginManager;
 exports.default = _default;

package/client/Socket.js

@@ -11,11 +11,13 @@ var _isomorphicWs = _interopRequireDefault(require("isomorphic-ws"));
 
 var _socketsEncoderDecoder = require("../common/sockets-encoder-decoder.js");
 
+var _logger = _interopRequireDefault(require("../common/logger.js"));
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 const log = (0, _debug.default)('soundworks:socket'); // https://stackoverflow.com/questions/17575790/environment-detection-node-js-or-browser
 
-const isBrowser = new Function("try {return this===window;}catch(e){ return false;}"); // close
+const isBrowser = new Function('try {return this===window;}catch(e){ return false;}'); // close
 //   Fired when a connection with a websocket is closed.
 //   Also available via the onclose property
 // error
@@ -118,7 +120,7 @@ class Socket {
     // ----------------------------------------------------------
 
     const stringSocketUrl = `${url}?binary=0&${queryParams}`;
-    await new Promise((resolve, reject) => {
+    await new Promise(resolve => {
       let connectionRefusedLogged = false;
 
       const trySocket = async () => {
@@ -148,22 +150,29 @@ class Socket {
         ws.addEventListener('error', e => {
           if (e.type === 'error' && e.error.code === 'ECONNREFUSED') {
             if (!connectionRefusedLogged) {
-              console.log('[socket] connection refused, waiting for the server to start');
+              _logger.default.log('[socket] connection refused, waiting for the server to start');
+
               connectionRefusedLogged = true;
             }
 
+            if (ws.terminate) {
+              ws.terminate();
+            } else {
+              ws.close();
+            }
+
             setTimeout(trySocket, 1000);
           }
         });
       };
 
       trySocket();
-    }); // // ----------------------------------------------------------
-    // // init binary socket
-    // // ----------------------------------------------------------
+    }); // ----------------------------------------------------------
+    // init binary socket
+    // ----------------------------------------------------------
 
     const binarySocketUrl = `${url}?binary=1&${queryParams}`;
-    await new Promise((resolve, reject) => {
+    await new Promise(resolve => {
       log(`[binary socket] trying connection - url: ${binarySocketUrl}`);
       const ws = new _isomorphicWs.default(binarySocketUrl, webSocketOptions);
       ws.binaryType = 'arraybuffer';
@@ -186,7 +195,7 @@ class Socket {
 
         resolve();
       });
-    }); // everyone is connected
+    }); // wait for both sockets connected
 
     return Promise.resolve();
   }
@@ -333,6 +342,5 @@ class Socket {
 
 }
 
-;
 var _default = Socket;
 exports.default = _default;

package/common/ParameterBag.js

@@ -359,18 +359,18 @@ class ParameterBag {
     for (let name in schema) {
       const def = schema[name];
 
-      if (!def.hasOwnProperty('type')) {
+      if (!Object.prototype.hasOwnProperty.call(def, 'type')) {
         throw new TypeError(`[stateManager] Invalid schema definition - param "${name}": "type" key is required`);
       }
 
-      if (!types.hasOwnProperty(def.type)) {
+      if (!Object.prototype.hasOwnProperty.call(types, def.type)) {
         throw new TypeError(`[stateManager] Invalid schema definition - param "${name}": "{ type: '${def.type}' }" does not exists`);
       }
 
       const required = types[def.type].required;
-      required.forEach(function (key) {
+      required.forEach(key => {
         if (def.event === true && key === 'default') {// do nothing, default is always null for `event` params
-        } else if (!def.hasOwnProperty(key)) {
+        } else if (!Object.prototype.hasOwnProperty.call(def, key)) {
           throw new TypeError(`[stateManager] Invalid schema definition - param "${name}" (type "${def.type}"): "${key}" key is required`);
         }
       });
@@ -409,21 +409,19 @@ class ParameterBag {
     ParameterBag.validateSchema(schema); // make shure initValues make sens according to the given schema
 
     for (let name in initValues) {
-      if (!schema.hasOwnProperty(name)) {
+      if (!Object.prototype.hasOwnProperty.call(schema, name)) {
         throw new ReferenceError(`[stateManager] init value defined for undefined param "${name}"`);
       }
     }
 
     for (let [name, def] of Object.entries(schema)) {
-      const {
-        defaultOptions,
-        coerceFunction
-      } = types[def.type];
-
       if (types[def.type].sanitizeSchema) {
         def = types[def.type].sanitizeSchema(def);
       }
 
+      const {
+        defaultOptions
+      } = types[def.type];
       def = Object.assign({}, defaultOptions, def); // if event property is set to true, the param must
       // be nullable and its default value is `undefined`
 
@@ -434,7 +432,7 @@ class ParameterBag {
 
       let initValue;
 
-      if (initValues.hasOwnProperty(name)) {
+      if (Object.prototype.hasOwnProperty.call(initValues, name)) {
         initValue = initValues[name];
       } else {
         initValue = def.default;
@@ -456,7 +454,7 @@ class ParameterBag {
 
 
   has(name) {
-    return this._schema.hasOwnProperty(name);
+    return Object.prototype.hasOwnProperty.call(this._schema, name);
   }
   /**
    * Return values of all parameters as a flat object.
@@ -520,7 +518,7 @@ class ParameterBag {
     if (value === null && def.nullable === false) {
       throw new TypeError(`[stateManager] Invalid value for ${def.type} param "${name}": value is null and param is not nullable`);
     } else if (value === null && def.nullable === true) {
-      value = value;
+      value = null;
     } else {
       value = coerceFunction(name, def, value);
     }

package/common/SharedState.js

@@ -11,18 +11,20 @@ var _sharedStateUtils = require("./shared-state-utils.js");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-// -----------------------------------------------------------
-// define a common namespace...
-// -----------------------------------------------------------
+/**
+ * Representation of a shared state.
+ *
+ * @memberof server
+ *
+ * @see {server.SharedStateManagerServer}
+ */
 
 /**
- * Representation of a shared state. The class and its instances are the same
- * client-side and server-side.
+ * Representation of a shared state.
  *
- * @memberof common
+ * @memberof client
  *
  * @see {client.SharedStateManagerClient}
- * @see {server.SharedStateManagerServer}
  */
 class SharedState {
   constructor(id, remoteId, schemaName, schema, client, isOwner, manager, initValues = {}) {
@@ -46,23 +48,47 @@ ${JSON.stringify(initValues, null, 2)}`);
     this._onDetachCallbacks = new Set();
     this._onDeleteCallbacks = new Set(); // add listener for state updates
 
-    client.transport.addListener(`${_sharedStateUtils.UPDATE_RESPONSE}-${id}-${this.remoteId}`, async (reqId, updates, context) => {
+    this._client.transport.addListener(`${_sharedStateUtils.UPDATE_RESPONSE}-${this.id}-${this.remoteId}`, async (reqId, updates, context) => {
       const updated = await this._commit(updates, context, true, true);
       (0, _sharedStateUtils.resolveRequest)(reqId, updated);
     }); // retrieve values but do not propagate to subscriptions
 
-    client.transport.addListener(`${_sharedStateUtils.UPDATE_ABORT}-${id}-${this.remoteId}`, async (reqId, updates, context) => {
+
+    this._client.transport.addListener(`${_sharedStateUtils.UPDATE_ABORT}-${this.id}-${this.remoteId}`, async (reqId, updates, context) => {
       const updated = await this._commit(updates, context, false, true);
       (0, _sharedStateUtils.resolveRequest)(reqId, updated);
     });
-    client.transport.addListener(`${_sharedStateUtils.UPDATE_NOTIFICATION}-${id}-${this.remoteId}`, async (updates, context) => {
-      // cf. https://github.com/collective-soundworks/soundworks/issues/18
-      await this._commit(updates, context, true, false);
+
+    this._client.transport.addListener(`${_sharedStateUtils.UPDATE_NOTIFICATION}-${this.id}-${this.remoteId}`, async (updates, context) => {
+      // https://github.com/collective-soundworks/soundworks/issues/18
+      //
+      // # note: 2002-10-03
+      //
+      // `setTimeout(async () => this._commit(updates, context, true, false));`
+      // appears to be the only way to push the update commit in the next event
+      // cycle so that `attach` can resolve before the update notification is
+      // actually dispatched. The alternative:
+      // `Promise.resolve().then(() => this._commit(updates, context, true, false))``
+      // does not behave as expected...
+      //
+      // However this breaks the reliability of:
+      // ```
+      // /* given a0, a1 and a2 being 3 similar attached states */
+      // await state.set({ int: i });
+      //
+      // assert.equal(a0.get('int'), i);
+      // assert.equal(a1.get('int'), i);
+      // assert.equal(a2.get('int'), i);
+      // ```
+      // which is far more important than the edge case reported in the issue
+      // therefore this wont be fixed for now
+      this._commit(updates, context, true, false);
     }); // ---------------------------------------------
     // DELETE initiated by creator, or schema deleted
     // ---------------------------------------------
 
-    client.transport.addListener(`${_sharedStateUtils.DELETE_NOTIFICATION}-${id}-${this.remoteId}`, () => {
+
+    this._client.transport.addListener(`${_sharedStateUtils.DELETE_NOTIFICATION}-${this.id}-${this.remoteId}`, () => {
       this._manager._statesById.delete(this.id);
 
       this._clearTransport();
@@ -78,7 +104,7 @@ ${JSON.stringify(initValues, null, 2)}`);
       // ---------------------------------------------
       // DELETE (can only delete if creator)
       // ---------------------------------------------
-      client.transport.addListener(`${_sharedStateUtils.DELETE_RESPONSE}-${id}-${this.remoteId}`, reqId => {
+      this._client.transport.addListener(`${_sharedStateUtils.DELETE_RESPONSE}-${this.id}-${this.remoteId}`, reqId => {
         this._manager._statesById.delete(this.id);
 
         this._clearTransport();
@@ -91,14 +117,15 @@ ${JSON.stringify(initValues, null, 2)}`);
 
         (0, _sharedStateUtils.resolveRequest)(reqId, this);
       });
-      client.transport.addListener(`${_sharedStateUtils.DELETE_ERROR}-${id}`, (reqId, msg) => {
+
+      this._client.transport.addListener(`${_sharedStateUtils.DELETE_ERROR}-${this.id}`, (reqId, msg) => {
         (0, _sharedStateUtils.rejectRequest)(reqId, msg);
       });
     } else {
       // ---------------------------------------------
       // DETACH
       // ---------------------------------------------
-      client.transport.addListener(`${_sharedStateUtils.DETACH_RESPONSE}-${id}-${this.remoteId}`, reqId => {
+      this._client.transport.addListener(`${_sharedStateUtils.DETACH_RESPONSE}-${this.id}-${this.remoteId}`, reqId => {
         this._manager._statesById.delete(this.id);
 
         this._clearTransport();
@@ -110,7 +137,8 @@ ${JSON.stringify(initValues, null, 2)}`);
         (0, _sharedStateUtils.resolveRequest)(reqId, this);
       }); // the state does not exists anymore in the server (should not happen)
 
-      client.transport.addListener(`${_sharedStateUtils.DETACH_ERROR}-${id}`, (reqId, msg) => {
+
+      this._client.transport.addListener(`${_sharedStateUtils.DETACH_ERROR}-${this.id}`, (reqId, msg) => {
         (0, _sharedStateUtils.rejectRequest)(reqId, msg);
       });
     }
@@ -150,7 +178,6 @@ ${JSON.stringify(initValues, null, 2)}`);
     for (let name in updates) {
       const {
         immediate,
-        filterChange,
         event
       } = this._parameters.getSchema(name); // @note 20211209 - we had an issue here server-side, because if the value
       // is an object or an array, the reference is shared by everybody, therefore
@@ -185,7 +212,9 @@ ${JSON.stringify(initValues, null, 2)}`);
       this._subscriptions.forEach(listener => {
         promises.push(listener(newValues, oldValues, context));
       });
-    }
+    } // on a given client, `await state.set(update)` resolves when all
+    // subscription have resolved themselves
+
 
     await Promise.all(promises); // reset events to null after propagation of all listeners
 

package/common/SharedStateManagerServer.js

@@ -190,7 +190,7 @@ class SharedStateManagerServer extends _SharedStateManagerClient.default {
 
 
   removeClient(nodeId) {
-    for (let [id, state] of this._serverStatesById.entries()) {
+    for (let [_id, state] of this._serverStatesById.entries()) {
       let deleteState = false; // define if the client is the creator of the state, in which case
       // everybody must delete it
 
@@ -274,7 +274,7 @@ class SharedStateManagerServer extends _SharedStateManagerClient.default {
 
   deleteSchema(schemaName) {
     // @note: deleting schema
-    for (let [id, state] of this._serverStatesById.entries()) {
+    for (let [_id, state] of this._serverStatesById.entries()) {
       if (state.schemaName === schemaName) {
         for (let [remoteId, attached] of state._attachedClients.entries()) {
           state._detachClient(remoteId, attached);

package/common/SharedStatePrivate.js

@@ -7,8 +7,6 @@ exports.default = void 0;
 
 var _ParameterBag = _interopRequireDefault(require("./ParameterBag.js"));
 
-var _lodash = _interopRequireDefault(require("lodash.clonedeep"));
-
 var _sharedStateUtils = require("./shared-state-utils");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/{server/utils → common}/logger.js

@@ -81,12 +81,16 @@ const logger = {
     }));
     console.log(``); // check if a route is defined but not in config
 
-    const configClientTypes = Object.keys(clientsConfig);
-    routes.forEach(r => {
-      if (configClientTypes.indexOf(r.clientType) === -1) {
-        console.log(`@warning: no client config found for route ${r.clientType}`);
-      }
-    });
+    if (clientsConfig) {
+      const configClientTypes = Object.keys(clientsConfig);
+      routes.forEach(r => {
+        if (configClientTypes.indexOf(r.clientType) === -1) {
+          console.log(`@warning: no client config found for route ${r.clientType}`);
+        }
+      });
+    } else {
+      console.log(`@warning: no config found for clients`);
+    }
   },
 
   ip(protocol, address, port) {
@@ -127,6 +131,30 @@ const logger = {
     }
 
     console.log(`    ${name} ${_chalk.default.red('errors')}`);
+  },
+
+  log(msg) {
+    if (!this.verbose) {
+      return;
+    }
+
+    console.log(msg);
+  },
+
+  warn(msg) {
+    if (!this.verbose) {
+      return;
+    }
+
+    console.warn(_chalk.default.yellow(msg));
+  },
+
+  error(msg) {
+    if (!this.verbose) {
+      return;
+    }
+
+    console.error(_chalk.default.red(msg));
   }
 
 };

package/common/shared-state-utils.js

@@ -82,7 +82,6 @@ function resolveRequest(reqId, data) {
 
 function rejectRequest(reqId, data) {
   const {
-    resolve,
     reject
   } = requestPromises.get(reqId);
   requestPromises.delete(reqId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soundworks/core",
-  "version": "3.5.1",
+  "version": "3.7.0",
   "description": "full-stack javascript framework for distributed audio visual experiences on the web",
   "authors": [
     "Benjamin Matuszewski",
@@ -30,6 +30,7 @@
     "dev:server": "chokidar src/server/ -c \"npm run build:server\"",
     "dev:common": "chokidar src/common/ -c \"npm run build:common\"",
     "dev": "npm run build && (npm run dev:client & npm run dev:server & npm run dev:common)",
+    "lint": "npx eslint src",
     "test": "mocha"
   },
   "dependencies": {
@@ -46,7 +47,6 @@
     "lodash.merge": "^4.6.2",
     "pem": "^1.14.6",
     "polka": "^0.5.2",
-    "serve-static": "^1.15.0",
     "uuid": "^8.3.2",
     "window-or-global": "^1.0.1",
     "ws": "^8.5.0"
@@ -55,17 +55,28 @@
     "@babel/cli": "^7.17.6",
     "@babel/core": "^7.17.9",
     "@babel/preset-env": "^7.16.11",
+    "@soundworks/plugin-delay": "^1.0.0",
     "chai": "^4.3.6",
+    "chai-shallow-deep-equal": "^1.4.6",
     "chokidar": "^3.5.3",
     "chokidar-cli": "^3.0.0",
+    "commitizen": "^4.2.5",
+    "cz-conventional-changelog": "^3.3.0",
     "docdash": "^1.2.0",
+    "dotenv": "^16.0.3",
+    "eslint": "^8.24.0",
     "jsdoc": "^3.6.10",
     "markdown-toc": "^1.2.0",
     "mocha": "^9.2.2",
-    "serial-mocha": "^0.0.4"
+    "puppeteer": "^18.0.5"
   },
   "optionalDependencies": {
     "bufferutil": "^4.0.5",
     "utf-8-validate": "^5.0.7"
+  },
+  "config": {
+    "commitizen": {
+      "path": "./node_modules/cz-conventional-changelog"
+    }
   }
 }

package/server/AbstractExperience.js

@@ -83,7 +83,7 @@ class AbstractExperience {
     // sent when the client `enters` the Experience client side, i.e. when all
     // required plugins are ready
 
-    return new Promise((resolve, reject) => {
+    return new Promise(() => {
       client.socket.addListener('s:exp:enter', () => {
         this.clients.add(client);
         this.enter(client);