node-web-audio-api 0.18.0 → 0.20.0

package/js/OfflineAudioContext.js

@@ -1,57 +1,220 @@
-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 {
+  propagateEvent,
+} = require('./lib/events.js');
+const {
+  throwSanitizedError,
+} = require('./lib/errors.js');
+const {
+  isFunction,
+  kEnumerableProperty,
+} = require('./lib/utils.js');
+const {
+  kNapiObj,
+  kOnStateChange,
+  kOnComplete,
+} = require('./lib/symbols.js');
 
-  const EventTarget = require('./EventTarget.mixin.js')(bindings.OfflineAudioContext, ['statechange']);
-  const BaseAudioContext = require('./BaseAudioContext.mixin.js')(EventTarget, bindings);
+module.exports = function patchOfflineAudioContext(jsExport, nativeBinding) {
+  class OfflineAudioContext extends jsExport.BaseAudioContext {
+    #renderedBuffer = null;
 
-  class OfflineAudioContext extends 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.`);
+        }
+
+        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);
+      }
+
+      super({ [kNapiObj]: napiObj });
+
+      // Add function to Napi object to bridge from Rust events to JS EventTarget
+      // They will be effectively registered on rust side when `startRendering` is called
+      this[kNapiObj][kOnStateChange] = (err, rawEvent) => {
+        if (typeof rawEvent !== 'object' && !('type' in rawEvent)) {
+          throw new TypeError('Invalid [kOnStateChange] Invocation: rawEvent should have a type property');
         }
-        args = [numberOfChannels, length, sampleRate];
+
+        const event = new Event(rawEvent.type);
+        propagateEvent(this, event);
+      };
+
+      // This event is, per spec, the last trigerred one
+      this[kNapiObj][kOnComplete] = (err, rawEvent) => {
+        if (typeof rawEvent !== 'object' && !('type' in rawEvent)) {
+          throw new TypeError('Invalid [kOnComplete] Invocation: rawEvent should have a type property');
+        }
+
+        // @fixme: workaround the fact that this event seems to be triggered before
+        // startRendering fulfills and that we want to return the exact same instance
+        if (this.#renderedBuffer === null) {
+          this.#renderedBuffer = new jsExport.AudioBuffer({ [kNapiObj]: rawEvent.renderedBuffer });
+        }
+
+        const event = new jsExport.OfflineAudioCompletionEvent(rawEvent.type, {
+          renderedBuffer: this.#renderedBuffer,
+        });
+
+        propagateEvent(this, event);
+      };
+    }
+
+    get length() {
+      if (!(this instanceof OfflineAudioContext)) {
+        throw new TypeError(`Invalid Invocation: Value of 'this' must be of type 'OfflineAudioContext'`);
       }
 
-      const [numberOfChannels, length, sampleRate] = args;
+      return this[kNapiObj].length;
+    }
 
-      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 oncomplete() {
+      if (!(this instanceof OfflineAudioContext)) {
+        throw new TypeError(`Invalid Invocation: Value of 'this' must be of type 'OfflineAudioContext'`);
       }
 
-      super(numberOfChannels, length, sampleRate);
+      return this._complete || null;
+    }
 
-      // EventTargetMixin has been called so EventTargetMixin[kDispatchEvent] is
-      // bound to this, then we can safely finalize event target initialization
-      super.__initEventTarget__();
+    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'`);
+      }
+
+      let nativeAudioBuffer;
+
+      try {
+        nativeAudioBuffer = await this[kNapiObj].startRendering();
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+
+      // @fixme: workaround the fact that this event seems to be triggered before
+      // startRendering fulfills and that we want to return the exact same instance
+      if (this.#renderedBuffer === null) {
+        this.#renderedBuffer = new jsExport.AudioBuffer({ [kNapiObj]: nativeAudioBuffer });
+      }
+
+      return this.#renderedBuffer;
+    }
+
+    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`);
+      }
 
-      // 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.
-      const event = new Event('complete');
-      event.renderedBuffer = renderedBuffer;
-      this.dispatchEvent(event)
+      suspendTime = conversions['double'](suspendTime, {
+        context: `Failed to execute 'suspend' on 'OfflineAudioContext': argument 1`,
+      });
 
-      return renderedBuffer;
+      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;
 };

package/js/OscillatorNode.js

@@ -17,56 +17,192 @@
 // -------------------------------------------------------------------------- //
 // -------------------------------------------------------------------------- //
 
-// 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');
-const AudioScheduledSourceNodeMixin = require('./AudioScheduledSourceNode.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');
+/* eslint-enable no-unused-vars */
 
-module.exports = (NativeOscillatorNode) => {
-
-  const EventTarget = EventTargetMixin(NativeOscillatorNode, ['ended']);
-  const AudioNode = AudioNodeMixin(EventTarget);
-  const AudioScheduledSourceNode = AudioScheduledSourceNodeMixin(AudioNode);
+const AudioScheduledSourceNode = require('./AudioScheduledSourceNode.js');
 
+module.exports = (jsExport, nativeBinding) => {
   class OscillatorNode extends AudioScheduledSourceNode {
+
+    #frequency = null;
+    #detune = null;
+
     constructor(context, options) {
-      if (options !== undefined && typeof options !== 'object') {
-        throw new TypeError("Failed to construct 'OscillatorNode': argument 2 is not of type 'OscillatorOptions'")
+
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to construct 'OscillatorNode': 1 argument required, but only ${arguments.length} present`);
+      }
+
+      if (!(context instanceof jsExport.BaseAudioContext)) {
+        throw new TypeError(`Failed to construct 'OscillatorNode': 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 \'OscillatorNode\': argument 2 is not of type \'OscillatorOptions\'');
+      }
+
+      if (options && options.type !== undefined) {
+        if (!['sine', 'square', 'sawtooth', 'triangle', 'custom'].includes(options.type)) {
+          throw new TypeError(`Failed to construct 'OscillatorNode': Failed to read the 'type' property from OscillatorOptions: The provided value '${options.type}' is not a valid enum value of type OscillatorType`);
+        }
+
+        parsedOptions.type = conversions['DOMString'](options.type, {
+          context: `Failed to construct 'OscillatorNode': Failed to read the 'type' property from OscillatorOptions: The provided value '${options.type}'`,
+        });
+      } else {
+        parsedOptions.type = 'sine';
+      }
+
+      if (options && options.frequency !== undefined) {
+        parsedOptions.frequency = conversions['float'](options.frequency, {
+          context: `Failed to construct 'OscillatorNode': Failed to read the 'frequency' property from OscillatorOptions: The provided value (${options.frequency}})`,
+        });
+      } else {
+        parsedOptions.frequency = 440;
+      }
+
+      if (options && options.detune !== undefined) {
+        parsedOptions.detune = conversions['float'](options.detune, {
+          context: `Failed to construct 'OscillatorNode': Failed to read the 'detune' property from OscillatorOptions: The provided value (${options.detune}})`,
+        });
+      } else {
+        parsedOptions.detune = 0;
+      }
+
+      if (options && options.periodicWave !== undefined) {
+        if (!(options.periodicWave instanceof jsExport.PeriodicWave)) {
+          throw new TypeError(`Failed to construct 'OscillatorNode': Failed to read the 'periodicWave' property from OscillatorOptions: The provided value '${options.periodicWave}' is not an instance of PeriodicWave`);
+        }
+
+        parsedOptions.periodicWave = options.periodicWave[kNapiObj];
+      } else {
+        parsedOptions.periodicWave = null;
+      }
+
+      if (parsedOptions.type === 'custom' && parsedOptions.periodicWave === null) {
+        throw new DOMException('Failed to construct \'OscillatorNode\': A PeriodicWave must be specified if the type is set to \'custom\'', 'InvalidStateError');
+      }
+
+      if (parsedOptions.periodicWave !== null) {
+        parsedOptions.type = 'custom';
+      }
+
+      if (options && options.channelCount !== undefined) {
+        parsedOptions.channelCount = conversions['unsigned long'](options.channelCount, {
+          enforceRange: true,
+          context: `Failed to construct 'OscillatorNode': Failed to read the 'channelCount' property from OscillatorOptions: The provided value '${options.channelCount}'`,
+        });
+      }
+
+      if (options && options.channelCountMode !== undefined) {
+        parsedOptions.channelCountMode = conversions['DOMString'](options.channelCountMode, {
+          context: `Failed to construct 'OscillatorNode': Failed to read the 'channelCount' property from OscillatorOptions: The provided value '${options.channelCountMode}'`,
+        });
+      }
+
+      if (options && options.channelInterpretation !== undefined) {
+        parsedOptions.channelInterpretation = conversions['DOMString'](options.channelInterpretation, {
+          context: `Failed to construct 'OscillatorNode': Failed to read the 'channelInterpretation' property from OscillatorOptions: The provided value '${options.channelInterpretation}'`,
+        });
+      }
+
+      let napiObj;
+
+      try {
+        napiObj = new nativeBinding.OscillatorNode(context[kNapiObj], parsedOptions);
+      } catch (err) {
+        throwSanitizedError(err);
       }
 
-      super(context, options);
-      // EventTargetMixin has been called so EventTargetMixin[kDispatchEvent] is
-      // bound to this, then we can safely finalize event target initialization
-      super.__initEventTarget__();
+      super(context, {
+        [kNapiObj]: napiObj,
+      });
 
-      this.frequency = new AudioParam(this.frequency);
-      this.detune = new AudioParam(this.detune);
+      this.#frequency = new jsExport.AudioParam({
+        [kNapiObj]: this[kNapiObj].frequency,
+      });
+      this.#detune = new jsExport.AudioParam({
+        [kNapiObj]: this[kNapiObj].detune,
+      });
     }
 
-    // getters
+    get frequency() {
+      if (!(this instanceof OscillatorNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'OscillatorNode\'');
+      }
 
-    get type() {
-      return super.type;
+      return this.#frequency;
     }
 
-    // setters
+    get detune() {
+      if (!(this instanceof OscillatorNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'OscillatorNode\'');
+      }
+
+      return this.#detune;
+    }
+
+    get type() {
+      if (!(this instanceof OscillatorNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'OscillatorNode\'');
+      }
+
+      return this[kNapiObj].type;
+    }
 
     set type(value) {
+      if (!(this instanceof OscillatorNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'OscillatorNode\'');
+      }
+
+      if (!['sine', 'square', 'sawtooth', 'triangle', 'custom'].includes(value)) {
+        console.warn(`Failed to set the 'type' property on 'OscillatorNode': Value '${value}' is not a valid 'OscillatorType' enum value`);
+        return;
+      }
+
       try {
-        super.type = value;
+        this[kNapiObj].type = value;
       } catch (err) {
         throwSanitizedError(err);
       }
     }
 
-    // methods
-    
-    setPeriodicWave(...args) {
+    setPeriodicWave(periodicWave) {
+      if (!(this instanceof OscillatorNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'OscillatorNode\'');
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to execute 'setPeriodicWave' on 'OscillatorNode': 1 argument required, but only ${arguments.length} present`);
+      }
+
+      if (!(periodicWave instanceof jsExport.PeriodicWave)) {
+        throw new TypeError(`Failed to execute 'setPeriodicWave' on 'OscillatorNode': Parameter 1 is not of type 'PeriodicWave'`);
+      }
+
+      periodicWave = periodicWave[kNapiObj];
+
       try {
-        return super.setPeriodicWave(...args);
+        return this[kNapiObj].setPeriodicWave(periodicWave);
       } catch (err) {
         throwSanitizedError(err);
       }
@@ -74,8 +210,29 @@ module.exports = (NativeOscillatorNode) => {
 
   }
 
-  return OscillatorNode;
-};
+  Object.defineProperties(OscillatorNode, {
+    length: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 1,
+    },
+  });
 
+  Object.defineProperties(OscillatorNode.prototype, {
+    [Symbol.toStringTag]: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 'OscillatorNode',
+    },
+    frequency: kEnumerableProperty,
+    detune: kEnumerableProperty,
+    type: kEnumerableProperty,
+    setPeriodicWave: kEnumerableProperty,
+  });
 
-  
+  return OscillatorNode;
+};