node-web-audio-api 0.18.0 → 0.19.0

package/js/BaseAudioContext.js

@@ -0,0 +1,419 @@
+// -------------------------------------------------------------------------- //
+// -------------------------------------------------------------------------- //
+//                                                                            //
+//                                                                            //
+//                                                                            //
+//    ██╗    ██╗ █████╗ ██████╗ ███╗   ██╗██╗███╗   ██╗ ██████╗               //
+//    ██║    ██║██╔══██╗██╔══██╗████╗  ██║██║████╗  ██║██╔════╝               //
+//    ██║ █╗ ██║███████║██████╔╝██╔██╗ ██║██║██╔██╗ ██║██║  ███╗              //
+//    ██║███╗██║██╔══██║██╔══██╗██║╚██╗██║██║██║╚██╗██║██║   ██║              //
+//    ╚███╔███╔╝██║  ██║██║  ██║██║ ╚████║██║██║ ╚████║╚██████╔╝              //
+//     ╚══╝╚══╝ ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═══╝╚═╝╚═╝  ╚═══╝ ╚═════╝               //
+//                                                                            //
+//                                                                            //
+//    - This file has been generated ---------------------------              //
+//                                                                            //
+//                                                                            //
+// -------------------------------------------------------------------------- //
+// -------------------------------------------------------------------------- //
+
+const {
+  isFunction,
+  kEnumerableProperty,
+  kHiddenProperty,
+} = require('./lib/utils.js');
+const {
+  kNapiObj,
+} = require('./lib/symbols.js');
+
+module.exports = (jsExport, _nativeBinding) => {
+  class BaseAudioContext extends EventTarget {
+    #listener = null;
+    #destination = null;
+
+    constructor(options) {
+      // Make constructor "private"
+      if (
+        (typeof options !== 'object') ||
+        !(kNapiObj in options)
+      ) {
+        throw new TypeError('Illegal constructor');
+      }
+
+      super();
+
+      Object.defineProperty(this, kNapiObj, {
+        value: options[kNapiObj],
+        ...kHiddenProperty,
+      });
+
+      this.#listener = null; // lazily instanciated
+      this.#destination = new jsExport.AudioDestinationNode(this, {
+        [kNapiObj]: this[kNapiObj].destination,
+      });
+    }
+
+    get listener() {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      if (this.#listener === null) {
+        this.#listener = new jsExport.AudioListener({
+          [kNapiObj]: this[kNapiObj].listener,
+        });
+      }
+
+      return this.#listener;
+    }
+
+    get destination() {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      return this.#destination;
+    }
+
+    get sampleRate() {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      return this[kNapiObj].sampleRate;
+    }
+
+    get currentTime() {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      return this[kNapiObj].currentTime;
+    }
+
+    get state() {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      return this[kNapiObj].state;
+    }
+
+    // renderQuantumSize
+    // audioWorklet
+
+    get onstatechange() {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      return this._statechange || null;
+    }
+
+    set onstatechange(value) {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      if (isFunction(value) || value === null) {
+        this._statechange = value;
+      }
+    }
+
+    // This is not exactly what the spec says, but if we reject the promise
+    // when decodeErrorCallback is present the program will crash in an
+    // unexpected manner
+    // cf. https://webaudio.github.io/web-audio-api/#dom-baseaudiocontext-decodeaudiodata
+    async decodeAudioData(arrayBuffer, decodeSuccessCallback = undefined, decodeErrorCallback = undefined) {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to execute 'decodeAudioData' on 'BaseAudioContext': 1 argument required, but only ${arguments.length} present`);
+      }
+
+      if (!(arrayBuffer instanceof ArrayBuffer)) {
+        throw new TypeError('Failed to execute "decodeAudioData": parameter 1 is not of type "ArrayBuffer"');
+      }
+
+      try {
+        const nativeAudioBuffer = await this[kNapiObj].decodeAudioData(arrayBuffer);
+        const audioBuffer = new jsExport.AudioBuffer({
+          [kNapiObj]: nativeAudioBuffer,
+        });
+
+        if (isFunction(decodeSuccessCallback)) {
+          decodeSuccessCallback(audioBuffer);
+        } else {
+          return audioBuffer;
+        }
+      } catch (err) {
+        const error = new DOMException(`Failed to execute 'decodeAudioData': ${err.message}`, 'EncodingError');
+
+        if (isFunction(decodeErrorCallback)) {
+          decodeErrorCallback(error);
+        } else {
+          throw error;
+        }
+      }
+    }
+
+    createBuffer(numberOfChannels, length, sampleRate) {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      if (arguments.length < 3) {
+        throw new TypeError(`Failed to execute 'createBuffer' on 'BaseAudioContext': 3 argument required, but only ${arguments.length} present`);
+      }
+
+      const options = {};
+
+      if (numberOfChannels !== undefined) {
+        options.numberOfChannels = numberOfChannels;
+      }
+
+      if (length !== undefined) {
+        options.length = length;
+      }
+
+      if (sampleRate !== undefined) {
+        options.sampleRate = sampleRate;
+      }
+
+      return new jsExport.AudioBuffer(options);
+    }
+
+    createPeriodicWave(real, imag) {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      if (arguments.length < 2) {
+        throw new TypeError(`Failed to execute 'createPeriodicWave' on 'BaseAudioContext': 2 argument required, but only ${arguments.length} present`);
+      }
+
+      const options = {};
+
+      if (real !== undefined) {
+        options.real = real;
+      }
+
+      if (imag !== undefined) {
+        options.imag = imag;
+      }
+
+      return new jsExport.PeriodicWave(this, options);
+    }
+
+    // --------------------------------------------------------------------
+    // Factory Methods (use the patched AudioNodes)
+    // --------------------------------------------------------------------
+    createAnalyser() {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      const options = {};
+
+      return new jsExport.AnalyserNode(this, options);
+    }
+
+    createBufferSource() {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      const options = {};
+
+      return new jsExport.AudioBufferSourceNode(this, options);
+    }
+
+    createBiquadFilter() {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      const options = {};
+
+      return new jsExport.BiquadFilterNode(this, options);
+    }
+
+    createChannelMerger(numberOfInputs = 6) {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      const options = {
+        numberOfInputs,
+      };
+
+      return new jsExport.ChannelMergerNode(this, options);
+    }
+
+    createChannelSplitter(numberOfOutputs = 6) {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      const options = {
+        numberOfOutputs,
+      };
+
+      return new jsExport.ChannelSplitterNode(this, options);
+    }
+
+    createConstantSource() {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      const options = {};
+
+      return new jsExport.ConstantSourceNode(this, options);
+    }
+
+    createConvolver() {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      const options = {};
+
+      return new jsExport.ConvolverNode(this, options);
+    }
+
+    createDelay(maxDelayTime = 1.0) {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      const options = {
+        maxDelayTime,
+      };
+
+      return new jsExport.DelayNode(this, options);
+    }
+
+    createDynamicsCompressor() {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      const options = {};
+
+      return new jsExport.DynamicsCompressorNode(this, options);
+    }
+
+    createGain() {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      const options = {};
+
+      return new jsExport.GainNode(this, options);
+    }
+
+    createIIRFilter(feedforward, feedback) {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      const options = {
+        feedforward,
+        feedback,
+      };
+
+      return new jsExport.IIRFilterNode(this, options);
+    }
+
+    createOscillator() {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      const options = {};
+
+      return new jsExport.OscillatorNode(this, options);
+    }
+
+    createPanner() {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      const options = {};
+
+      return new jsExport.PannerNode(this, options);
+    }
+
+    createStereoPanner() {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      const options = {};
+
+      return new jsExport.StereoPannerNode(this, options);
+    }
+
+    createWaveShaper() {
+      if (!(this instanceof BaseAudioContext)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BaseAudioContext\'');
+      }
+
+      const options = {};
+
+      return new jsExport.WaveShaperNode(this, options);
+    }
+
+  }
+
+  Object.defineProperties(BaseAudioContext, {
+    length: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 0,
+    },
+  });
+
+  Object.defineProperties(BaseAudioContext.prototype, {
+    [Symbol.toStringTag]: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 'BaseAudioContext',
+    },
+    createAnalyser: kEnumerableProperty,
+    createBufferSource: kEnumerableProperty,
+    createBiquadFilter: kEnumerableProperty,
+    createChannelMerger: kEnumerableProperty,
+    createChannelSplitter: kEnumerableProperty,
+    createConstantSource: kEnumerableProperty,
+    createConvolver: kEnumerableProperty,
+    createDelay: kEnumerableProperty,
+    createDynamicsCompressor: kEnumerableProperty,
+    createGain: kEnumerableProperty,
+    createIIRFilter: kEnumerableProperty,
+    createOscillator: kEnumerableProperty,
+    createPanner: kEnumerableProperty,
+    createStereoPanner: kEnumerableProperty,
+    createWaveShaper: kEnumerableProperty,
+    listener: kEnumerableProperty,
+    destination: kEnumerableProperty,
+    sampleRate: kEnumerableProperty,
+    currentTime: kEnumerableProperty,
+    state: kEnumerableProperty,
+    onstatechange: kEnumerableProperty,
+    decodeAudioData: kEnumerableProperty,
+    createBuffer: kEnumerableProperty,
+    createPeriodicWave: kEnumerableProperty,
+  });
+
+  return BaseAudioContext;
+};

package/js/BiquadFilterNode.js

@@ -17,54 +17,223 @@
 // -------------------------------------------------------------------------- //
 // -------------------------------------------------------------------------- //
 
-// 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 = (NativeBiquadFilterNode) => {
+module.exports = (jsExport, nativeBinding) => {
+  class BiquadFilterNode extends AudioNode {
 
-  const EventTarget = EventTargetMixin(NativeBiquadFilterNode);
-  const AudioNode = AudioNodeMixin(EventTarget);
+    #frequency = null;
+    #detune = null;
+    #Q = null;
+    #gain = null;
 
-  class BiquadFilterNode extends AudioNode {
     constructor(context, options) {
-      if (options !== undefined && typeof options !== 'object') {
-        throw new TypeError("Failed to construct 'BiquadFilterNode': argument 2 is not of type 'BiquadFilterOptions'")
+
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to construct 'BiquadFilterNode': 1 argument required, but only ${arguments.length} present`);
+      }
+
+      if (!(context instanceof jsExport.BaseAudioContext)) {
+        throw new TypeError(`Failed to construct 'BiquadFilterNode': 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 \'BiquadFilterNode\': argument 2 is not of type \'BiquadFilterOptions\'');
+      }
+
+      if (options && options.type !== undefined) {
+        if (!['lowpass', 'highpass', 'bandpass', 'lowshelf', 'highshelf', 'peaking', 'notch', 'allpass'].includes(options.type)) {
+          throw new TypeError(`Failed to construct 'BiquadFilterNode': Failed to read the 'type' property from BiquadFilterOptions: The provided value '${options.type}' is not a valid enum value of type BiquadFilterType`);
+        }
+
+        parsedOptions.type = conversions['DOMString'](options.type, {
+          context: `Failed to construct 'BiquadFilterNode': Failed to read the 'type' property from BiquadFilterOptions: The provided value '${options.type}'`,
+        });
+      } else {
+        parsedOptions.type = 'lowpass';
+      }
+
+      if (options && options.Q !== undefined) {
+        parsedOptions.Q = conversions['float'](options.Q, {
+          context: `Failed to construct 'BiquadFilterNode': Failed to read the 'Q' property from BiquadFilterOptions: The provided value (${options.Q}})`,
+        });
+      } else {
+        parsedOptions.Q = 1;
+      }
+
+      if (options && options.detune !== undefined) {
+        parsedOptions.detune = conversions['float'](options.detune, {
+          context: `Failed to construct 'BiquadFilterNode': Failed to read the 'detune' property from BiquadFilterOptions: The provided value (${options.detune}})`,
+        });
+      } else {
+        parsedOptions.detune = 0;
+      }
+
+      if (options && options.frequency !== undefined) {
+        parsedOptions.frequency = conversions['float'](options.frequency, {
+          context: `Failed to construct 'BiquadFilterNode': Failed to read the 'frequency' property from BiquadFilterOptions: The provided value (${options.frequency}})`,
+        });
+      } else {
+        parsedOptions.frequency = 350;
       }
 
-      super(context, options);
+      if (options && options.gain !== undefined) {
+        parsedOptions.gain = conversions['float'](options.gain, {
+          context: `Failed to construct 'BiquadFilterNode': Failed to read the 'gain' property from BiquadFilterOptions: The provided value (${options.gain}})`,
+        });
+      } else {
+        parsedOptions.gain = 0;
+      }
+
+      if (options && options.channelCount !== undefined) {
+        parsedOptions.channelCount = conversions['unsigned long'](options.channelCount, {
+          enforceRange: true,
+          context: `Failed to construct 'BiquadFilterNode': Failed to read the 'channelCount' property from BiquadFilterOptions: The provided value '${options.channelCount}'`,
+        });
+      }
+
+      if (options && options.channelCountMode !== undefined) {
+        parsedOptions.channelCountMode = conversions['DOMString'](options.channelCountMode, {
+          context: `Failed to construct 'BiquadFilterNode': Failed to read the 'channelCount' property from BiquadFilterOptions: The provided value '${options.channelCountMode}'`,
+        });
+      }
 
-      this.frequency = new AudioParam(this.frequency);
-      this.detune = new AudioParam(this.detune);
-      this.Q = new AudioParam(this.Q);
-      this.gain = new AudioParam(this.gain);
+      if (options && options.channelInterpretation !== undefined) {
+        parsedOptions.channelInterpretation = conversions['DOMString'](options.channelInterpretation, {
+          context: `Failed to construct 'BiquadFilterNode': Failed to read the 'channelInterpretation' property from BiquadFilterOptions: The provided value '${options.channelInterpretation}'`,
+        });
+      }
+
+      let napiObj;
+
+      try {
+        napiObj = new nativeBinding.BiquadFilterNode(context[kNapiObj], parsedOptions);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+
+      super(context, {
+        [kNapiObj]: napiObj,
+      });
+
+      this.#frequency = new jsExport.AudioParam({
+        [kNapiObj]: this[kNapiObj].frequency,
+      });
+      this.#detune = new jsExport.AudioParam({
+        [kNapiObj]: this[kNapiObj].detune,
+      });
+      this.#Q = new jsExport.AudioParam({
+        [kNapiObj]: this[kNapiObj].Q,
+      });
+      this.#gain = new jsExport.AudioParam({
+        [kNapiObj]: this[kNapiObj].gain,
+      });
     }
 
-    // getters
+    get frequency() {
+      if (!(this instanceof BiquadFilterNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BiquadFilterNode\'');
+      }
 
-    get type() {
-      return super.type;
+      return this.#frequency;
     }
 
-    // setters
+    get detune() {
+      if (!(this instanceof BiquadFilterNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BiquadFilterNode\'');
+      }
+
+      return this.#detune;
+    }
+
+    get Q() {
+      if (!(this instanceof BiquadFilterNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BiquadFilterNode\'');
+      }
+
+      return this.#Q;
+    }
+
+    get gain() {
+      if (!(this instanceof BiquadFilterNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BiquadFilterNode\'');
+      }
+
+      return this.#gain;
+    }
+
+    get type() {
+      if (!(this instanceof BiquadFilterNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BiquadFilterNode\'');
+      }
+
+      return this[kNapiObj].type;
+    }
 
     set type(value) {
+      if (!(this instanceof BiquadFilterNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BiquadFilterNode\'');
+      }
+
+      if (!['lowpass', 'highpass', 'bandpass', 'lowshelf', 'highshelf', 'peaking', 'notch', 'allpass'].includes(value)) {
+        console.warn(`Failed to set the 'type' property on 'BiquadFilterNode': Value '${value}' is not a valid 'BiquadFilterType' enum value`);
+        return;
+      }
+
       try {
-        super.type = value;
+        this[kNapiObj].type = value;
       } catch (err) {
         throwSanitizedError(err);
       }
     }
 
-    // methods
-    
-    getFrequencyResponse(...args) {
+    getFrequencyResponse(frequencyHz, magResponse, phaseResponse) {
+      if (!(this instanceof BiquadFilterNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'BiquadFilterNode\'');
+      }
+
+      if (arguments.length < 3) {
+        throw new TypeError(`Failed to execute 'getFrequencyResponse' on 'BiquadFilterNode': 3 argument required, but only ${arguments.length} present`);
+      }
+
+      if (!(frequencyHz instanceof Float32Array)) {
+        throw new TypeError(`Failed to execute 'getFrequencyResponse' on 'BiquadFilterNode': Parameter 1 is not of type 'Float32Array'`);
+      }
+
+      if (!(magResponse instanceof Float32Array)) {
+        throw new TypeError(`Failed to execute 'getFrequencyResponse' on 'BiquadFilterNode': Parameter 2 is not of type 'Float32Array'`);
+      }
+
+      if (!(phaseResponse instanceof Float32Array)) {
+        throw new TypeError(`Failed to execute 'getFrequencyResponse' on 'BiquadFilterNode': Parameter 3 is not of type 'Float32Array'`);
+      }
+
       try {
-        return super.getFrequencyResponse(...args);
+        return this[kNapiObj].getFrequencyResponse(frequencyHz, magResponse, phaseResponse);
       } catch (err) {
         throwSanitizedError(err);
       }
@@ -72,8 +241,31 @@ module.exports = (NativeBiquadFilterNode) => {
 
   }
 
-  return BiquadFilterNode;
-};
+  Object.defineProperties(BiquadFilterNode, {
+    length: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 1,
+    },
+  });
 
+  Object.defineProperties(BiquadFilterNode.prototype, {
+    [Symbol.toStringTag]: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 'BiquadFilterNode',
+    },
+    frequency: kEnumerableProperty,
+    detune: kEnumerableProperty,
+    Q: kEnumerableProperty,
+    gain: kEnumerableProperty,
+    type: kEnumerableProperty,
+    getFrequencyResponse: kEnumerableProperty,
+  });
 
-  
+  return BiquadFilterNode;
+};