node-web-audio-api 0.15.0 → 0.17.0

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## v0.17.0 (08/03/2024)
+
+- Update upstream crate to [1.0.0-rc.2](https://github.com/orottier/web-audio-api-rs/blob/main/CHANGELOG.md#version-100-rc2-2024-03-07)
+- Improve compliance and error handling
+
+## v0.16.0 (09/02/2024)
+
+- Update upstream create to [v0.42.0](https://github.com/orottier/web-audio-api-rs/blob/main/CHANGELOG.md#version-0420-2024-02-05)
+- Improve Error handling
+- Add channelCounnt to media constraints
+
 ## v0.15.0 (16/01/2024)
 
 - Update upstream create to [v0.41.1](https://github.com/orottier/web-audio-api-rs/blob/main/CHANGELOG.md#version-0411-2024-01-11)

package/index.mjs

@@ -27,6 +27,8 @@ const nativeModule = require('./index.cjs');
 export const {
   AudioContext,
   OfflineAudioContext,
+  AudioParam,
+  AudioDestinationNode,
   AudioBuffer,
   PeriodicWave,
   // manually written nodes

package/js/AnalyserNode.js

@@ -32,6 +32,10 @@ module.exports = (NativeAnalyserNode) => {
 
   class AnalyserNode extends AudioNode {
     constructor(context, options) {
+      if (options !== undefined && typeof options !== 'object') {
+        throw new TypeError("Failed to construct 'AnalyserNode': argument 2 is not of type 'AnalyserOptions'")
+      }
+
       super(context, options);
 
     }

package/js/AudioBufferSourceNode.js

@@ -33,6 +33,10 @@ module.exports = (NativeAudioBufferSourceNode) => {
 
   class AudioBufferSourceNode extends AudioScheduledSourceNode {
     constructor(context, options) {
+      if (options !== undefined && typeof options !== 'object') {
+        throw new TypeError("Failed to construct 'AudioBufferSourceNode': argument 2 is not of type 'AudioBufferSourceOptions'")
+      }
+
       super(context, options);
       // EventTargetMixin has been called so EventTargetMixin[kDispatchEvent] is
       // bound to this, then we can safely finalize event target initialization

package/js/AudioDestinationNode.js

@@ -0,0 +1,111 @@
+// @note - This should be reviewed (but how...?)
+//
+// We can't really use the AudioNode mixin because we need to wrap
+// the native destination instance.
+
+const { throwSanitizedError } = require('./lib/errors.js');
+const { AudioParam, kNativeAudioParam } = require('./AudioParam.js');
+const kNativeAudioDestinationNode = Symbol('node-web-audio-api:audio-destination-node');
+
+class AudioDestinationNode {
+  constructor(nativeAudioDestinationNode) {
+    this[kNativeAudioDestinationNode] = nativeAudioDestinationNode;
+  }
+
+  // AudioNode interface
+  get context() {
+    return this[kNativeAudioDestinationNode].context;
+  }
+
+  get numberOfInputs() {
+    return this[kNativeAudioDestinationNode].numberOfInputs;
+  }
+
+  get numberOfOutputs() {
+    return this[kNativeAudioDestinationNode].numberOfOutputs;
+  }
+
+  get channelCount() {
+    return this[kNativeAudioDestinationNode].channelCount;
+  }
+
+  get channelCountMode() {
+    return this[kNativeAudioDestinationNode].channelCountMode;
+  }
+
+  get channelInterpretation() {
+    return this[kNativeAudioDestinationNode].channelInterpretation;
+  }
+
+  // setters
+
+  set channelCount(value) {
+    try {
+      this[kNativeAudioDestinationNode].channelCount = value;
+    } catch (err) {
+      throwSanitizedError(err);
+    }
+  }
+
+  set channelCountMode(value) {
+    try {
+      this[kNativeAudioDestinationNode].channelCountMode = value;
+    } catch (err) {
+      throwSanitizedError(err);
+    }
+  }
+
+  set channelInterpretation(value) {
+    try {
+      this[kNativeAudioDestinationNode].channelInterpretation = value;
+    } catch (err) {
+      throwSanitizedError(err);
+    }
+  }
+
+  // methods - connect / disconnect
+
+  connect(...args) {
+    // unwrap raw audio params from facade
+    if (args[0] instanceof AudioParam) {
+      args[0] = args[0][kNativeAudioParam];
+    }
+
+    // unwrap raw audio destination from facade
+    if (args[0] instanceof AudioDestinationNode) {
+      args[0] = args[0][kNativeAudioDestinationNode];
+    }
+
+    try {
+      return this[kNativeAudioDestinationNode].connect(...args);
+    } catch (err) {
+      throwSanitizedError(err);
+    }
+  }
+
+  disconnect(...args) {
+    // unwrap raw audio params from facade
+    if (args[0] instanceof AudioParam) {
+      args[0] = args[0][kNativeAudioParam];
+    }
+
+    // unwrap raw audio destination from facade
+    if (args[0] instanceof AudioDestinationNode) {
+      args[0] = args[0][kNativeAudioDestinationNode];
+    }
+
+    try {
+      return this[kNativeAudioDestinationNode].disconnect(...args);
+    } catch (err) {
+      throwSanitizedError(err);
+    }
+  }
+
+  get maxChannelCount() {
+    return this[kNativeAudioDestinationNode].maxChannelCount;
+  }
+}
+
+module.exports.kNativeAudioDestinationNode = kNativeAudioDestinationNode;
+module.exports.AudioDestinationNode = AudioDestinationNode;
+

package/js/AudioNode.mixin.js

@@ -20,6 +20,7 @@
 const { throwSanitizedError } = require('./lib/errors.js');
 
 const { AudioParam, kNativeAudioParam } = require('./AudioParam.js');
+const { AudioDestinationNode, kNativeAudioDestinationNode } = require('./AudioDestinationNode.js');
 
 module.exports = (superclass) => {
   class AudioNode extends superclass {
@@ -93,6 +94,11 @@ module.exports = (superclass) => {
         args[0] = args[0][kNativeAudioParam];
       }
 
+      // unwrap raw audio destination from facade
+      if (args[0] instanceof AudioDestinationNode) {
+        args[0] = args[0][kNativeAudioDestinationNode];
+      }
+
       try {
         return super.connect(...args);
       } catch (err) {
@@ -106,6 +112,11 @@ module.exports = (superclass) => {
         args[0] = args[0][kNativeAudioParam];
       }
 
+      // unwrap raw audio destination from facade
+      if (args[0] instanceof AudioDestinationNode) {
+        args[0] = args[0][kNativeAudioDestinationNode];
+      }
+
       try {
         return super.disconnect(...args);
       } catch (err) {

package/js/BaseAudioContext.mixin.js

@@ -17,6 +17,7 @@
 // -------------------------------------------------------------------------- //
 // -------------------------------------------------------------------------- //
 
+const { AudioDestinationNode } = require('./AudioDestinationNode.js');
 const { isFunction } = require('./lib/utils.js');
 
 module.exports = (superclass, bindings) => {
@@ -36,9 +37,16 @@ module.exports = (superclass, bindings) => {
     PannerNode,
     StereoPannerNode,
     WaveShaperNode,
+    PeriodicWave,
   } = bindings;
 
   class BaseAudioContext extends superclass {
+    constructor(...args) {
+      super(...args);
+
+      this.destination = new AudioDestinationNode(this.destination);
+    }
+
     // 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
@@ -65,6 +73,10 @@ module.exports = (superclass, bindings) => {
       }
     }
 
+    createPeriodicWave(real, imag) {
+      return new PeriodicWave(this, { real, imag });
+    }
+
     // --------------------------------------------------------------------
     // Factory Methods (use the patched AudioNodes)
     // --------------------------------------------------------------------

package/js/BiquadFilterNode.js

@@ -32,6 +32,10 @@ module.exports = (NativeBiquadFilterNode) => {
 
   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'")
+      }
+
       super(context, options);
 
       this.frequency = new AudioParam(this.frequency);

package/js/ChannelMergerNode.js

@@ -32,6 +32,10 @@ module.exports = (NativeChannelMergerNode) => {
 
   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'")
+      }
+
       super(context, options);
 
     }

package/js/ChannelSplitterNode.js

@@ -32,6 +32,10 @@ module.exports = (NativeChannelSplitterNode) => {
 
   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'")
+      }
+
       super(context, options);
 
     }

package/js/ConstantSourceNode.js

@@ -33,6 +33,10 @@ module.exports = (NativeConstantSourceNode) => {
 
   class ConstantSourceNode extends AudioScheduledSourceNode {
     constructor(context, options) {
+      if (options !== undefined && typeof options !== 'object') {
+        throw new TypeError("Failed to construct 'ConstantSourceNode': argument 2 is not of type 'ConstantSourceOptions'")
+      }
+
       super(context, options);
       // EventTargetMixin has been called so EventTargetMixin[kDispatchEvent] is
       // bound to this, then we can safely finalize event target initialization

package/js/ConvolverNode.js

@@ -32,6 +32,10 @@ module.exports = (NativeConvolverNode) => {
 
   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'")
+      }
+
       super(context, options);
 
     }

package/js/DelayNode.js

@@ -32,6 +32,10 @@ module.exports = (NativeDelayNode) => {
 
   class DelayNode extends AudioNode {
     constructor(context, options) {
+      if (options !== undefined && typeof options !== 'object') {
+        throw new TypeError("Failed to construct 'DelayNode': argument 2 is not of type 'DelayOptions'")
+      }
+
       super(context, options);
 
       this.delayTime = new AudioParam(this.delayTime);

package/js/DynamicsCompressorNode.js

@@ -32,6 +32,10 @@ module.exports = (NativeDynamicsCompressorNode) => {
 
   class DynamicsCompressorNode extends AudioNode {
     constructor(context, options) {
+      if (options !== undefined && typeof options !== 'object') {
+        throw new TypeError("Failed to construct 'DynamicsCompressorNode': argument 2 is not of type 'DynamicsCompressorOptions'")
+      }
+
       super(context, options);
 
       this.threshold = new AudioParam(this.threshold);

package/js/EventTarget.mixin.js

@@ -54,6 +54,7 @@ module.exports = (superclass, eventTypes = []) => class EventTarget extends supe
     // event.target = this;
     // event.currentTarget = this;
     // event.srcElement = this;
+
     this.dispatchEvent(event);
   }
 };

package/js/GainNode.js

@@ -32,6 +32,10 @@ module.exports = (NativeGainNode) => {
 
   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'")
+      }
+
       super(context, options);
 
       this.gain = new AudioParam(this.gain);

package/js/IIRFilterNode.js

@@ -32,6 +32,10 @@ module.exports = (NativeIIRFilterNode) => {
 
   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'")
+      }
+
       super(context, options);
 
     }

package/js/OfflineAudioContext.js

@@ -1,4 +1,4 @@
-const { NotSupportedError } = require('./lib/errors.js');
+const { nameCodeMap, DOMException } = require('./lib/errors.js');
 const { isPlainObject, isPositiveInt, isPositiveNumber } = require('./lib/utils.js');
 
 module.exports = function patchOfflineAudioContext(bindings) {
@@ -23,21 +23,31 @@ module.exports = function patchOfflineAudioContext(bindings) {
       const [numberOfChannels, length, sampleRate] = args;
 
       if (!isPositiveInt(numberOfChannels)) {
-        throw new NotSupportedError(`Invalid value for numberOfChannels: ${numberOfChannels}`);
+        throw new TypeError(`Invalid value for numberOfChannels: ${numberOfChannels}`);
       } else if (!isPositiveInt(length)) {
-        throw new NotSupportedError(`Invalid value for length: ${length}`);
+        throw new TypeError(`Invalid value for length: ${length}`);
       } else if (!isPositiveNumber(sampleRate)) {
-        throw new NotSupportedError(`Invalid value for sampleRate: ${sampleRate}`);
+        throw new TypeError(`Invalid value for sampleRate: ${sampleRate}`);
       }
 
       super(numberOfChannels, length, sampleRate);
 
-      // @todo - do not init the event target, no way to clean the thread safe
-      // functions for now
-
       // EventTargetMixin has been called so EventTargetMixin[kDispatchEvent] is
       // bound to this, then we can safely finalize event target initialization
-      // super.__initEventTarget__();
+      super.__initEventTarget__();
+    }
+
+    async startRendering() {
+      const renderedBuffer = await super.startRendering();
+
+      // We do this here, so that we can just share the same audioBuffer instance.
+      // This also simplifies code on the rust side as we don't need to deal
+      // with the OfflineAudioCompletionEvent.
+      const event = new Event('complete');
+      event.renderedBuffer = renderedBuffer;
+      this.dispatchEvent(event)
+
+      return renderedBuffer;
     }
   }
 

package/js/OscillatorNode.js

@@ -33,6 +33,10 @@ module.exports = (NativeOscillatorNode) => {
 
   class OscillatorNode extends AudioScheduledSourceNode {
     constructor(context, options) {
+      if (options !== undefined && typeof options !== 'object') {
+        throw new TypeError("Failed to construct 'OscillatorNode': argument 2 is not of type 'OscillatorOptions'")
+      }
+
       super(context, options);
       // EventTargetMixin has been called so EventTargetMixin[kDispatchEvent] is
       // bound to this, then we can safely finalize event target initialization

package/js/PannerNode.js

@@ -32,6 +32,10 @@ module.exports = (NativePannerNode) => {
 
   class PannerNode extends AudioNode {
     constructor(context, options) {
+      if (options !== undefined && typeof options !== 'object') {
+        throw new TypeError("Failed to construct 'PannerNode': argument 2 is not of type 'PannerOptions'")
+      }
+
       super(context, options);
 
       this.positionX = new AudioParam(this.positionX);

package/js/PeriodicWave.js

@@ -0,0 +1,16 @@
+const { throwSanitizedError } = require('./lib/errors.js');
+
+module.exports = (NativePeriodicWave) => {
+  class PeriodicWave extends NativePeriodicWave {
+    constructor(context, options) {
+      try {
+        super(context, options);
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+    }
+  }
+
+  return PeriodicWave;
+};
+

package/js/StereoPannerNode.js

@@ -32,6 +32,10 @@ module.exports = (NativeStereoPannerNode) => {
 
   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'")
+      }
+
       super(context, options);
 
       this.pan = new AudioParam(this.pan);

package/js/WaveShaperNode.js

@@ -32,6 +32,10 @@ module.exports = (NativeWaveShaperNode) => {
 
   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'")
+      }
+
       super(context, options);
 
     }

package/js/lib/errors.js

@@ -4,37 +4,57 @@ const path = require('path');
 const internalPath = path.join('node-web-audio-api', 'js');
 const internalRe = new RegExp(internalPath);
 
-class NotSupportedError extends Error {
-  constructor(message) {
+// 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 = 'NotSupportedError';
-  }
-}
-
-class InvalidStateError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'InvalidStateError';
-  }
-}
 
-class IndexSizeError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'IndexSizeError';
-  }
-}
-
-class InvalidAccessError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'InvalidAccessError';
+    this.name = name;
+    this.code = nameCodeMap[this.name];
   }
 }
 
-exports.NotSupportedError = NotSupportedError;
-exports.InvalidStateError = InvalidStateError;
-exports.IndexSizeError = IndexSizeError;
+exports.DOMException = DOMException;
 
 function overrideStack(originalError, newError) {
   // override previous error message
@@ -60,6 +80,7 @@ exports.throwSanitizedError = function throwSanitizedError(err) {
   //   right: Max
   let originalMessage = err.message;
   originalMessage = originalMessage.replace('assertion `left != right` failed: ', '');
+  originalMessage = originalMessage.replace('assertion `left == right` failed: ', '');
   originalMessage = originalMessage.split(EOL)[0]; // keep only first line
 
   // "Native Errors"
@@ -76,33 +97,33 @@ exports.throwSanitizedError = function throwSanitizedError(err) {
     throw error;
   }
 
-  // "other errors"
+  // DOM Exceptions
   if (originalMessage.startsWith('NotSupportedError')) {
     const msg = originalMessage.replace(/^NotSupportedError - /, '');
-    const error = new NotSupportedError(msg);
+    const error = new DOMException(msg, 'NotSupportedError');
     overrideStack(err, error);
 
     throw error;
   } else  if (originalMessage.startsWith('InvalidStateError')) {
     const msg = originalMessage.replace(/^InvalidStateError - /, '');
-    const error = new InvalidStateError(msg);
+    const error = new DOMException(msg, 'InvalidStateError');
     overrideStack(err, error);
 
     throw error;
   } if (originalMessage.startsWith('IndexSizeError')) {
     const msg = originalMessage.replace(/^IndexSizeError - /, '');
-    const error = new IndexSizeError(msg);
+    const error = new DOMException(msg, 'IndexSizeError');
     overrideStack(err, error);
 
     throw error;
   } if (originalMessage.startsWith('InvalidAccessError')) {
     const msg = originalMessage.replace(/^InvalidAccessError - /, '');
-    const error = new InvalidAccessError(msg);
+    const error = new DOMException(msg, 'InvalidAccessError');
     overrideStack(err, error);
 
     throw error;
   }
 
-  console.warn('[lib/errors.js] Unhandled error type', err.name, err.message);
+  console.warn('[lib/errors.js] Possibly unhandled error type', err.message);
   throw err;
 }

package/js/monkey-patch.js

@@ -38,9 +38,16 @@ module.exports = function monkeyPatch(nativeBinding) {
   nativeBinding.StereoPannerNode = require('./StereoPannerNode.js')(nativeBinding.StereoPannerNode);
   nativeBinding.WaveShaperNode = require('./WaveShaperNode.js')(nativeBinding.WaveShaperNode);
 
+  // @todo - wrap AudioBuffer interface as well
+  nativeBinding.PeriodicWave = require('./PeriodicWave.js')(nativeBinding.PeriodicWave);
+
   nativeBinding.AudioContext = require('./AudioContext.js')(nativeBinding);
   nativeBinding.OfflineAudioContext = require('./OfflineAudioContext.js')(nativeBinding);
 
+  // find a way to make the constructor private
+  nativeBinding.AudioParam = require('./AudioParam.js').AudioParam;
+  nativeBinding.AudioDestinationNode = require('./AudioDestinationNode.js').AudioDestinationNode;
+
   // --------------------------------------------------------------------------
   // Promisify MediaDevices API
   // --------------------------------------------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-web-audio-api",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "author": "Benjamin Matuszewski",
   "description": "Node.js bindings for web-audio-api-rs using napi-rs",
   "exports": {