node-web-audio-api 0.18.0 → 0.20.0

package/js/PeriodicWave.js

@@ -1,16 +1,80 @@
+const conversions = require('webidl-conversions');
+
 const { throwSanitizedError } = require('./lib/errors.js');
+const { toSanitizedSequence } = require('./lib/cast.js');
+const { kNapiObj } = require('./lib/symbols.js');
+const { kHiddenProperty } = require('./lib/utils.js');
 
-module.exports = (NativePeriodicWave) => {
-  class PeriodicWave extends NativePeriodicWave {
+module.exports = (jsExport, nativeBinding) => {
+  class PeriodicWave {
     constructor(context, options) {
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to construct 'PeriodicWave': 1 argument required, but only ${arguments.length} present`);
+      }
+
+      if (!(context instanceof jsExport.BaseAudioContext)) {
+        throw new TypeError(`Failed to construct 'PeriodicWave': argument 1 is not of type BaseAudioContext`);
+      }
+
+      const parsedOptions = {};
+
+      if (options && 'real' in options) {
+        try {
+          parsedOptions.real = toSanitizedSequence(options.real, Float32Array);
+        } catch (err) {
+          throw new TypeError(`Failed to construct 'PeriodicWave': Failed to read the 'real' property from PeriodicWaveOptions: The provided value ${err.message}`);
+        }
+      }
+
+      if (options && 'imag' in options) {
+        try {
+          parsedOptions.imag = toSanitizedSequence(options.imag, Float32Array);
+        } catch (err) {
+          throw new TypeError(`Failed to construct 'PeriodicWave': Failed to read the 'imag' property from PeriodicWaveOptions: The provided value ${err.message}`);
+        }
+      }
+
+      // disableNormalization = false
+      if (options && 'disableNormalization' in options) {
+        parsedOptions.disableNormalization = conversions['boolean'](options.disableNormalization, {
+          context: `Failed to construct 'PeriodicWave': Failed to read the 'imag' property from PeriodicWaveOptions: The provided value`,
+        });
+      } else {
+        parsedOptions.disableNormalization;
+      }
+
       try {
-        super(context, options);
+        const napiObj = new nativeBinding.PeriodicWave(context[kNapiObj], parsedOptions);
+        Object.defineProperty(this, kNapiObj, {
+          value: napiObj,
+          ...kHiddenProperty,
+        });
       } catch (err) {
         throwSanitizedError(err);
       }
     }
   }
 
+  Object.defineProperties(PeriodicWave, {
+    length: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 1,
+    },
+  });
+
+  Object.defineProperties(PeriodicWave.prototype, {
+    [Symbol.toStringTag]: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 'PeriodicWave',
+    },
+  });
+
   return PeriodicWave;
 };
 

package/js/ScriptProcessorNode.js

@@ -0,0 +1,179 @@
+/* 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,
+  kOnAudioProcess,
+} = require('./lib/symbols.js');
+const {
+  propagateEvent,
+} = require('./lib/events.js');
+/* eslint-enable no-unused-vars */
+
+const AudioNode = require('./AudioNode.js');
+
+module.exports = (jsExport, nativeBinding) => {
+  class ScriptProcessorNode extends AudioNode {
+
+    #onaudioprocess = null;
+
+    constructor(context, options) {
+
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to construct 'ScriptProcessorNode': 1 argument required, but only ${arguments.length} present`);
+      }
+
+      if (!(context instanceof jsExport.BaseAudioContext)) {
+        throw new TypeError(`Failed to construct 'ScriptProcessorNode': 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 \'ScriptProcessorNode\': argument 2 is not of type \'ScriptProcessorNodeOptions\'');
+      }
+
+      // IDL defines bufferSize default value as 0
+      // cf. https://webaudio.github.io/web-audio-api/#dom-baseaudiocontext-createscriptprocessor
+      // > If it’s not passed in, or if the value is 0, then the implementation
+      // > will choose the best buffer size for the given environment, which will
+      // > be constant power of 2 throughout the lifetime of the node.
+      if (options && options.bufferSize !== undefined && options.bufferSize !== 0) {
+        parsedOptions.bufferSize = conversions['unsigned long'](options.bufferSize, {
+          enforceRange: true,
+          context: `Failed to construct 'ScriptProcessorNode': Failed to read the 'bufferSize' property from ScriptProcessorNodeOptions: The provided value '${options.bufferSize}'`,
+        });
+      } else {
+        parsedOptions.bufferSize = 256;
+      }
+
+      if (options && options.numberOfInputChannels !== undefined) {
+        parsedOptions.numberOfInputChannels = conversions['unsigned long'](options.numberOfInputChannels, {
+          enforceRange: true,
+          context: `Failed to construct 'ScriptProcessorNode': Failed to read the 'numberOfInputChannels' property from ScriptProcessorNodeOptions: The provided value '${options.numberOfInputChannels}'`,
+        });
+      } else {
+        parsedOptions.numberOfInputChannels = 2;
+      }
+
+      if (options && options.numberOfOutputChannels !== undefined) {
+        parsedOptions.numberOfOutputChannels = conversions['unsigned long'](options.numberOfOutputChannels, {
+          enforceRange: true,
+          context: `Failed to construct 'ScriptProcessorNode': Failed to read the 'numberOfOutputChannels' property from ScriptProcessorNodeOptions: The provided value '${options.numberOfOutputChannels}'`,
+        });
+      } else {
+        parsedOptions.numberOfOutputChannels = 2;
+      }
+
+      if (options && options.channelCount !== undefined) {
+        parsedOptions.channelCount = conversions['unsigned long'](options.channelCount, {
+          enforceRange: true,
+          context: `Failed to construct 'ScriptProcessorNode': Failed to read the 'channelCount' property from ScriptProcessorNodeOptions: The provided value '${options.channelCount}'`,
+        });
+      }
+
+      if (options && options.channelCountMode !== undefined) {
+        parsedOptions.channelCountMode = conversions['DOMString'](options.channelCountMode, {
+          context: `Failed to construct 'ScriptProcessorNode': Failed to read the 'channelCount' property from ScriptProcessorNodeOptions: The provided value '${options.channelCountMode}'`,
+        });
+      }
+
+      if (options && options.channelInterpretation !== undefined) {
+        parsedOptions.channelInterpretation = conversions['DOMString'](options.channelInterpretation, {
+          context: `Failed to construct 'ScriptProcessorNode': Failed to read the 'channelInterpretation' property from ScriptProcessorNodeOptions: The provided value '${options.channelInterpretation}'`,
+        });
+      }
+
+      let napiObj;
+
+      try {
+        napiObj = new nativeBinding.ScriptProcessorNode(context[kNapiObj], parsedOptions);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+
+      super(context, {
+        [kNapiObj]: napiObj,
+      });
+
+      this[kNapiObj][kOnAudioProcess] = (err, rawEvent) => {
+        if (typeof rawEvent !== 'object' && !('type' in rawEvent)) {
+          throw new TypeError('Invalid [kOnStateChange] Invocation: rawEvent should have a type property');
+        }
+
+        const audioProcessingEventInit = {
+          playbackTime: rawEvent.playbackTime,
+          inputBuffer: new jsExport.AudioBuffer({ [kNapiObj]: rawEvent.inputBuffer }),
+          outputBuffer: new jsExport.AudioBuffer({ [kNapiObj]: rawEvent.outputBuffer }),
+        };
+
+        const event = new jsExport.AudioProcessingEvent('audioprocess', audioProcessingEventInit);
+        propagateEvent(this, event);
+      };
+
+      this[kNapiObj].listen_to_events();
+    }
+
+    get bufferSize() {
+      if (!(this instanceof ScriptProcessorNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'ScriptProcessorNode\'');
+      }
+
+      return this[kNapiObj].bufferSize;
+    }
+
+    get onaudioprocess() {
+      if (!(this instanceof ScriptProcessorNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'ScriptProcessorNode\'');
+      }
+
+      return this.#onaudioprocess;
+    }
+
+    set onaudioprocess(value) {
+      if (!(this instanceof ScriptProcessorNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'ScriptProcessorNode\'');
+      }
+
+      if (isFunction(value) || value === null) {
+        this.#onaudioprocess = value;
+      }
+    }
+  }
+
+  Object.defineProperties(ScriptProcessorNode, {
+    length: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 0,
+    },
+  });
+
+  Object.defineProperties(ScriptProcessorNode.prototype, {
+    [Symbol.toStringTag]: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 'ScriptProcessorNode',
+    },
+    bufferSize: kEnumerableProperty,
+    onaudioprocess: kEnumerableProperty,
+
+  });
+
+  return ScriptProcessorNode;
+};

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

package/js/WaveShaperNode.js

@@ -17,63 +17,178 @@
 // -------------------------------------------------------------------------- //
 // -------------------------------------------------------------------------- //
 
-// 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 = (jsExport, nativeBinding) => {
+  class WaveShaperNode extends AudioNode {
 
+    constructor(context, options) {
 
-module.exports = (NativeWaveShaperNode) => {
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to construct 'WaveShaperNode': 1 argument required, but only ${arguments.length} present`);
+      }
 
-  const EventTarget = EventTargetMixin(NativeWaveShaperNode);
-  const AudioNode = AudioNodeMixin(EventTarget);
+      if (!(context instanceof jsExport.BaseAudioContext)) {
+        throw new TypeError(`Failed to construct 'WaveShaperNode': argument 1 is not of type BaseAudioContext`);
+      }
 
-  class WaveShaperNode extends AudioNode {
-    constructor(context, options) {
-      if (options !== undefined && typeof options !== 'object') {
-        throw new TypeError("Failed to construct 'WaveShaperNode': argument 2 is not of type 'WaveShaperOptions'")
+      // parsed version of the option to be passed to NAPI
+      const parsedOptions = {};
+
+      if (options && typeof options !== 'object') {
+        throw new TypeError('Failed to construct \'WaveShaperNode\': argument 2 is not of type \'WaveShaperOptions\'');
       }
 
-      super(context, options);
+      if (options && options.curve !== undefined) {
+        try {
+          parsedOptions.curve = toSanitizedSequence(options.curve, Float32Array);
+        } catch (err) {
+          throw new TypeError(`Failed to construct 'WaveShaperNode': Failed to read the 'curve' property from WaveShaperOptions: The provided value ${err.message}`);
+        }
+      } else {
+        parsedOptions.curve = null;
+      }
 
-    }
+      if (options && options.oversample !== undefined) {
+        if (!['none', '2x', '4x'].includes(options.oversample)) {
+          throw new TypeError(`Failed to construct 'WaveShaperNode': Failed to read the 'oversample' property from WaveShaperOptions: The provided value '${options.oversample}' is not a valid enum value of type OverSampleType`);
+        }
 
-    // getters
+        parsedOptions.oversample = conversions['DOMString'](options.oversample, {
+          context: `Failed to construct 'WaveShaperNode': Failed to read the 'oversample' property from WaveShaperOptions: The provided value '${options.oversample}'`,
+        });
+      } else {
+        parsedOptions.oversample = 'none';
+      }
 
-    get curve() {
-      return super.curve;
-    }
+      if (options && options.channelCount !== undefined) {
+        parsedOptions.channelCount = conversions['unsigned long'](options.channelCount, {
+          enforceRange: true,
+          context: `Failed to construct 'WaveShaperNode': Failed to read the 'channelCount' property from WaveShaperOptions: The provided value '${options.channelCount}'`,
+        });
+      }
+
+      if (options && options.channelCountMode !== undefined) {
+        parsedOptions.channelCountMode = conversions['DOMString'](options.channelCountMode, {
+          context: `Failed to construct 'WaveShaperNode': Failed to read the 'channelCount' property from WaveShaperOptions: The provided value '${options.channelCountMode}'`,
+        });
+      }
+
+      if (options && options.channelInterpretation !== undefined) {
+        parsedOptions.channelInterpretation = conversions['DOMString'](options.channelInterpretation, {
+          context: `Failed to construct 'WaveShaperNode': Failed to read the 'channelInterpretation' property from WaveShaperOptions: The provided value '${options.channelInterpretation}'`,
+        });
+      }
+
+      let napiObj;
+
+      try {
+        napiObj = new nativeBinding.WaveShaperNode(context[kNapiObj], parsedOptions);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+
+      super(context, {
+        [kNapiObj]: napiObj,
+      });
 
-    get oversample() {
-      return super.oversample;
     }
 
-    // setters
+    get curve() {
+      if (!(this instanceof WaveShaperNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'WaveShaperNode\'');
+      }
+
+      return this[kNapiObj].curve;
+    }
 
     set curve(value) {
+      if (!(this instanceof WaveShaperNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'WaveShaperNode\'');
+      }
+
+      if (value === null) {
+        console.warn('Setting the \'curve\' property on \'WaveShaperNode\' to \'null\' is not supported yet');
+        return;
+      } else if (!(value instanceof Float32Array)) {
+        throw new TypeError('Failed to set the \'curve\' property on \'WaveShaperNode\': Value is not a valid \'Float32Array\' value');
+      }
+
       try {
-        super.curve = value;
+        this[kNapiObj].curve = value;
       } catch (err) {
         throwSanitizedError(err);
       }
     }
 
+    get oversample() {
+      if (!(this instanceof WaveShaperNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'WaveShaperNode\'');
+      }
+
+      return this[kNapiObj].oversample;
+    }
+
     set oversample(value) {
+      if (!(this instanceof WaveShaperNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'WaveShaperNode\'');
+      }
+
+      if (!['none', '2x', '4x'].includes(value)) {
+        console.warn(`Failed to set the 'oversample' property on 'WaveShaperNode': Value '${value}' is not a valid 'OverSampleType' enum value`);
+        return;
+      }
+
       try {
-        super.oversample = value;
+        this[kNapiObj].oversample = value;
       } catch (err) {
         throwSanitizedError(err);
       }
     }
 
-    // methods
-    
   }
 
+  Object.defineProperties(WaveShaperNode, {
+    length: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 1,
+    },
+  });
+
+  Object.defineProperties(WaveShaperNode.prototype, {
+    [Symbol.toStringTag]: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 'WaveShaperNode',
+    },
+
+    curve: kEnumerableProperty,
+    oversample: kEnumerableProperty,
+
+  });
+
   return WaveShaperNode;
 };
-
-
-  

package/js/lib/cast.js

@@ -0,0 +1,19 @@
+exports.toSanitizedSequence = function toSanitizedSequence(data, targetCtor) {
+  if (
+    (data.buffer && data.buffer instanceof ArrayBuffer)
+    || Array.isArray(data)
+  ) {
+    data = new targetCtor(data);
+  } else {
+    throw new TypeError(`cannot be converted to sequence of ${targetCtor}`);
+  }
+
+  // check it only contains finite values
+  for (let i = 0; i < data.length; i++) {
+    if (!Number.isFinite(data[i])) {
+      throw new TypeError(`should contain only finite values`);
+    }
+  }
+
+  return data;
+}