node-web-audio-api 0.18.0 → 0.19.0

package/js/ChannelMergerNode.js

@@ -17,39 +17,113 @@
 // -------------------------------------------------------------------------- //
 // -------------------------------------------------------------------------- //
 
-// 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 = (NativeChannelMergerNode) => {
-
-  const EventTarget = EventTargetMixin(NativeChannelMergerNode);
-  const AudioNode = AudioNodeMixin(EventTarget);
-
+module.exports = (jsExport, nativeBinding) => {
   class ChannelMergerNode extends AudioNode {
+
     constructor(context, options) {
-      if (options !== undefined && typeof options !== 'object') {
-        throw new TypeError("Failed to construct 'ChannelMergerNode': argument 2 is not of type 'ChannelMergerOptions'")
+
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to construct 'ChannelMergerNode': 1 argument required, but only ${arguments.length} present`);
       }
 
-      super(context, options);
+      if (!(context instanceof jsExport.BaseAudioContext)) {
+        throw new TypeError(`Failed to construct 'ChannelMergerNode': argument 1 is not of type BaseAudioContext`);
+      }
 
-    }
+      // parsed version of the option to be passed to NAPI
+      const parsedOptions = {};
 
-    // getters
+      if (options && typeof options !== 'object') {
+        throw new TypeError('Failed to construct \'ChannelMergerNode\': argument 2 is not of type \'ChannelMergerOptions\'');
+      }
 
-    // setters
+      if (options && options.numberOfInputs !== undefined) {
+        parsedOptions.numberOfInputs = conversions['unsigned long'](options.numberOfInputs, {
+          enforceRange: true,
+          context: `Failed to construct 'ChannelMergerNode': Failed to read the 'numberOfInputs' property from ChannelMergerOptions: The provided value (${options.numberOfInputs}})`,
+        });
+      } else {
+        parsedOptions.numberOfInputs = 6;
+      }
+
+      if (options && options.channelCount !== undefined) {
+        parsedOptions.channelCount = conversions['unsigned long'](options.channelCount, {
+          enforceRange: true,
+          context: `Failed to construct 'ChannelMergerNode': Failed to read the 'channelCount' property from ChannelMergerOptions: The provided value '${options.channelCount}'`,
+        });
+      }
+
+      if (options && options.channelCountMode !== undefined) {
+        parsedOptions.channelCountMode = conversions['DOMString'](options.channelCountMode, {
+          context: `Failed to construct 'ChannelMergerNode': Failed to read the 'channelCount' property from ChannelMergerOptions: The provided value '${options.channelCountMode}'`,
+        });
+      }
+
+      if (options && options.channelInterpretation !== undefined) {
+        parsedOptions.channelInterpretation = conversions['DOMString'](options.channelInterpretation, {
+          context: `Failed to construct 'ChannelMergerNode': Failed to read the 'channelInterpretation' property from ChannelMergerOptions: The provided value '${options.channelInterpretation}'`,
+        });
+      }
+
+      let napiObj;
+
+      try {
+        napiObj = new nativeBinding.ChannelMergerNode(context[kNapiObj], parsedOptions);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+
+      super(context, {
+        [kNapiObj]: napiObj,
+      });
+
+    }
 
-    // methods
-    
   }
 
-  return ChannelMergerNode;
-};
+  Object.defineProperties(ChannelMergerNode, {
+    length: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 1,
+    },
+  });
 
+  Object.defineProperties(ChannelMergerNode.prototype, {
+    [Symbol.toStringTag]: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 'ChannelMergerNode',
+    },
 
-  
+  });
+
+  return ChannelMergerNode;
+};

package/js/ChannelSplitterNode.js

@@ -17,39 +17,113 @@
 // -------------------------------------------------------------------------- //
 // -------------------------------------------------------------------------- //
 
-// 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 = (NativeChannelSplitterNode) => {
-
-  const EventTarget = EventTargetMixin(NativeChannelSplitterNode);
-  const AudioNode = AudioNodeMixin(EventTarget);
-
+module.exports = (jsExport, nativeBinding) => {
   class ChannelSplitterNode extends AudioNode {
+
     constructor(context, options) {
-      if (options !== undefined && typeof options !== 'object') {
-        throw new TypeError("Failed to construct 'ChannelSplitterNode': argument 2 is not of type 'ChannelSplitterOptions'")
+
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to construct 'ChannelSplitterNode': 1 argument required, but only ${arguments.length} present`);
       }
 
-      super(context, options);
+      if (!(context instanceof jsExport.BaseAudioContext)) {
+        throw new TypeError(`Failed to construct 'ChannelSplitterNode': argument 1 is not of type BaseAudioContext`);
+      }
 
-    }
+      // parsed version of the option to be passed to NAPI
+      const parsedOptions = {};
 
-    // getters
+      if (options && typeof options !== 'object') {
+        throw new TypeError('Failed to construct \'ChannelSplitterNode\': argument 2 is not of type \'ChannelSplitterOptions\'');
+      }
 
-    // setters
+      if (options && options.numberOfOutputs !== undefined) {
+        parsedOptions.numberOfOutputs = conversions['unsigned long'](options.numberOfOutputs, {
+          enforceRange: true,
+          context: `Failed to construct 'ChannelSplitterNode': Failed to read the 'numberOfOutputs' property from ChannelSplitterOptions: The provided value (${options.numberOfOutputs}})`,
+        });
+      } else {
+        parsedOptions.numberOfOutputs = 6;
+      }
+
+      if (options && options.channelCount !== undefined) {
+        parsedOptions.channelCount = conversions['unsigned long'](options.channelCount, {
+          enforceRange: true,
+          context: `Failed to construct 'ChannelSplitterNode': Failed to read the 'channelCount' property from ChannelSplitterOptions: The provided value '${options.channelCount}'`,
+        });
+      }
+
+      if (options && options.channelCountMode !== undefined) {
+        parsedOptions.channelCountMode = conversions['DOMString'](options.channelCountMode, {
+          context: `Failed to construct 'ChannelSplitterNode': Failed to read the 'channelCount' property from ChannelSplitterOptions: The provided value '${options.channelCountMode}'`,
+        });
+      }
+
+      if (options && options.channelInterpretation !== undefined) {
+        parsedOptions.channelInterpretation = conversions['DOMString'](options.channelInterpretation, {
+          context: `Failed to construct 'ChannelSplitterNode': Failed to read the 'channelInterpretation' property from ChannelSplitterOptions: The provided value '${options.channelInterpretation}'`,
+        });
+      }
+
+      let napiObj;
+
+      try {
+        napiObj = new nativeBinding.ChannelSplitterNode(context[kNapiObj], parsedOptions);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+
+      super(context, {
+        [kNapiObj]: napiObj,
+      });
+
+    }
 
-    // methods
-    
   }
 
-  return ChannelSplitterNode;
-};
+  Object.defineProperties(ChannelSplitterNode, {
+    length: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 1,
+    },
+  });
 
+  Object.defineProperties(ChannelSplitterNode.prototype, {
+    [Symbol.toStringTag]: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 'ChannelSplitterNode',
+    },
 
-  
+  });
+
+  return ChannelSplitterNode;
+};

package/js/ConstantSourceNode.js

@@ -17,44 +17,110 @@
 // -------------------------------------------------------------------------- //
 // -------------------------------------------------------------------------- //
 
-// 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');
+const {
+  bridgeEventTarget,
+} = require('./lib/events.js');
+/* eslint-enable no-unused-vars */
 
-module.exports = (NativeConstantSourceNode) => {
-
-  const EventTarget = EventTargetMixin(NativeConstantSourceNode, ['ended']);
-  const AudioNode = AudioNodeMixin(EventTarget);
-  const AudioScheduledSourceNode = AudioScheduledSourceNodeMixin(AudioNode);
+const AudioScheduledSourceNode = require('./AudioScheduledSourceNode.js');
 
+module.exports = (jsExport, nativeBinding) => {
   class ConstantSourceNode extends AudioScheduledSourceNode {
+
+    #offset = null;
+
     constructor(context, options) {
-      if (options !== undefined && typeof options !== 'object') {
-        throw new TypeError("Failed to construct 'ConstantSourceNode': argument 2 is not of type 'ConstantSourceOptions'")
+
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to construct 'ConstantSourceNode': 1 argument required, but only ${arguments.length} present`);
+      }
+
+      if (!(context instanceof jsExport.BaseAudioContext)) {
+        throw new TypeError(`Failed to construct 'ConstantSourceNode': 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 \'ConstantSourceNode\': argument 2 is not of type \'ConstantSourceOptions\'');
+      }
+
+      if (options && options.offset !== undefined) {
+        parsedOptions.offset = conversions['float'](options.offset, {
+          context: `Failed to construct 'ConstantSourceNode': Failed to read the 'offset' property from ConstantSourceOptions: The provided value (${options.offset}})`,
+        });
+      } else {
+        parsedOptions.offset = 1;
       }
 
-      super(context, options);
-      // EventTargetMixin has been called so EventTargetMixin[kDispatchEvent] is
-      // bound to this, then we can safely finalize event target initialization
-      super.__initEventTarget__();
+      let napiObj;
 
-      this.offset = new AudioParam(this.offset);
+      try {
+        napiObj = new nativeBinding.ConstantSourceNode(context[kNapiObj], parsedOptions);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+
+      super(context, {
+        [kNapiObj]: napiObj,
+      });
+
+      // Bridge Rust native event to Node EventTarget
+      bridgeEventTarget(this);
+
+      this.#offset = new jsExport.AudioParam({
+        [kNapiObj]: this[kNapiObj].offset,
+      });
     }
 
-    // getters
+    get offset() {
+      if (!(this instanceof ConstantSourceNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'ConstantSourceNode\'');
+      }
 
-    // setters
+      return this.#offset;
+    }
 
-    // methods
-    
   }
 
-  return ConstantSourceNode;
-};
+  Object.defineProperties(ConstantSourceNode, {
+    length: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 1,
+    },
+  });
+
+  Object.defineProperties(ConstantSourceNode.prototype, {
+    [Symbol.toStringTag]: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 'ConstantSourceNode',
+    },
+    offset: kEnumerableProperty,
 
+  });
 
-  
+  return ConstantSourceNode;
+};

package/js/ConvolverNode.js

@@ -17,63 +17,195 @@
 // -------------------------------------------------------------------------- //
 // -------------------------------------------------------------------------- //
 
-// 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 = (jsExport, nativeBinding) => {
+  class ConvolverNode extends AudioNode {
 
+    constructor(context, options) {
 
-module.exports = (NativeConvolverNode) => {
+      if (arguments.length < 1) {
+        throw new TypeError(`Failed to construct 'ConvolverNode': 1 argument required, but only ${arguments.length} present`);
+      }
 
-  const EventTarget = EventTargetMixin(NativeConvolverNode);
-  const AudioNode = AudioNodeMixin(EventTarget);
+      if (!(context instanceof jsExport.BaseAudioContext)) {
+        throw new TypeError(`Failed to construct 'ConvolverNode': argument 1 is not of type BaseAudioContext`);
+      }
 
-  class ConvolverNode extends AudioNode {
-    constructor(context, options) {
-      if (options !== undefined && typeof options !== 'object') {
-        throw new TypeError("Failed to construct 'ConvolverNode': argument 2 is not of type 'ConvolverOptions'")
+      // parsed version of the option to be passed to NAPI
+      const parsedOptions = {};
+
+      if (options && typeof options !== 'object') {
+        throw new TypeError('Failed to construct \'ConvolverNode\': argument 2 is not of type \'ConvolverOptions\'');
       }
 
-      super(context, options);
+      if (options && options.buffer !== undefined) {
+        if (options.buffer !== null) {
+          if (!(options.buffer instanceof jsExport.AudioBuffer)) {
+            throw new TypeError('Failed to construct \'ConvolverNode\': Failed to read the \'buffer\' property from ConvolverOptions: The provided value cannot be converted to \'AudioBuffer\'');
+          }
+
+          // unwrap napi audio buffer
+          parsedOptions.buffer = options.buffer[kNapiObj];
+        } else {
+          parsedOptions.buffer = null;
+        }
+      } else {
+        parsedOptions.buffer = null;
+      }
 
-    }
+      if (options && options.disableNormalization !== undefined) {
+        parsedOptions.disableNormalization = conversions['boolean'](options.disableNormalization, {
+          context: `Failed to construct 'ConvolverNode': Failed to read the 'disableNormalization' property from ConvolverOptions: The provided value (${options.disableNormalization}})`,
+        });
+      } else {
+        parsedOptions.disableNormalization = false;
+      }
 
-    // getters
+      if (options && options.channelCount !== undefined) {
+        parsedOptions.channelCount = conversions['unsigned long'](options.channelCount, {
+          enforceRange: true,
+          context: `Failed to construct 'ConvolverNode': Failed to read the 'channelCount' property from ConvolverOptions: The provided value '${options.channelCount}'`,
+        });
+      }
 
-    get buffer() {
-      return super.buffer;
-    }
+      if (options && options.channelCountMode !== undefined) {
+        parsedOptions.channelCountMode = conversions['DOMString'](options.channelCountMode, {
+          context: `Failed to construct 'ConvolverNode': Failed to read the 'channelCount' property from ConvolverOptions: The provided value '${options.channelCountMode}'`,
+        });
+      }
+
+      if (options && options.channelInterpretation !== undefined) {
+        parsedOptions.channelInterpretation = conversions['DOMString'](options.channelInterpretation, {
+          context: `Failed to construct 'ConvolverNode': Failed to read the 'channelInterpretation' property from ConvolverOptions: The provided value '${options.channelInterpretation}'`,
+        });
+      }
+
+      let napiObj;
+
+      try {
+        napiObj = new nativeBinding.ConvolverNode(context[kNapiObj], parsedOptions);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+
+      super(context, {
+        [kNapiObj]: napiObj,
+      });
+
+      // keep the wrapped AudioBuffer around
+      Object.defineProperty(this, kAudioBuffer, {
+        __proto__: null,
+        enumerable: false,
+        writable: true,
+        value: null,
+      });
+
+      if (options && options.buffer !== undefined) {
+        this[kAudioBuffer] = options.buffer;
+      }
 
-    get normalize() {
-      return super.normalize;
     }
 
-    // setters
+    get buffer() {
+      if (!(this instanceof ConvolverNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'ConvolverNode\'');
+      }
+
+      return this[kAudioBuffer];
+    }
 
     set buffer(value) {
+      if (!(this instanceof ConvolverNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'ConvolverNode\'');
+      }
+
+      if (value === null) {
+        console.warn('Setting the \'buffer\' property on \'ConvolverNode\' to \'null\' is not supported yet');
+        return;
+      } else if (!(kNapiObj in value)) {
+        throw new TypeError('Failed to set the \'buffer\' property on \'ConvolverNode\': Failed to convert value to \'AudioBuffer\'');
+      }
+
       try {
-        super.buffer = value;
+        this[kNapiObj].buffer = value[kNapiObj];
       } catch (err) {
         throwSanitizedError(err);
       }
+
+      this[kAudioBuffer] = value;
+    }
+
+    get normalize() {
+      if (!(this instanceof ConvolverNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'ConvolverNode\'');
+      }
+
+      return this[kNapiObj].normalize;
     }
 
     set normalize(value) {
+      if (!(this instanceof ConvolverNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'ConvolverNode\'');
+      }
+
+      value = conversions['boolean'](value, {
+        context: `Failed to set the 'normalize' property on 'ConvolverNode': Value`,
+      });
+
       try {
-        super.normalize = value;
+        this[kNapiObj].normalize = value;
       } catch (err) {
         throwSanitizedError(err);
       }
     }
 
-    // methods
-    
   }
 
+  Object.defineProperties(ConvolverNode, {
+    length: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 1,
+    },
+  });
+
+  Object.defineProperties(ConvolverNode.prototype, {
+    [Symbol.toStringTag]: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 'ConvolverNode',
+    },
+
+    buffer: kEnumerableProperty,
+    normalize: kEnumerableProperty,
+
+  });
+
   return ConvolverNode;
 };
-
-
-