node-web-audio-api 0.18.0 → 0.20.0

package/js/Events.js

@@ -0,0 +1,84 @@
+const { kEnumerableProperty } = require('./lib/utils.js');
+
+class OfflineAudioCompletionEvent extends Event {
+  #renderedBuffer = null;
+
+  constructor(type, eventInitDict) {
+    super(type);
+
+    if (typeof eventInitDict !== 'object' || eventInitDict === null || !('renderedBuffer' in eventInitDict)) {
+      throw TypeError(`Failed to construct 'OfflineAudioCompletionEvent': Failed to read the 'renderedBuffer' property from 'OfflineAudioCompletionEvent': Required member is undefined.`);
+    }
+
+    this.#renderedBuffer = eventInitDict.renderedBuffer;
+  }
+
+  get renderedBuffer() {
+    return this.#renderedBuffer;
+  }
+}
+
+Object.defineProperties(OfflineAudioCompletionEvent.prototype, {
+  [Symbol.toStringTag]: {
+    __proto__: null,
+    writable: false,
+    enumerable: false,
+    configurable: true,
+    value: 'OfflineAudioCompletionEvent',
+  },
+
+  renderedBuffer: kEnumerableProperty,
+});
+
+class AudioProcessingEvent extends Event {
+  #playbackTime = null;
+  #inputBuffer = null;
+  #outputBuffer = null;
+
+  constructor(type, eventInitDict) {
+    if (
+      typeof eventInitDict !== 'object'
+      || eventInitDict === null
+      || !('playbackTime' in eventInitDict)
+      || !('inputBuffer' in eventInitDict)
+      || !('outputBuffer' in eventInitDict)
+    ) {
+      throw TypeError(`Failed to construct 'AudioProcessingEvent': Invalid 'AudioProcessingEventInit' given`);
+    }
+
+    super(type);
+
+    this.#playbackTime = eventInitDict.playbackTime;
+    this.#inputBuffer = eventInitDict.inputBuffer;
+    this.#outputBuffer = eventInitDict.outputBuffer;
+  }
+
+  get playbackTime() {
+    return this.#playbackTime;
+  }
+
+  get inputBuffer() {
+    return this.#inputBuffer;
+  }
+
+  get outputBuffer() {
+    return this.#outputBuffer;
+  }
+}
+
+Object.defineProperties(AudioProcessingEvent.prototype, {
+  [Symbol.toStringTag]: {
+    __proto__: null,
+    writable: false,
+    enumerable: false,
+    configurable: true,
+    value: 'AudioProcessingEvent',
+  },
+
+  playbackTime: kEnumerableProperty,
+  inputBuffer: kEnumerableProperty,
+  outputBuffer: kEnumerableProperty,
+});
+
+module.exports.OfflineAudioCompletionEvent = OfflineAudioCompletionEvent;
+module.exports.AudioProcessingEvent = AudioProcessingEvent;

package/js/GainNode.js

@@ -17,40 +17,123 @@
 // -------------------------------------------------------------------------- //
 // -------------------------------------------------------------------------- //
 
-// 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');
+/* eslint-enable no-unused-vars */
 
+const AudioNode = require('./AudioNode.js');
 
-module.exports = (NativeGainNode) => {
+module.exports = (jsExport, nativeBinding) => {
+  class GainNode extends AudioNode {
 
-  const EventTarget = EventTargetMixin(NativeGainNode);
-  const AudioNode = AudioNodeMixin(EventTarget);
+    #gain = null;
 
-  class GainNode extends AudioNode {
     constructor(context, options) {
-      if (options !== undefined && typeof options !== 'object') {
-        throw new TypeError("Failed to construct 'GainNode': argument 2 is not of type 'GainOptions'")
+
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to construct 'GainNode': 1 argument required, but only ${arguments.length} present`);
+      }
+
+      if (!(context instanceof jsExport.BaseAudioContext)) {
+        throw new TypeError(`Failed to construct 'GainNode': 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 \'GainNode\': argument 2 is not of type \'GainOptions\'');
+      }
+
+      if (options && options.gain !== undefined) {
+        parsedOptions.gain = conversions['float'](options.gain, {
+          context: `Failed to construct 'GainNode': Failed to read the 'gain' property from GainOptions: The provided value (${options.gain}})`,
+        });
+      } else {
+        parsedOptions.gain = 1.0;
+      }
+
+      if (options && options.channelCount !== undefined) {
+        parsedOptions.channelCount = conversions['unsigned long'](options.channelCount, {
+          enforceRange: true,
+          context: `Failed to construct 'GainNode': Failed to read the 'channelCount' property from GainOptions: The provided value '${options.channelCount}'`,
+        });
+      }
+
+      if (options && options.channelCountMode !== undefined) {
+        parsedOptions.channelCountMode = conversions['DOMString'](options.channelCountMode, {
+          context: `Failed to construct 'GainNode': Failed to read the 'channelCount' property from GainOptions: The provided value '${options.channelCountMode}'`,
+        });
+      }
+
+      if (options && options.channelInterpretation !== undefined) {
+        parsedOptions.channelInterpretation = conversions['DOMString'](options.channelInterpretation, {
+          context: `Failed to construct 'GainNode': Failed to read the 'channelInterpretation' property from GainOptions: The provided value '${options.channelInterpretation}'`,
+        });
       }
 
-      super(context, options);
+      let napiObj;
 
-      this.gain = new AudioParam(this.gain);
+      try {
+        napiObj = new nativeBinding.GainNode(context[kNapiObj], parsedOptions);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+
+      super(context, {
+        [kNapiObj]: napiObj,
+      });
+
+      this.#gain = new jsExport.AudioParam({
+        [kNapiObj]: this[kNapiObj].gain,
+      });
     }
 
-    // getters
+    get gain() {
+      if (!(this instanceof GainNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'GainNode\'');
+      }
 
-    // setters
+      return this.#gain;
+    }
 
-    // methods
-    
   }
 
-  return GainNode;
-};
+  Object.defineProperties(GainNode, {
+    length: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 1,
+    },
+  });
 
+  Object.defineProperties(GainNode.prototype, {
+    [Symbol.toStringTag]: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 'GainNode',
+    },
+    gain: kEnumerableProperty,
 
-  
+  });
+
+  return GainNode;
+};

package/js/IIRFilterNode.js

@@ -17,38 +17,132 @@
 // -------------------------------------------------------------------------- //
 // -------------------------------------------------------------------------- //
 
-// 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');
+/* 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 +150,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,99 @@
 // -------------------------------------------------------------------------- //
 // -------------------------------------------------------------------------- //
 
-// 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');
+/* 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;
+};