node-web-audio-api 0.18.0 → 0.19.0

package/js/DelayNode.js

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

package/js/DynamicsCompressorNode.js

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

package/js/GainNode.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 = (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;
+};