@soundworks/core 4.0.0-alpha.2 → 4.0.0-alpha.3

package/.eslintrc

@@ -1,7 +1,6 @@
 {
   "extends": [
     "@ircam",
-    "plugin:jsdoc/recommended"
   ],
   "settings": {
     "jsdoc": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soundworks/core",
-  "version": "4.0.0-alpha.2",
+  "version": "4.0.0-alpha.3",
   "description": "Open-source creative coding framework for distributed applications based on Web technologies",
   "authors": [
     "Benjamin Matuszewski",

package/src/common/ParameterBag.js

@@ -17,7 +17,7 @@ export const types = {
     },
     coerceFunction: (name, def, value) => {
       if (typeof value !== 'boolean') {
-        throw new TypeError(`[stateManager] Invalid value for boolean param "${name}": ${value}`);
+        throw new TypeError(`[SharedState] Invalid value for boolean param "${name}": ${value}`);
       }
 
       return value;
@@ -30,7 +30,7 @@ export const types = {
     },
     coerceFunction: (name, def, value) => {
       if (typeof value !== 'string') {
-        throw new TypeError(`[stateManager] Invalid value for string param "${name}": ${value}`);
+        throw new TypeError(`[SharedState] Invalid value for string param "${name}": ${value}`);
       }
 
       return value;
@@ -63,7 +63,7 @@ export const types = {
     },
     coerceFunction: (name, def, value) => {
       if (!(typeof value === 'number' && Math.floor(value) === value)) {
-        throw new TypeError(`[stateManager] Invalid value for integer param "${name}": ${value}`);
+        throw new TypeError(`[SharedState] Invalid value for integer param "${name}": ${value}`);
       }
 
       return Math.max(def.min, Math.min(def.max, value));
@@ -96,7 +96,7 @@ export const types = {
     },
     coerceFunction: (name, def, value) => {
       if (typeof value !== 'number' || value !== value) { // reject NaN
-        throw new TypeError(`[stateManager] Invalid value for float param "${name}": ${value}`);
+        throw new TypeError(`[SharedState] Invalid value for float param "${name}": ${value}`);
       }
 
       return Math.max(def.min, Math.min(def.max, value));
@@ -109,7 +109,7 @@ export const types = {
     },
     coerceFunction: (name, def, value) => {
       if (def.list.indexOf(value) === -1) {
-        throw new TypeError(`[stateManager] Invalid value for enum param "${name}": ${value}`);
+        throw new TypeError(`[SharedState] Invalid value for enum param "${name}": ${value}`);
       }
 
 
@@ -139,11 +139,11 @@ class ParameterBag {
       const def = schema[name];
 
       if (!Object.prototype.hasOwnProperty.call(def, 'type')) {
-        throw new TypeError(`[stateManager] Invalid schema definition - param "${name}": "type" key is required`);
+        throw new TypeError(`[StateManager.registerSchema] Invalid schema definition - param "${name}": "type" key is required`);
       }
 
       if (!Object.prototype.hasOwnProperty.call(types, def.type)) {
-        throw new TypeError(`[stateManager] Invalid schema definition - param "${name}": "{ type: '${def.type}' }" does not exists`);
+        throw new TypeError(`[StateManager.registerSchema] Invalid schema definition - param "${name}": "{ type: '${def.type}' }" does not exists`);
       }
 
       const required = types[def.type].required;
@@ -152,7 +152,7 @@ class ParameterBag {
         if (def.event === true && key === 'default') {
           // do nothing, default is always null for `event` params
         } else if (!Object.prototype.hasOwnProperty.call(def, key)) {
-          throw new TypeError(`[stateManager] Invalid schema definition - param "${name}" (type "${def.type}"): "${key}" key is required`);
+          throw new TypeError(`[StateManager.registerSchema] Invalid schema definition - param "${name}" (type "${def.type}"): "${key}" key is required`);
         }
       });
     }
@@ -160,7 +160,7 @@ class ParameterBag {
 
   constructor(schema, initValues = {}) {
     if (!schema) {
-      throw new Error(`[stateManager] schema is mandatory`);
+      throw new Error(`[ParameterBag] schema is mandatory`);
     }
 
     schema = cloneDeep(schema);
@@ -193,7 +193,7 @@ class ParameterBag {
     // make shure initValues make sens according to the given schema
     for (let name in initValues) {
       if (!Object.prototype.hasOwnProperty.call(schema, name)) {
-        throw new ReferenceError(`[stateManager] init value defined for undefined param "${name}"`);
+        throw new ReferenceError(`[StateManager.create] init value defined for undefined param "${name}"`);
       }
     }
 
@@ -264,10 +264,12 @@ class ParameterBag {
    */
   get(name) {
     if (!this.has(name)) {
-      throw new ReferenceError(`[stateManager] Cannot get value of undefined parameter "${name}"`);
+      throw new ReferenceError(`[SharedState] Cannot get value of undefined parameter "${name}"`);
     }
 
     if (this._schema[name].type === 'any') {
+      // we return a deep copy of the object as we don't want the client code to
+      // be able to modify our underlying data.
       return cloneDeep(this._values[name]);
     } else {
       return this._values[name];
@@ -287,14 +289,14 @@ class ParameterBag {
    */
   set(name, value) {
     if (!this.has(name)) {
-      throw new ReferenceError(`[stateManager] Cannot set value of undefined parameter "${name}"`);
+      throw new ReferenceError(`[SharedState] Cannot set value of undefined parameter "${name}"`);
     }
 
     const def = this._schema[name];
     const { coerceFunction } = types[def.type];
 
     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`);
+      throw new TypeError(`[SharedState] Invalid value for ${def.type} param "${name}": value is null and param is not nullable`);
     } else if (value === null && def.nullable === true) {
       value = null;
     } else {
@@ -304,6 +306,16 @@ class ParameterBag {
     const currentValue = this._values[name];
     const updated = !equal(currentValue, value);
 
+    // we store a deep copy of the object as we don't want the client to be able
+    // to modify our underlying data, which leads unexpected behavior where the
+    // deep equal check to returns true, and therefore the update is not triggered.
+    //
+    // @see tests/common.state-manager.spec.js
+    // 'should copy stored value for "any" type to have a predictable behavior'
+    if (this._schema[name].type === 'any') {
+      value = cloneDeep(value);
+    }
+
     this._values[name] = value;
 
     // return tuple so that the state manager can handle the `filterChange` option
@@ -337,7 +349,7 @@ class ParameterBag {
       return this._schema;
     } else {
       if (!this.has(name)) {
-        throw new ReferenceError(`[stateManager] Cannot get schema description of undefined parameter "${name}"`);
+        throw new ReferenceError(`[SharedState] Cannot get schema description of undefined parameter "${name}"`);
       }
 
       return this._schema[name];

package/src/common/utils.js

@@ -1,3 +1,5 @@
+import isPlainObj from 'is-plain-obj';
+
 // https://stackoverflow.com/questions/17575790/environment-detection-node-js-or-browser
 export const isBrowser = new Function('try {return this===window;}catch(e){ return false;}');
 
@@ -20,3 +22,7 @@ export function isFunction(func) {
     Object.prototype.toString.call(func) == '[object AsyncFunction]';
 }
 
+export function isPlainObject(obj) {
+  return isPlainObj(obj);
+}
+

package/src/server/Server.js

@@ -648,6 +648,10 @@ Invalid certificate files, please check your:
 
         await this._dispatchStatus('started');
 
+        if (this.config.env.type === 'development') {
+          logger.log(`\n> press "${chalk.bold('Ctrl + C')}" to exit`);
+        }
+
         resolve();
       });
     });

package/src/server/StateManager.js

@@ -5,6 +5,7 @@ import clonedeep from 'lodash.clonedeep';
 import BaseStateManager from '../common/BaseStateManager.js';
 import ParameterBag from '../common/ParameterBag.js';
 import SharedStatePrivate from '../common/SharedStatePrivate.js';
+import { isString, isPlainObject } from '../common/utils.js';
 import {
   SERVER_ID,
   CREATE_REQUEST,
@@ -514,10 +515,18 @@ class StateManager extends BaseStateManager {
    * })
    */
   registerSchema(schemaName, schema) {
+    if (!isString(schemaName)) {
+      throw new Error(`[stateManager.registerSchema] Invalid schema name "${schemaName}", should be a string`);
+    }
+
     if (this._schemas.has(schemaName)) {
       throw new Error(`[stateManager.registerSchema] cannot register schema with name: "${schemaName}", schema name already exists`);
     }
 
+    if (!isPlainObject(schema)) {
+      throw new Error(`[stateManager.registerSchema] Invalid schema, should be an object`);
+    }
+
     ParameterBag.validateSchema(schema);
 
     this._schemas.set(schemaName, clonedeep(schema));