@soundworks/core 3.7.0 → 4.0.0-alpha.1

package/client/Socket.js

@@ -1,346 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _debug = _interopRequireDefault(require("debug"));
-
-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
-//   Fired when a connection with a websocket is closed.
-//   Also available via the onclose property
-// error
-//   Fired when a connection with a websocket has been closed because of an error, such as whensome data couldn't be sent.
-//   Also available via the onerror property.
-// message
-//   Fired when data is received through a websocket.
-//   Also available via the onmessage property.
-// open
-//   Fired when a connection with a websocket is opened.
-//   Also available via the onopen property.
-// @todo - use isomorphic ws ? (does seems like a perfect idea)
-
-/**
- * Simple wrapper with simple pubsub system built on top of `ws` socket.
- * The abstraction actually open two different sockets:
- * - one configured for string (JSON compatible) messages
- * - one configured with `binaryType=arraybuffer` for streaming data more
- *   efficiently.
- * The sockets also re-emits all "native" ws events.
- *
- * An instance of `Socket` is automatically created by the `soundworks.Client`.
- * @see {@link client.Client#socket}
- *
- * @see https://github.com/websockets/ws
- *
- * @memberof client
- */
-
-class Socket {
-  constructor() {
-    /**
-     * WebSocket instance (string protocol - binaryType = 'string').
-     */
-
-    /** @private */
-    this.ws = null;
-    /**
-     * WebSocket instance (binary protocol - binaryType = 'arraybuffer').
-     */
-
-    /** @private */
-
-    this.binaryWs = null;
-    this._stringListeners = new Map();
-    this._binaryListeners = new Map();
-  }
-  /**
-   * Initialize a websocket connection with the server. This is automatically
-   * called in `client.init()`
-   * @param {String} clientType - `client.type` {@link client}
-   * @param {Object} options - Options of the socket
-   * @param {Array<String>} options.path - Defines where socket should find the `socket.io` file
-   */
-
-  /** @private */
-
-
-  async init(clientType, config) {
-    // unique key that allows to associate the two sockets to the same client.
-    // note: the key is only used to pair to two sockets, so its usage is very
-    // limited in time therefore a random number should hopefully be sufficient.
-    const key = (Math.random() + '').replace(/^0\./, ''); // open web sockets
-
-    let {
-      path
-    } = config.env.websockets; // @note: keep this check
-    // backward compatibility w/ assetsDomain and websocket old config way
-    // cf. https://github.com/collective-soundworks/soundworks/issues/35
-
-    if (config.env.subpath) {
-      path = `${config.env.subpath}/${path}`;
-    }
-
-    let url;
-    let webSocketOptions;
-
-    if (isBrowser()) {
-      const protocol = window.location.protocol.replace(/^http?/, 'ws');
-      const {
-        hostname,
-        port
-      } = window.location;
-      url = `${protocol}//${hostname}:${port}/${path}`;
-      webSocketOptions = [];
-    } else {
-      const protocol = config.env.useHttps ? 'wss:' : 'ws:';
-      const {
-        serverIp,
-        port
-      } = config.env;
-      url = `${protocol}//${serverIp}:${port}/${path}`;
-      webSocketOptions = {
-        rejectUnauthorized: false
-      };
-    }
-
-    const queryParams = `clientType=${clientType}&key=${key}`; // ----------------------------------------------------------
-    // init string socket
-    // ----------------------------------------------------------
-
-    const stringSocketUrl = `${url}?binary=0&${queryParams}`;
-    await new Promise(resolve => {
-      let connectionRefusedLogged = false;
-
-      const trySocket = async () => {
-        log(`[string socket] trying connection - url: ${stringSocketUrl}`);
-        const ws = new _isomorphicWs.default(stringSocketUrl, webSocketOptions);
-        ws.addEventListener('open', connectEvent => {
-          // parse incoming messages for pubsub
-          this.ws = ws;
-          this.ws.addEventListener('message', e => {
-            const [channel, args] = (0, _socketsEncoderDecoder.unpackStringMessage)(e.data);
-
-            this._emit(false, channel, ...args);
-          }); // broadcast all `WebSocket` native events
-
-          ['close', 'error', 'upgrade', 'message'].forEach(eventName => {
-            this.ws.addEventListener(eventName, e => {
-              this._emit(false, eventName, e);
-            });
-          }); // forward open event
-
-          this._emit(false, 'open', connectEvent); // continue with raw socket
-
-
-          resolve();
-        }); // cf. https://github.com/collective-soundworks/soundworks/issues/17
-
-        ws.addEventListener('error', e => {
-          if (e.type === 'error' && e.error.code === 'ECONNREFUSED') {
-            if (!connectionRefusedLogged) {
-              _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
-    // ----------------------------------------------------------
-
-    const binarySocketUrl = `${url}?binary=1&${queryParams}`;
-    await new Promise(resolve => {
-      log(`[binary socket] trying connection - url: ${binarySocketUrl}`);
-      const ws = new _isomorphicWs.default(binarySocketUrl, webSocketOptions);
-      ws.binaryType = 'arraybuffer';
-      ws.addEventListener('open', connectEvent => {
-        // parse incoming messages for pubsub
-        this.binaryWs = ws;
-        this.binaryWs.addEventListener('message', e => {
-          const [channel, data] = (0, _socketsEncoderDecoder.unpackBinaryMessage)(e.data);
-
-          this._emit(true, channel, data);
-        }); // broadcast all `WebSocket` native events
-
-        ['close', 'error', 'upgrade', 'message'].forEach(eventName => {
-          this.binaryWs.addEventListener(eventName, e => {
-            this._emit(true, eventName, e);
-          });
-        }); // forward open event
-
-        this._emit(true, 'open', connectEvent);
-
-        resolve();
-      });
-    }); // wait for both sockets connected
-
-    return Promise.resolve();
-  }
-  /** @private */
-
-
-  _emit(binary, channel, ...args) {
-    const listeners = binary ? this._binaryListeners : this._stringListeners;
-
-    if (listeners.has(channel)) {
-      const callbacks = listeners.get(channel);
-      callbacks.forEach(callback => callback(...args));
-    }
-  }
-  /** @private */
-
-
-  _addListener(listeners, channel, callback) {
-    if (!listeners.has(channel)) {
-      listeners.set(channel, new Set());
-    }
-
-    const callbacks = listeners.get(channel);
-    callbacks.add(callback);
-  }
-  /** @private */
-
-
-  _removeListener(listeners, channel, callback) {
-    if (listeners.has(channel)) {
-      const callbacks = listeners.get(channel);
-      callbacks.delete(callback);
-
-      if (callbacks.size === 0) {
-        listeners.delete(channel);
-      }
-    }
-  }
-  /** @private */
-
-
-  _removeAllListeners(listeners, channel) {
-    if (listeners.has(channel)) {
-      listeners.delete(channel);
-    }
-  }
-  /**
-   * Send JSON compatible messages on a given channel
-   *
-   * @param {String} channel - The channel of the message
-   * @param {...*} args - Arguments of the message (as many as needed, of any type)
-   */
-
-
-  send(channel, ...args) {
-    const msg = (0, _socketsEncoderDecoder.packStringMessage)(channel, ...args);
-    this.ws.send(msg);
-  }
-  /**
-   * Listen JSON compatible messages on a given channel
-   *
-   * @param {String} channel - Channel of the message
-   * @param {Function} callback - Callback to execute when a message is received
-   */
-
-
-  addListener(channel, callback) {
-    this._addListener(this._stringListeners, channel, callback);
-  }
-  /**
-   * Remove a listener from JSON compatible messages on a given channel
-   *
-   * @param {String} channel - Channel of the message
-   * @param {Function} callback - Callback to remove
-   */
-
-
-  removeListener(channel, callback) {
-    this._removeListener(this._stringListeners, channel, callback);
-  }
-  /**
-   * Remove all listeners from JSON compatible messages on a given channel
-   *
-   * @param {String} channel - Channel of the message
-   */
-
-
-  removeAllListeners(channel) {
-    this._removeAllListeners(this._stringListeners, channel);
-  }
-  /**
-   * Send binary messages on a given channel
-   *
-   * @param {String} channel - Channel of the message
-   * @param {TypedArray} typedArray - Data to send
-   */
-
-
-  sendBinary(channel, typedArray) {
-    const msg = (0, _socketsEncoderDecoder.packBinaryMessage)(channel, typedArray);
-    this.binaryWs.send(msg);
-  }
-  /**
-   * Listen binary messages on a given channel
-   *
-   * @param {String} channel - Channel of the message
-   * @param {Function} callback - Callback to execute when a message is received
-   */
-
-
-  addBinaryListener(channel, callback) {
-    this._addListener(this._binaryListeners, channel, callback);
-  }
-  /**
-   * Remove a listener from binary compatible messages on a given channel
-   *
-   * @param {String} channel - Channel of the message
-   * @param {Function} callback - Callback to cancel
-   */
-
-
-  removeBinaryListener(channel, callback) {
-    this._removeListener(this._binaryListeners, channel, callback);
-  }
-  /**
-   * Remove all listeners from binary compatible messages on a given channel
-   *
-   * @param {String} channel - Channel of the message
-   */
-
-
-  removeAllBinaryListeners(channel) {
-    this._removeAllListeners(this._binaryListeners, channel);
-  }
-  /**
-   * Immediately close the 2 sockets
-   */
-
-
-  terminate() {
-    this.ws.close();
-    this.binaryWs.close();
-  }
-
-}
-
-var _default = Socket;
-exports.default = _default;

package/client/index.js

@@ -1,48 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = exports.Client = exports.AbstractExperience = void 0;
-
-var _AbstractExperience2 = _interopRequireDefault(require("./AbstractExperience.js"));
-
-var _Client2 = _interopRequireDefault(require("./Client.js"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Client-side part of the *soundworks* framework.
- * Can run seamlessly in a browser or in node.js.
- *
- * @namespace client
- *
- * @example
- * import soundworks from '@soundworks/core/client';
- *
- * // create a new `soundworks.Client` instance
- * const client = new soundworks.Client();
- * // register a pre-defined or user-defined plugin
- * client.registerService('my-plugin', myServiceFactory);
- * // initialize the client (mainly connect and initialize WebSockets)
- * await client.init(config);
- * // create application specific experience
- * // must extends `soundworks.Experience`
- * const playerExperience = new PlayerExperience(client);
- * // init required plugins, if any
- * await client.start();
- * // when everything is ready, start the experience
- * playerExperience.start();
- */
-// `import soundworks from '@soundworks/core/client'``
-// or
-// `import { Client } from '@soundworks/core/client'`
-const AbstractExperience = _AbstractExperience2.default;
-exports.AbstractExperience = AbstractExperience;
-const Client = _Client2.default;
-exports.Client = Client;
-var _default = {
-  AbstractExperience: _AbstractExperience2.default,
-  Client: _Client2.default
-};
-exports.default = _default;

package/client.js

@@ -1,28 +0,0 @@
-"use strict";
-
-/**
- * This is a dirty shortcut to enable cleaner import in template using `type=module`
- * This should be cleaned little by little...
- *
- * We need to define if we can be backward compatible there if we go to full module (probably not)
- */
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = exports.Client = exports.AbstractExperience = void 0;
-
-var _AbstractExperience2 = _interopRequireDefault(require("./client/AbstractExperience.js"));
-
-var _Client2 = _interopRequireDefault(require("./client/Client.js"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const AbstractExperience = _AbstractExperience2.default;
-exports.AbstractExperience = AbstractExperience;
-const Client = _Client2.default;
-exports.Client = Client;
-var _default = {
-  AbstractExperience: _AbstractExperience2.default,
-  Client: _Client2.default
-};
-exports.default = _default;

package/common/SharedStateManagerClient.js

@@ -1,194 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _SharedState = _interopRequireDefault(require("./SharedState.js"));
-
-var _sharedStateUtils = require("./shared-state-utils.js");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Component dedicated at managing distributed states, accessible through {@link common.SharedState} instances, among the application.
- *
- * An instance of `SharedStateManagerClient` is automatically created by the
- * `soundworks.Client` at initialization (cf. {@link client.Client#stateManager}).
- *
- * Tutorial: [https://collective-soundworks.github.io/tutorials/state-manager.html](https://collective-soundworks.github.io/tutorials/state-manager.html)
- *
- * @memberof client
- * @see {@link common.SharedState}
- * @see {@link server.SharedStateManagerServer}
- * @see {@link client.Client#stateManager}
- */
-class SharedStateManagerClient {
-  /**
-   * @param {Number} id - Id of the node.
-   * @param {Object} transport - Transport to use for synchronizing the state.
-   *  Must implement a basic EventEmitter API.
-   */
-  constructor(id, transport) {
-    this.client = {
-      id,
-      transport
-    };
-    this._statesById = new Map();
-    this._observeListeners = new Set();
-    this._cachedSchemas = new Map();
-    this._observeRequestCallbacks = new Map(); // ---------------------------------------------
-    // CREATE
-    // ---------------------------------------------
-
-    this.client.transport.addListener(_sharedStateUtils.CREATE_RESPONSE, (reqId, stateId, remoteId, schemaName, schema, initValues) => {
-      // cache schema when first dealing it to save some bandwidth
-      if (!this._cachedSchemas.has(schemaName)) {
-        this._cachedSchemas.set(schemaName, schema);
-      }
-
-      schema = this._cachedSchemas.get(schemaName);
-      const state = new _SharedState.default(stateId, remoteId, schemaName, schema, this.client, true, this, initValues);
-
-      this._statesById.set(state.id, state);
-
-      (0, _sharedStateUtils.resolveRequest)(reqId, state);
-    });
-    this.client.transport.addListener(_sharedStateUtils.CREATE_ERROR, (reqId, msg) => {
-      (0, _sharedStateUtils.rejectRequest)(reqId, msg);
-    }); // ---------------------------------------------
-    // ATTACH (when creator, is attached by default)
-    // ---------------------------------------------
-
-    this.client.transport.addListener(_sharedStateUtils.ATTACH_RESPONSE, (reqId, stateId, remoteId, schemaName, schema, currentValues) => {
-      // cache schema when first dealing with it to save some bandwidth
-      // note: when we make the schemas dynamic at some point
-      // the server should be able to invalidate the schema and send
-      // it again despite the caching.
-      if (!this._cachedSchemas.has(schemaName)) {
-        this._cachedSchemas.set(schemaName, schema);
-      }
-
-      schema = this._cachedSchemas.get(schemaName);
-      const state = new _SharedState.default(stateId, remoteId, schemaName, schema, this.client, false, this, currentValues);
-
-      this._statesById.set(state.id, state);
-
-      (0, _sharedStateUtils.resolveRequest)(reqId, state);
-    });
-    this.client.transport.addListener(_sharedStateUtils.ATTACH_ERROR, (reqId, msg) => {
-      (0, _sharedStateUtils.rejectRequest)(reqId, msg);
-    }); // ---------------------------------------------
-    // OBSERVE PEERS (be notified when a state is created, lazy)
-    // ---------------------------------------------
-
-    this.client.transport.addListener(_sharedStateUtils.OBSERVE_RESPONSE, (reqId, ...list) => {
-      // retrieve the callback that have been stored in observe to make sure
-      // we don't call another callback that may have been registered earlier.
-      const callback = this._observeRequestCallbacks.get(reqId);
-
-      this._observeRequestCallbacks.delete(reqId);
-
-      list.forEach(([schemaName, stateId, nodeId]) => {
-        callback(schemaName, stateId, nodeId);
-      });
-      (0, _sharedStateUtils.resolveRequest)(reqId, list);
-    });
-    this.client.transport.addListener(_sharedStateUtils.OBSERVE_NOTIFICATION, (...list) => {
-      list.forEach(([schemaName, stateId, nodeId]) => {
-        this._observeListeners.forEach(callback => callback(schemaName, stateId, nodeId));
-      });
-    }); // ---------------------------------------------
-    // Clear cache when schema is deleted
-    // ---------------------------------------------
-
-    this.client.transport.addListener(_sharedStateUtils.DELETE_SCHEMA, schemaName => {
-      this._cachedSchemas.delete(schemaName);
-    });
-  }
-  /**
-   * Create a {@link common.SharedState} instance from a previsouly registered schema.
-   *
-   * @see {@link common.SharedState}
-   *
-   * @param {String} schemaName - Name of the schema as given on registration
-   *  (cf. ServerStateManager)
-   * @param {Object} [initValues={}] - Default values for the state.
-   *
-   * @return {@link common.SharedState}
-   */
-
-
-  async create(schemaName, initValues = {}) {
-    return new Promise((resolve, reject) => {
-      const reqId = (0, _sharedStateUtils.storeRequestPromise)(resolve, reject);
-      const requireSchema = this._cachedSchemas.has(schemaName) ? false : true;
-      this.client.transport.emit(_sharedStateUtils.CREATE_REQUEST, reqId, schemaName, requireSchema, initValues);
-    });
-  }
-  /**
-   * Attach to an existing {@link common.SharedState} instance.
-   *
-   * @see {@link common.SharedState}
-   *
-   * @param {String} schemaName - Name of the schema as given on registration
-   *  (cf. ServerStateManager)
-   * @param {Object} [stateId=null] - Id of the state to attach to. If `null`,
-   *  attach to the first state found with the given schema name (usefull for
-   *  globally shared states owned by the server).
-   *
-   * @return {@link common.SharedState}
-   */
-
-
-  async attach(schemaName, stateId = null) {
-    return new Promise((resolve, reject) => {
-      // @todo - add a timeout
-      const reqId = (0, _sharedStateUtils.storeRequestPromise)(resolve, reject);
-      const requireSchema = this._cachedSchemas.has(schemaName) ? false : true;
-      this.client.transport.emit(_sharedStateUtils.ATTACH_REQUEST, reqId, schemaName, stateId, requireSchema);
-    });
-  }
-  /**
-   * @callback client.SharedStateManagerClient~observeCallback
-   * @async
-   * @param {String} schemaName - name of the schema
-   * @param {Number} stateId - id of the state
-   * @param {Number} nodeId - id of the node that created the state
-   */
-
-  /**
-   * Observe all the {@link common.SharedState} instances that are created on the network.
-   *
-   * @param {client.SharedStateManagerClient~observeCallback} callback - Function
-   *  to be called when a new state is created on the network.
-   *
-   * @example
-   * this.client.stateManager.observe(async (schemaName, stateId, nodeId) => {
-   *   if (schemaName === 'something') {
-   *     const state = await this.client.stateManager.attach(schemaName, stateId);
-   *     console.log(state.getValues());
-   *   }
-   * });
-   */
-
-
-  observe(callback) {
-    this._observeListeners.add(callback); // store function
-
-
-    new Promise((resolve, reject) => {
-      const reqId = (0, _sharedStateUtils.storeRequestPromise)(resolve, reject); // store the callback to be executed on the response
-
-      this._observeRequestCallbacks.set(reqId, callback);
-
-      this.client.transport.emit(_sharedStateUtils.OBSERVE_REQUEST, reqId);
-    });
-    return () => this._observeListeners.delete(callback);
-  }
-
-}
-
-var _default = SharedStateManagerClient;
-exports.default = _default;

package/common/Signal.js

@@ -1,40 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-/** @private */
-class Signal {
-  constructor() {
-    this._state = false;
-    this._observers = new Set();
-  }
-
-  set value(value) {
-    if (value !== this._state) {
-      this._state = value;
-
-      for (let observer of this._observers) {
-        observer(value);
-      }
-    }
-  }
-
-  get value() {
-    return this._state;
-  }
-
-  addObserver(observer) {
-    this._observers.add(observer);
-  }
-
-  removeObserver(observer) {
-    this._observers.delete(observer);
-  }
-
-}
-
-var _default = Signal;
-exports.default = _default;

package/common/SignalAll.js

@@ -1,44 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _Signal = _interopRequireDefault(require("./Signal.js"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Compound signal that is `true` when all signals it depends on are `true`.
- * Dependencies are added through the `add` method.
- * @private
- */
-class SignalAll extends _Signal.default {
-  constructor() {
-    super();
-    this._sources = new Set();
-  }
-
-  get length() {
-    return this._sources.size;
-  }
-
-  add(signal) {
-    this._sources.add(signal);
-
-    signal.addObserver(() => {
-      let value = true;
-
-      for (let signal of this._sources) {
-        value = value && signal.value;
-      }
-
-      super.value = value;
-    });
-  }
-
-}
-
-var _default = SignalAll;
-exports.default = _default;