node-web-audio-api 0.18.0 → 0.19.0

package/js/IIRFilterNode.js

@@ -17,38 +17,135 @@
 // -------------------------------------------------------------------------- //
 // -------------------------------------------------------------------------- //
 
-// eslint-disable-next-line no-unused-vars
-const { throwSanitizedError } = require('./lib/errors.js');
-// eslint-disable-next-line no-unused-vars
-const { AudioParam } = require('./AudioParam.js');
-const EventTargetMixin = require('./EventTarget.mixin.js');
-const AudioNodeMixin = require('./AudioNode.mixin.js');
+/* eslint-disable no-unused-vars */
+const conversions = require('webidl-conversions');
+const {
+  toSanitizedSequence,
+} = require('./lib/cast.js');
+const {
+  isFunction,
+  kEnumerableProperty,
+} = require('./lib/utils.js');
+const {
+  throwSanitizedError,
+} = require('./lib/errors.js');
+const {
+  kNapiObj,
+  kAudioBuffer,
+} = require('./lib/symbols.js');
+const {
+  bridgeEventTarget,
+} = require('./lib/events.js');
+/* eslint-enable no-unused-vars */
 
+const AudioNode = require('./AudioNode.js');
 
-module.exports = (NativeIIRFilterNode) => {
-
-  const EventTarget = EventTargetMixin(NativeIIRFilterNode);
-  const AudioNode = AudioNodeMixin(EventTarget);
-
+module.exports = (jsExport, nativeBinding) => {
   class IIRFilterNode extends AudioNode {
+
     constructor(context, options) {
-      if (options !== undefined && typeof options !== 'object') {
-        throw new TypeError("Failed to construct 'IIRFilterNode': argument 2 is not of type 'IIRFilterOptions'")
+
+      if (arguments.length < 2) {
+        throw new TypeError(`Failed to construct 'IIRFilterNode': 2 argument required, but only ${arguments.length} present`);
+      }
+
+      if (!(context instanceof jsExport.BaseAudioContext)) {
+        throw new TypeError(`Failed to construct 'IIRFilterNode': argument 1 is not of type BaseAudioContext`);
+      }
+
+      // parsed version of the option to be passed to NAPI
+      const parsedOptions = {};
+
+      if (options && typeof options !== 'object') {
+        throw new TypeError('Failed to construct \'IIRFilterNode\': argument 2 is not of type \'IIRFilterOptions\'');
+      }
+
+      // required options
+      if (typeof options !== 'object' || (options && options.feedforward === undefined)) {
+        throw new TypeError('Failed to construct \'IIRFilterNode\': Failed to read the \'feedforward\' property from IIRFilterOptions: Required member is undefined');
+      }
+
+      if (options && options.feedforward !== undefined) {
+        try {
+          parsedOptions.feedforward = toSanitizedSequence(options.feedforward, Float64Array);
+        } catch (err) {
+          throw new TypeError(`Failed to construct 'IIRFilterNode': Failed to read the 'feedforward' property from IIRFilterOptions: The provided value ${err.message}`);
+        }
+      } else {
+        parsedOptions.feedforward = null;
+      }
+
+      // required options
+      if (typeof options !== 'object' || (options && options.feedback === undefined)) {
+        throw new TypeError('Failed to construct \'IIRFilterNode\': Failed to read the \'feedback\' property from IIRFilterOptions: Required member is undefined');
+      }
+
+      if (options && options.feedback !== undefined) {
+        try {
+          parsedOptions.feedback = toSanitizedSequence(options.feedback, Float64Array);
+        } catch (err) {
+          throw new TypeError(`Failed to construct 'IIRFilterNode': Failed to read the 'feedback' property from IIRFilterOptions: The provided value ${err.message}`);
+        }
+      } else {
+        parsedOptions.feedback = null;
+      }
+
+      if (options && options.channelCount !== undefined) {
+        parsedOptions.channelCount = conversions['unsigned long'](options.channelCount, {
+          enforceRange: true,
+          context: `Failed to construct 'IIRFilterNode': Failed to read the 'channelCount' property from IIRFilterOptions: The provided value '${options.channelCount}'`,
+        });
+      }
+
+      if (options && options.channelCountMode !== undefined) {
+        parsedOptions.channelCountMode = conversions['DOMString'](options.channelCountMode, {
+          context: `Failed to construct 'IIRFilterNode': Failed to read the 'channelCount' property from IIRFilterOptions: The provided value '${options.channelCountMode}'`,
+        });
       }
 
-      super(context, options);
+      if (options && options.channelInterpretation !== undefined) {
+        parsedOptions.channelInterpretation = conversions['DOMString'](options.channelInterpretation, {
+          context: `Failed to construct 'IIRFilterNode': Failed to read the 'channelInterpretation' property from IIRFilterOptions: The provided value '${options.channelInterpretation}'`,
+        });
+      }
+
+      let napiObj;
+
+      try {
+        napiObj = new nativeBinding.IIRFilterNode(context[kNapiObj], parsedOptions);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+
+      super(context, {
+        [kNapiObj]: napiObj,
+      });
 
     }
 
-    // getters
+    getFrequencyResponse(frequencyHz, magResponse, phaseResponse) {
+      if (!(this instanceof IIRFilterNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'IIRFilterNode\'');
+      }
 
-    // setters
+      if (arguments.length < 3) {
+        throw new TypeError(`Failed to execute 'getFrequencyResponse' on 'IIRFilterNode': 3 argument required, but only ${arguments.length} present`);
+      }
+
+      if (!(frequencyHz instanceof Float32Array)) {
+        throw new TypeError(`Failed to execute 'getFrequencyResponse' on 'IIRFilterNode': Parameter 1 is not of type 'Float32Array'`);
+      }
+
+      if (!(magResponse instanceof Float32Array)) {
+        throw new TypeError(`Failed to execute 'getFrequencyResponse' on 'IIRFilterNode': Parameter 2 is not of type 'Float32Array'`);
+      }
+
+      if (!(phaseResponse instanceof Float32Array)) {
+        throw new TypeError(`Failed to execute 'getFrequencyResponse' on 'IIRFilterNode': Parameter 3 is not of type 'Float32Array'`);
+      }
 
-    // methods
-    
-    getFrequencyResponse(...args) {
       try {
-        return super.getFrequencyResponse(...args);
+        return this[kNapiObj].getFrequencyResponse(frequencyHz, magResponse, phaseResponse);
       } catch (err) {
         throwSanitizedError(err);
       }
@@ -56,8 +153,27 @@ module.exports = (NativeIIRFilterNode) => {
 
   }
 
-  return IIRFilterNode;
-};
+  Object.defineProperties(IIRFilterNode, {
+    length: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 2,
+    },
+  });
+
+  Object.defineProperties(IIRFilterNode.prototype, {
+    [Symbol.toStringTag]: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 'IIRFilterNode',
+    },
 
+    getFrequencyResponse: kEnumerableProperty,
+  });
 
-  
+  return IIRFilterNode;
+};

package/js/MediaStreamAudioSourceNode.js

@@ -17,43 +17,102 @@
 // -------------------------------------------------------------------------- //
 // -------------------------------------------------------------------------- //
 
-// eslint-disable-next-line no-unused-vars
-const { throwSanitizedError } = require('./lib/errors.js');
-// eslint-disable-next-line no-unused-vars
-const { AudioParam } = require('./AudioParam.js');
-const EventTargetMixin = require('./EventTarget.mixin.js');
-const AudioNodeMixin = require('./AudioNode.mixin.js');
+/* eslint-disable no-unused-vars */
+const conversions = require('webidl-conversions');
+const {
+  toSanitizedSequence,
+} = require('./lib/cast.js');
+const {
+  isFunction,
+  kEnumerableProperty,
+} = require('./lib/utils.js');
+const {
+  throwSanitizedError,
+} = require('./lib/errors.js');
+const {
+  kNapiObj,
+  kAudioBuffer,
+} = require('./lib/symbols.js');
+const {
+  bridgeEventTarget,
+} = require('./lib/events.js');
+/* eslint-enable no-unused-vars */
 
+const AudioNode = require('./AudioNode.js');
 
-module.exports = (NativeMediaStreamAudioSourceNode) => {
-
-  const EventTarget = EventTargetMixin(NativeMediaStreamAudioSourceNode);
-  const AudioNode = AudioNodeMixin(EventTarget);
-
+module.exports = (jsExport, nativeBinding) => {
   class MediaStreamAudioSourceNode extends AudioNode {
+
     constructor(context, options) {
-      if (options !== undefined && typeof options !== 'object') {
-        throw new TypeError("Failed to construct 'MediaStreamAudioSourceNode': argument 2 is not of type 'MediaStreamAudioSourceOptions'")
+
+      if (arguments.length < 2) {
+        throw new TypeError(`Failed to construct 'MediaStreamAudioSourceNode': 2 argument required, but only ${arguments.length} present`);
       }
 
-      super(context, options);
+      if (!(context instanceof jsExport.AudioContext)) {
+        throw new TypeError(`Failed to construct 'MediaStreamAudioSourceNode': argument 1 is not of type AudioContext`);
+      }
 
-    }
+      // parsed version of the option to be passed to NAPI
+      const parsedOptions = {};
 
-    // getters
+      if (options && typeof options !== 'object') {
+        throw new TypeError('Failed to construct \'MediaStreamAudioSourceNode\': argument 2 is not of type \'MediaStreamAudioSourceOptions\'');
+      }
+
+      // required options
+      if (typeof options !== 'object' || (options && options.mediaStream === undefined)) {
+        throw new TypeError('Failed to construct \'MediaStreamAudioSourceNode\': Failed to read the \'mediaStream\' property from MediaStreamAudioSourceOptions: Required member is undefined');
+      }
+
+      parsedOptions.mediaStream = options.mediaStream;
+
+      let napiObj;
+
+      try {
+        napiObj = new nativeBinding.MediaStreamAudioSourceNode(context[kNapiObj], parsedOptions);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+
+      super(context, {
+        [kNapiObj]: napiObj,
+      });
 
-    get mediaStream() {
-      return super.mediaStream;
     }
 
-    // setters
+    get mediaStream() {
+      if (!(this instanceof MediaStreamAudioSourceNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'MediaStreamAudioSourceNode\'');
+      }
+
+      return this[kNapiObj].mediaStream;
+    }
 
-    // methods
-    
   }
 
-  return MediaStreamAudioSourceNode;
-};
+  Object.defineProperties(MediaStreamAudioSourceNode, {
+    length: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 2,
+    },
+  });
+
+  Object.defineProperties(MediaStreamAudioSourceNode.prototype, {
+    [Symbol.toStringTag]: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 'MediaStreamAudioSourceNode',
+    },
 
+    mediaStream: kEnumerableProperty,
 
-  
+  });
+
+  return MediaStreamAudioSourceNode;
+};

package/js/OfflineAudioContext.js

@@ -1,57 +1,205 @@
-const { nameCodeMap, DOMException } = require('./lib/errors.js');
-const { isPlainObject, isPositiveInt, isPositiveNumber } = require('./lib/utils.js');
+const conversions = require('webidl-conversions');
 
-module.exports = function patchOfflineAudioContext(bindings) {
-  // @todo - EventTarget
-  // - https://github.com/orottier/web-audio-api-rs/issues/411
-  // - https://github.com/orottier/web-audio-api-rs/issues/416
+const {
+  bridgeEventTarget,
+} = require('./lib/events.js');
+const {
+  throwSanitizedError,
+} = require('./lib/errors.js');
+const {
+  isFunction,
+  kEnumerableProperty,
+} = require('./lib/utils.js');
+const {
+  kNapiObj
+} = require('./lib/symbols.js');
 
-  const EventTarget = require('./EventTarget.mixin.js')(bindings.OfflineAudioContext, ['statechange']);
-  const BaseAudioContext = require('./BaseAudioContext.mixin.js')(EventTarget, bindings);
+// constructor(OfflineAudioContextOptions contextOptions);
+// constructor(unsigned long numberOfChannels, unsigned long length, float sampleRate);
+// Promise<AudioBuffer> startRendering();
+// Promise<undefined> resume();
+// Promise<undefined> suspend(double suspendTime);
+// readonly attribute unsigned long length;
+// attribute EventHandler oncomplete;
 
-  class OfflineAudioContext extends BaseAudioContext {
+module.exports = function patchOfflineAudioContext(jsExport, nativeBinding) {
+  class OfflineAudioContext extends jsExport.BaseAudioContext {
     constructor(...args) {
-      // handle initialisation with either an options object or a sequence of parameters
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to construct 'OfflineAudioContext': 1 argument required, but only ${arguments.length} present`);
+      }
+
       // https://webaudio.github.io/web-audio-api/#dom-offlineaudiocontext-constructor-contextoptions-contextoptions
-      if (isPlainObject(args[0]) && 'length' in args[0] && 'sampleRate' in args[0]
-      ) {
-        let { numberOfChannels, length, sampleRate } = args[0];
-        if (numberOfChannels === undefined) {
-            numberOfChannels = 1;
+      if (arguments.length === 1) {
+        const options = args[0];
+
+        if (typeof options !== 'object') {
+          throw new TypeError(`Failed to construct 'OfflineAudioContext': argument 1 is not of type 'OfflineAudioContextOptions'`);
+        }
+
+        if (options.length === undefined) {
+          throw new TypeError(`Failed to construct 'OfflineAudioContext': Failed to read the 'length' property from 'OfflineAudioContextOptions': Required member is undefined.`);
+        }
+
+        if (options.sampleRate === undefined) {
+          throw new TypeError(`Failed to construct 'OfflineAudioContext': Failed to read the 'sampleRate' property from 'OfflineAudioContextOptions': Required member is undefined.`);
         }
-        args = [numberOfChannels, length, sampleRate];
+
+        if (options.numberOfChannels === undefined) {
+          options.numberOfChannels = 1;
+        }
+
+        args = [
+          options.numberOfChannels,
+          options.length,
+          options.sampleRate
+        ];
+      }
+
+      let [numberOfChannels, length, sampleRate] = args;
+
+      numberOfChannels = conversions['unsigned long'](numberOfChannels, {
+        enforceRange: true,
+        context: `Failed to construct 'OfflineAudioContext': Failed to read the 'numberOfChannels' property from OfflineContextOptions; The provided value (${numberOfChannels})`
+      });
+
+      length = conversions['unsigned long'](length, {
+        enforceRange: true,
+        context: `Failed to construct 'OfflineAudioContext': Failed to read the 'length' property from OfflineContextOptions; The provided value (${length})`
+      });
+
+      sampleRate = conversions['float'](sampleRate, {
+        context: `Failed to construct 'OfflineAudioContext': Failed to read the 'sampleRate' property from OfflineContextOptions; The provided value (${sampleRate})`
+      });
+
+      let napiObj;
+
+      try {
+        napiObj = new nativeBinding.OfflineAudioContext(numberOfChannels, length, sampleRate);
+      } catch (err) {
+        throwSanitizedError(err);
       }
 
-      const [numberOfChannels, length, sampleRate] = args;
+      super({ [kNapiObj]: napiObj });
+    }
 
-      if (!isPositiveInt(numberOfChannels)) {
-        throw new TypeError(`Invalid value for numberOfChannels: ${numberOfChannels}`);
-      } else if (!isPositiveInt(length)) {
-        throw new TypeError(`Invalid value for length: ${length}`);
-      } else if (!isPositiveNumber(sampleRate)) {
-        throw new TypeError(`Invalid value for sampleRate: ${sampleRate}`);
+    get length() {
+      if (!(this instanceof OfflineAudioContext)) {
+        throw new TypeError("Invalid Invocation: Value of 'this' must be of type 'OfflineAudioContext'");
       }
 
-      super(numberOfChannels, length, sampleRate);
+      return this[kNapiObj].length;
+    }
 
-      // EventTargetMixin has been called so EventTargetMixin[kDispatchEvent] is
-      // bound to this, then we can safely finalize event target initialization
-      super.__initEventTarget__();
+    get oncomplete() {
+      if (!(this instanceof OfflineAudioContext)) {
+        throw new TypeError("Invalid Invocation: Value of 'this' must be of type 'OfflineAudioContext'");
+      }
+
+      return this._complete || null;
+    }
+
+    set oncomplete(value) {
+      if (!(this instanceof OfflineAudioContext)) {
+        throw new TypeError("Invalid Invocation: Value of 'this' must be of type 'OfflineAudioContext'");
+      }
+
+      if (isFunction(value) || value === null) {
+        this._complete = value;
+      }
     }
 
     async startRendering() {
-      const renderedBuffer = await super.startRendering();
+      if (!(this instanceof OfflineAudioContext)) {
+        throw new TypeError("Invalid Invocation: Value of 'this' must be of type 'OfflineAudioContext'");
+      }
+
+      // Lazily register event callback on rust side
+      bridgeEventTarget(this);
 
-      // We do this here, so that we can just share the same audioBuffer instance.
-      // This also simplifies code on the rust side as we don't need to deal
-      // with the OfflineAudioCompletionEvent.
+      let nativeAudioBuffer;
+
+      try {
+        nativeAudioBuffer = await this[kNapiObj].startRendering();
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+
+      const audioBuffer = new jsExport.AudioBuffer({ [kNapiObj]: nativeAudioBuffer });
+
+      // We dispatch the complete event manually to simplify the sharing of the
+      // `AudioBuffer` instance. This also simplifies code on the rust side as
+      // we don't need to deal with the `OfflineAudioCompletionEvent` type.
       const event = new Event('complete');
-      event.renderedBuffer = renderedBuffer;
-      this.dispatchEvent(event)
+      event.renderedBuffer = audioBuffer;
 
-      return renderedBuffer;
+      if (isFunction(this[`oncomplete`])) {
+        this[`oncomplete`](event);
+      }
+
+      this.dispatchEvent(event);
+
+      return audioBuffer;
+    }
+
+    async resume() {
+      if (!(this instanceof OfflineAudioContext)) {
+        throw new TypeError("Invalid Invocation: Value of 'this' must be of type 'OfflineAudioContext'");
+      }
+
+      try {
+        await this[kNapiObj].resume();
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+
+    async suspend(suspendTime) {
+      if (!(this instanceof OfflineAudioContext)) {
+        throw new TypeError("Invalid Invocation: Value of 'this' must be of type 'OfflineAudioContext'");
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to execute 'suspend' on 'OfflineAudioContext': 1 argument required, but only ${arguments.length} present`);
+      }
+
+      suspendTime = conversions['double'](suspendTime, {
+        context: `Failed to execute 'suspend' on 'OfflineAudioContext': argument 1`,
+      });
+
+      try {
+        await this[kNapiObj].suspend(suspendTime);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
     }
   }
 
+  Object.defineProperties(OfflineAudioContext, {
+    length: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 1,
+    },
+  });
+
+  Object.defineProperties(OfflineAudioContext.prototype, {
+    [Symbol.toStringTag]: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 'OfflineAudioContext',
+    },
+
+    length: kEnumerableProperty,
+    oncomplete: kEnumerableProperty,
+    startRendering: kEnumerableProperty,
+    resume: kEnumerableProperty,
+    suspend: kEnumerableProperty,
+  });
+
   return OfflineAudioContext;
 };