node-web-audio-api 0.18.0 → 0.20.0

package/js/AudioContext.js

@@ -1,60 +1,326 @@
-let contextId = 0;
+const conversions = require('webidl-conversions');
+
+const {
+  throwSanitizedError,
+} = require('./lib/errors.js');
+const {
+  isFunction,
+  kEnumerableProperty,
+} = require('./lib/utils.js');
+const {
+  kNapiObj,
+  kOnStateChange,
+  kOnSinkChange,
+} = require('./lib/symbols.js');
+const {
+  propagateEvent,
+} = require('./lib/events.js');
 
-const kProcessId = Symbol('processId');
-const kKeepAwakeId = Symbol('keepAwakeId');
+let contextId = 0;
 
-module.exports = function(bindings) {
-  const {
-    MediaStreamAudioSourceNode,
-  } = bindings;
+module.exports = function(jsExport, nativeBinding) {
 
-  const EventTarget = require('./EventTarget.mixin.js')(bindings.AudioContext, ['statechange', 'sinkchange']);
-  const BaseAudioContext = require('./BaseAudioContext.mixin.js')(EventTarget, bindings);
+  class AudioContext extends jsExport.BaseAudioContext {
+    #sinkId = '';
 
-  class AudioContext extends BaseAudioContext {
-  // class AudioContext extends NativeAudioContext {
     constructor(options = {}) {
-      super(options);
-      // EventTargetMixin has been called so EventTargetMixin[kDispatchEvent] is
-      // bound to this, then we can safely finalize event target initialization
-      super.__initEventTarget__();
+      if (typeof options !== 'object') {
+        throw new TypeError(`Failed to construct 'AudioContext': The provided value is not of type 'AudioContextOptions'`);
+      }
+
+      let targetOptions = {};
+
+      if (options.latencyHint !== undefined) {
+        if (['balanced', 'interactive', 'playback'].includes(options.latencyHint)) {
+          targetOptions.latencyHint = conversions['DOMString'](options.latencyHint);
+        } else {
+          targetOptions.latencyHint = conversions['double'](options.latencyHint, {
+            context: `Failed to construct 'AudioContext': Failed to read the 'sinkId' property from AudioNodeOptions: The provided value (${options.latencyHint})`,
+          });
+        }
+      } else {
+        targetOptions.latencyHint = 'interactive';
+      }
+
+      if (options.sampleRate !== undefined) {
+        targetOptions.sampleRate = conversions['float'](options.sampleRate, {
+          context: `Failed to construct 'AudioContext': Failed to read the 'sinkId' property from AudioNodeOptions: The provided value (${options.sampleRate})`,
+        });
+      } else {
+        targetOptions.sampleRate = null;
+      }
+
+      if (options.sinkId !== undefined) {
+        const sinkId = options.sinkId;
+
+        if (typeof options.sinkId === 'object') {
+          // https://webaudio.github.io/web-audio-api/#enumdef-audiosinktype
+          if (!('type' in options.sinkId) || options.sinkId.type !== 'none') {
+            throw TypeError(`Failed to construct 'AudioContext': Failed to read the 'sinkId' property from AudioNodeOptions: Failed to read the 'type' property from 'AudioSinkOptions': The provided value (${sinkId.type}) is not a valid enum value of type AudioSinkType.`);
+          }
+
+          targetOptions.sinkId = 'none';
+        } else {
+          targetOptions.sinkId = conversions['DOMString'](sinkId, {
+            context: `Failed to construct 'AudioContext': Failed to read the 'sinkId' property from AudioNodeOptions:  Failed to read the 'type' property from 'AudioSinkOptions': The provided value (${sinkId})`,
+          });
+        }
+      } else {
+        targetOptions.sinkId = '';
+      }
+
+      let napiObj;
+
+      try {
+        napiObj = new nativeBinding.AudioContext(targetOptions);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+
+      super({ [kNapiObj]: napiObj });
+
+      if (options.sinkId !== undefined) {
+        this.#sinkId = options.sinkId;
+      }
+
+      // Add function to Napi object to bridge from Rust events to JS EventTarget
+      this[kNapiObj][kOnStateChange] = (err, rawEvent) => {
+        if (typeof rawEvent !== 'object' && !('type' in rawEvent)) {
+          throw new TypeError('Invalid [kOnStateChange] Invocation: rawEvent should have a type property');
+        }
+
+        const event = new Event(rawEvent.type);
+        propagateEvent(this, event);
+      };
 
+      this[kNapiObj][kOnSinkChange] = (err, rawEvent) => {
+        if (typeof rawEvent !== 'object' && !('type' in rawEvent)) {
+          throw new TypeError('Invalid [kOnSinkChange] Invocation: rawEvent should have a type property');
+        }
+
+        const event = new Event(rawEvent.type);
+        propagateEvent(this, event);
+      };
+
+      // Workaround to bind the `sinkchange` and `statechange` events to EventTarget.
+      // This must be called from JS facade ctor as the JS handler are added to the Napi
+      // object after its instantiation, and that we don't have any initial `resume` call.
+      this[kNapiObj].listen_to_events();
+
+      // @todo - check if this is still required
       // prevent garbage collection and process exit
       const id = contextId++;
       // store in process to prevent garbage collection
-      const processId = Symbol(`__AudioContext_${id}`);
-      process[processId] = this;
-      // keep process symbol around to delete later
-      this[kProcessId] = processId;
+      const kAudioContextId = Symbol(`node-web-audio-api:audio-context-${id}`);
+      Object.defineProperty(process, kAudioContextId, {
+        __proto__: null,
+        enumerable: false,
+        configurable: true,
+        value: this,
+      });
       // keep process awake until context is closed
       const keepAwakeId = setInterval(() => {}, 10 * 1000);
-      this[kKeepAwakeId] = keepAwakeId;
 
       // clear on close
       this.addEventListener('statechange', () => {
         if (this.state === 'closed') {
           // allow to garbage collect the context and to the close the process
-          delete process[this[kProcessId]];
-          clearTimeout(this[kKeepAwakeId]);
+          delete process[kAudioContextId];
+          clearTimeout(keepAwakeId);
         }
       });
     }
 
-    setSinkId(sinkId) {
+    get baseLatency() {
+      if (!(this instanceof AudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioContext\'');
+      }
+
+      return this[kNapiObj].baseLatency;
+    }
+
+    get outputLatency() {
+      if (!(this instanceof AudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioContext\'');
+      }
+
+      return this[kNapiObj].outputLatency;
+    }
+
+    get sinkId() {
+      if (!(this instanceof AudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioContext\'');
+      }
+
+      return this.#sinkId;
+    }
+
+    get renderCapacity() {
+      if (!(this instanceof AudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioContext\'');
+      }
+
+      throw new Error(`AudioContext::renderCapacity is not yet implemented`);
+    }
+
+    get onsinkchange() {
+      if (!(this instanceof AudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioContext\'');
+      }
+
+      return this._sinkchange || null;
+    }
+
+    set onsinkchange(value) {
+      if (!(this instanceof AudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioContext\'');
+      }
+
+      if (isFunction(value) || value === null) {
+        this._sinkchange = value;
+      }
+    }
+
+    getOutputTimestamp() {
+      if (!(this instanceof AudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioContext\'');
+      }
+
+      throw new Error(`AudioContext::getOutputTimestamp is not yet implemented`);
+    }
+
+    async resume() {
+      if (!(this instanceof AudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioContext\'');
+      }
+
+      await this[kNapiObj].resume();
+    }
+
+    async suspend() {
+      if (!(this instanceof AudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioContext\'');
+      }
+
+      await this[kNapiObj].suspend();
+    }
+
+    async close() {
+      if (!(this instanceof AudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioContext\'');
+      }
+
+      await this[kNapiObj].close();
+    }
+
+    async setSinkId(sinkId) {
+      if (!(this instanceof AudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioContext\'');
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to execute 'setSinkId' on 'AudioContext': 1 argument required, but only ${arguments.length} present`);
+      }
+
+      let targetSinkId = '';
+
+      if (typeof sinkId === 'object') {
+        if (!('type' in sinkId) || sinkId.type !== 'none') {
+          throw new TypeError(`Failed to execute 'setSinkId' on 'AudioContext': Failed to read the 'type' property from 'AudioSinkOptions': The provided value '${sinkId.type}' is not a valid enum value of type AudioSinkType.`);
+        }
+
+        targetSinkId = 'none';
+      } else {
+        targetSinkId = conversions['DOMString'](sinkId, {
+          context: `Failed to execute 'setSinkId' on 'AudioContext': Failed to read the 'type' property from 'AudioSinkOptions': The provided value '${sinkId.type}'`,
+        });
+      }
+
+      this.#sinkId = sinkId;
+
       try {
-        super.setSinkId(sinkId);
-        return Promise.resolve(undefined);
+        this[kNapiObj].setSinkId(targetSinkId);
       } catch (err) {
-        return Promise.reject(err);
+        throwSanitizedError(err);
       }
     }
 
     // online context only AudioNodes
     createMediaStreamSource(mediaStream) {
-      const options = { mediaStream };
-      return new MediaStreamAudioSourceNode(this, options);
+      if (!(this instanceof AudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioContext\'');
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to execute 'createMediaStreamSource' on 'AudioContext': 1 argument required, but only ${arguments.length} present`);
+      }
+
+      const options = {
+        mediaStream,
+      };
+
+      return new jsExport.MediaStreamAudioSourceNode(this, options);
+    }
+
+    createMediaElementSource() {
+      if (!(this instanceof AudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioContext\'');
+      }
+
+      throw new Error(`AudioContext::createMediaElementSource() is not yet implemented, cf. https://github.com/ircam-ismm/node-web-audio-api/issues/91 for more information`);
+    }
+
+    createMediaStreamTrackSource() {
+      if (!(this instanceof AudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioContext\'');
+      }
+
+      throw new Error(`AudioContext::createMediaStreamTrackSource() is not yet implemented, cf. https://github.com/ircam-ismm/node-web-audio-api/issues/91 for more information`);
+    }
+
+    createMediaStreamDestination() {
+      if (!(this instanceof AudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioContext\'');
+      }
+
+      throw new Error(`AudioContext::createMediaStreamDestination() is not yet implemented, cf. https://github.com/ircam-ismm/node-web-audio-api/issues/91 for more information`);
     }
   }
 
+  Object.defineProperties(AudioContext, {
+    length: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 0,
+    },
+  });
+
+  Object.defineProperties(AudioContext.prototype, {
+    [Symbol.toStringTag]: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 'AudioContext',
+    },
+
+    baseLatency: kEnumerableProperty,
+    outputLatency: kEnumerableProperty,
+    sinkId: kEnumerableProperty,
+    renderCapacity: kEnumerableProperty,
+    onsinkchange: kEnumerableProperty,
+    getOutputTimestamp: kEnumerableProperty,
+    resume: kEnumerableProperty,
+    suspend: kEnumerableProperty,
+    close: kEnumerableProperty,
+    setSinkId: kEnumerableProperty,
+    createMediaStreamSource: kEnumerableProperty,
+    createMediaElementSource: kEnumerableProperty,
+    createMediaStreamTrackSource: kEnumerableProperty,
+    createMediaStreamDestination: kEnumerableProperty,
+  });
+
   return AudioContext;
 };

package/js/AudioDestinationNode.js

@@ -1,111 +1,53 @@
-// @note - This should be reviewed (but how...?)
-//
-// We can't really use the AudioNode mixin because we need to wrap
-// the native destination instance.
+const { kNapiObj } = require('./lib/symbols.js');
+const { kEnumerableProperty } = require('./lib/utils.js');
+const AudioNode = require('./AudioNode.js');
 
-const { throwSanitizedError } = require('./lib/errors.js');
-const { AudioParam, kNativeAudioParam } = require('./AudioParam.js');
-const kNativeAudioDestinationNode = Symbol('node-web-audio-api:audio-destination-node');
-
-class AudioDestinationNode {
-  constructor(nativeAudioDestinationNode) {
-    this[kNativeAudioDestinationNode] = nativeAudioDestinationNode;
-  }
-
-  // AudioNode interface
-  get context() {
-    return this[kNativeAudioDestinationNode].context;
-  }
-
-  get numberOfInputs() {
-    return this[kNativeAudioDestinationNode].numberOfInputs;
-  }
-
-  get numberOfOutputs() {
-    return this[kNativeAudioDestinationNode].numberOfOutputs;
-  }
-
-  get channelCount() {
-    return this[kNativeAudioDestinationNode].channelCount;
-  }
-
-  get channelCountMode() {
-    return this[kNativeAudioDestinationNode].channelCountMode;
-  }
-
-  get channelInterpretation() {
-    return this[kNativeAudioDestinationNode].channelInterpretation;
-  }
-
-  // setters
-
-  set channelCount(value) {
-    try {
-      this[kNativeAudioDestinationNode].channelCount = value;
-    } catch (err) {
-      throwSanitizedError(err);
-    }
-  }
-
-  set channelCountMode(value) {
-    try {
-      this[kNativeAudioDestinationNode].channelCountMode = value;
-    } catch (err) {
-      throwSanitizedError(err);
-    }
-  }
-
-  set channelInterpretation(value) {
-    try {
-      this[kNativeAudioDestinationNode].channelInterpretation = value;
-    } catch (err) {
-      throwSanitizedError(err);
-    }
-  }
-
-  // methods - connect / disconnect
-
-  connect(...args) {
-    // unwrap raw audio params from facade
-    if (args[0] instanceof AudioParam) {
-      args[0] = args[0][kNativeAudioParam];
-    }
-
-    // unwrap raw audio destination from facade
-    if (args[0] instanceof AudioDestinationNode) {
-      args[0] = args[0][kNativeAudioDestinationNode];
+class AudioDestinationNode extends AudioNode {
+  constructor(context, options) {
+    // Make constructor "private"
+    if (
+      (typeof options !== 'object')
+      || !(kNapiObj in options)
+      || options[kNapiObj]['Symbol.toStringTag'] !== 'AudioDestinationNode'
+    ) {
+      throw new TypeError('Illegal constructor');
     }
 
-    try {
-      return this[kNativeAudioDestinationNode].connect(...args);
-    } catch (err) {
-      throwSanitizedError(err);
-    }
+    super(context, {
+      [kNapiObj]: options[kNapiObj],
+    });
   }
 
-  disconnect(...args) {
-    // unwrap raw audio params from facade
-    if (args[0] instanceof AudioParam) {
-      args[0] = args[0][kNativeAudioParam];
-    }
-
-    // unwrap raw audio destination from facade
-    if (args[0] instanceof AudioDestinationNode) {
-      args[0] = args[0][kNativeAudioDestinationNode];
-    }
-
-    try {
-      return this[kNativeAudioDestinationNode].disconnect(...args);
-    } catch (err) {
-      throwSanitizedError(err);
+  get maxChannelCount() {
+    if (!(this instanceof AudioDestinationNode)) {
+      throw new TypeError(`Invalid Invocation: Value of 'this' must be of type 'AudioDestinationNode'`);
     }
-  }
 
-  get maxChannelCount() {
-    return this[kNativeAudioDestinationNode].maxChannelCount;
+    return this[kNapiObj].maxChannelCount;
   }
 }
 
-module.exports.kNativeAudioDestinationNode = kNativeAudioDestinationNode;
-module.exports.AudioDestinationNode = AudioDestinationNode;
+Object.defineProperties(AudioDestinationNode, {
+  length: {
+    __proto__: null,
+    writable: false,
+    enumerable: false,
+    configurable: true,
+    value: 0,
+  },
+});
+
+Object.defineProperties(AudioDestinationNode.prototype, {
+  [Symbol.toStringTag]: {
+    __proto__: null,
+    writable: false,
+    enumerable: false,
+    configurable: true,
+    value: 'AudioDestinationNode',
+  },
+
+  maxChannelCount: kEnumerableProperty,
+});
+
+module.exports = AudioDestinationNode;