node-web-audio-api 0.18.0 → 0.19.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/StereoPannerNode.js

@@ -17,40 +17,126 @@
 // -------------------------------------------------------------------------- //
 // -------------------------------------------------------------------------- //
 
-// 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 = (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,181 @@
 // -------------------------------------------------------------------------- //
 // -------------------------------------------------------------------------- //
 
-// 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 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;
+}

package/js/lib/errors.js

@@ -4,58 +4,6 @@ const path = require('path');
 const internalPath = path.join('node-web-audio-api', 'js');
 const internalRe = new RegExp(internalPath);
 
-// from wpt/resources/tesharness.js (line 2226)
-const nameCodeMap = {
-    IndexSizeError: 1,
-    HierarchyRequestError: 3,
-    WrongDocumentError: 4,
-    InvalidCharacterError: 5,
-    NoModificationAllowedError: 7,
-    NotFoundError: 8,
-    NotSupportedError: 9,
-    InUseAttributeError: 10,
-    InvalidStateError: 11,
-    SyntaxError: 12,
-    InvalidModificationError: 13,
-    NamespaceError: 14,
-    InvalidAccessError: 15,
-    TypeMismatchError: 17,
-    SecurityError: 18,
-    NetworkError: 19,
-    AbortError: 20,
-    URLMismatchError: 21,
-    QuotaExceededError: 22,
-    TimeoutError: 23,
-    InvalidNodeTypeError: 24,
-    DataCloneError: 25,
-
-    EncodingError: 0,
-    NotReadableError: 0,
-    UnknownError: 0,
-    ConstraintError: 0,
-    DataError: 0,
-    TransactionInactiveError: 0,
-    ReadOnlyError: 0,
-    VersionError: 0,
-    OperationError: 0,
-    NotAllowedError: 0,
-    OptOutError: 0
-};
-
-exports.nameCodeMap = nameCodeMap;
-
-
-class DOMException extends Error {
-  constructor(message, name) {
-    super(message);
-
-    this.name = name;
-    this.code = nameCodeMap[this.name];
-  }
-}
-
-exports.DOMException = DOMException;
-
 function overrideStack(originalError, newError) {
   // override previous error message
   const stack = originalError.stack.replace(originalError.message, newError.message);
@@ -87,6 +35,7 @@ exports.throwSanitizedError = function throwSanitizedError(err) {
   if (originalMessage.startsWith('TypeError')) {
     const msg = originalMessage.replace(/^TypeError - /, '');
     const error = new TypeError(msg);
+    overrideStack(err, error);
 
     throw error;
   } else if (originalMessage.startsWith('RangeError')) {
@@ -110,20 +59,26 @@ exports.throwSanitizedError = function throwSanitizedError(err) {
     overrideStack(err, error);
 
     throw error;
-  } if (originalMessage.startsWith('IndexSizeError')) {
+  } else if (originalMessage.startsWith('IndexSizeError')) {
     const msg = originalMessage.replace(/^IndexSizeError - /, '');
     const error = new DOMException(msg, 'IndexSizeError');
     overrideStack(err, error);
 
     throw error;
-  } if (originalMessage.startsWith('InvalidAccessError')) {
+  } else if (originalMessage.startsWith('InvalidAccessError')) {
     const msg = originalMessage.replace(/^InvalidAccessError - /, '');
     const error = new DOMException(msg, 'InvalidAccessError');
     overrideStack(err, error);
 
+    throw error;
+  } else if (originalMessage.startsWith('NotFoundError')) {
+    const msg = originalMessage.replace(/^NotFoundError - /, '');
+    const error = new DOMException(msg, 'NotFoundError');
+    overrideStack(err, error);
+
     throw error;
   }
 
-  console.warn('[lib/errors.js] Possibly unhandled error type', err.message);
+  console.warn('[lib/errors.js] Unexpected Rust error', err);
   throw err;
 }

package/js/lib/events.js

@@ -0,0 +1,20 @@
+const { kNapiObj, kDispatchEvent } = require('./symbols.js');
+const { isFunction } = require('./utils.js');
+
+/**
+ * Listen for events from Rust, and bridge them to Node EventTarget paradigm
+ */
+module.exports.bridgeEventTarget = function bridgeEventTarget(jsObj) {
+    // Finalize event registration on Rust side
+  jsObj[kNapiObj][kDispatchEvent] = (err, eventType) => {
+    const event = new Event(eventType);
+    // call attribute first if exists
+    if (isFunction(jsObj[`on${event.type}`])) {
+      jsObj[`on${event.type}`](event);
+    }
+    // then distach to add event listeners
+    jsObj.dispatchEvent(event);
+  }
+  // ask Rust to register `kDispatchEvent` as listener
+  jsObj[kNapiObj].__initEventTarget__();
+}

package/js/lib/symbols.js

@@ -0,0 +1,5 @@
+module.exports.kNapiObj = Symbol('node-web-audio-api:napi-obj');
+module.exports.kAudioBuffer = Symbol('node-web-audio-api:audio-buffer');
+// this needs to be shared with Rust ide
+module.exports.kDispatchEvent = Symbol.for('node-web-audio-api:napi-dispatch-event');
+

package/js/lib/utils.js

@@ -1,16 +1,16 @@
-exports.isPlainObject = function isPlainObject(obj) {
-  return Object.prototype.toString.call(obj) === '[object Object]';
-};
-
-exports.isPositiveInt = function isPositiveInt(n) {
-  return Number.isSafeInteger(n) && 0 < n;
-};
-
-exports.isPositiveNumber = function isPositiveNumber(n) {
-  return Number(n) === n && 0 < n;
-};
-
 exports.isFunction = function isFunction(val) {
   return Object.prototype.toString.call(val) == '[object Function]' ||
     Object.prototype.toString.call(val) == '[object AsyncFunction]';
 };
+
+const kEnumerableProperty = { __proto__: null };
+kEnumerableProperty.enumerable = true;
+Object.freeze(kEnumerableProperty);
+
+exports.kEnumerableProperty = kEnumerableProperty;
+
+const kHiddenProperty = { __proto__: null };
+kHiddenProperty.enumerable = false;
+Object.freeze(kHiddenProperty);
+
+exports.kHiddenProperty = kHiddenProperty;