node-web-audio-api 0.18.0 → 0.19.0

package/js/AudioParam.js

@@ -17,116 +17,329 @@
 // -------------------------------------------------------------------------- //
 // -------------------------------------------------------------------------- //
 
-const { throwSanitizedError } = require('./lib/errors.js');
+const conversions = require('webidl-conversions');
 
-const kNativeAudioParam = Symbol('node-web-audio-api:audio-param');
+const {
+  toSanitizedSequence,
+} = require('./lib/cast.js');
+const {
+  throwSanitizedError,
+} = require('./lib/errors.js');
+
+const {
+  kEnumerableProperty,
+  kHiddenProperty,
+} = require('./lib/utils.js');
+const {
+  kNapiObj,
+} = require('./lib/symbols.js');
 
 class AudioParam {
-  constructor(nativeAudioParam) {
-    this[kNativeAudioParam] = nativeAudioParam;
+  constructor(options) {
+    // Make constructor "private"
+    if (
+      (typeof options !== 'object') ||
+      !(kNapiObj in options) ||
+      options[kNapiObj]['Symbol.toStringTag'] !== 'AudioParam'
+    ) {
+      throw new TypeError('Illegal constructor');
+    }
+
+    Object.defineProperty(this, kNapiObj, {
+      value: options[kNapiObj],
+      ...kHiddenProperty,
+    });
   }
-  // getters
 
   get value() {
-    return this[kNativeAudioParam].value;
+    if (!(this instanceof AudioParam)) {
+      throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioParam\'');
+    }
+
+    return this[kNapiObj].value;
+  }
+
+  set value(value) {
+    if (!(this instanceof AudioParam)) {
+      throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioParam\'');
+    }
+
+    value = conversions['float'](value, {
+      context: `Failed to set the 'value' property on 'AudioParam': The provided float value`,
+    });
+
+    try {
+      this[kNapiObj].value = value;
+    } catch (err) {
+      throwSanitizedError(err);
+    }
   }
 
   get automationRate() {
-    return this[kNativeAudioParam].automationRate;
+    if (!(this instanceof AudioParam)) {
+      throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioParam\'');
+    }
+
+    return this[kNapiObj].automationRate;
+  }
+
+  set automationRate(value) {
+    if (!(this instanceof AudioParam)) {
+      throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioParam\'');
+    }
+
+    if (!['a-rate', 'k-rate'].includes(value)) {
+      console.warn(`Failed to set the 'automationRate' property on 'AudioParam': Value '${value}' is not a valid 'AutomationRate' enum value`);
+      return;
+    }
+
+    try {
+      this[kNapiObj].automationRate = value;
+    } catch (err) {
+      throwSanitizedError(err);
+    }
   }
 
   get defaultValue() {
-    return this[kNativeAudioParam].defaultValue;
+    if (!(this instanceof AudioParam)) {
+      throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioParam\'');
+    }
+
+    return this[kNapiObj].defaultValue;
   }
 
   get minValue() {
-    return this[kNativeAudioParam].minValue;
+    if (!(this instanceof AudioParam)) {
+      throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioParam\'');
+    }
+
+    return this[kNapiObj].minValue;
   }
 
   get maxValue() {
-    return this[kNativeAudioParam].maxValue;
+    if (!(this instanceof AudioParam)) {
+      throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioParam\'');
+    }
+
+    return this[kNapiObj].maxValue;
   }
 
-  // setters
+  setValueAtTime(value, startTime) {
+    if (!(this instanceof AudioParam)) {
+      throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioParam\'');
+    }
 
-  set value(value) {
-    try {
-      this[kNativeAudioParam].value = value;
-    } catch (err) {
-      throwSanitizedError(err);
+    if (arguments.length < 2) {
+      throw new TypeError(`Failed to execute 'setValueAtTime' on 'AudioParam': 2 argument required, but only ${arguments.length} present`);
     }
-  }
 
-  set automationRate(value) {
+    value = conversions['float'](value, {
+      context: `Failed to execute 'setValueAtTime' on 'AudioParam': Parameter 1`,
+    });
+
+    startTime = conversions['double'](startTime, {
+      context: `Failed to execute 'setValueAtTime' on 'AudioParam': Parameter 2`,
+    });
+
     try {
-      this[kNativeAudioParam].automationRate = value;
+      this[kNapiObj].setValueAtTime(value, startTime);
     } catch (err) {
       throwSanitizedError(err);
     }
+
+    return this;
   }
 
-  // methods
+  linearRampToValueAtTime(value, endTime) {
+    if (!(this instanceof AudioParam)) {
+      throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioParam\'');
+    }
+
+    if (arguments.length < 2) {
+      throw new TypeError(`Failed to execute 'linearRampToValueAtTime' on 'AudioParam': 2 argument required, but only ${arguments.length} present`);
+    }
+
+    value = conversions['float'](value, {
+      context: `Failed to execute 'linearRampToValueAtTime' on 'AudioParam': Parameter 1`,
+    });
+
+    endTime = conversions['double'](endTime, {
+      context: `Failed to execute 'linearRampToValueAtTime' on 'AudioParam': Parameter 2`,
+    });
 
-  setValueAtTime(...args) {
     try {
-      return this[kNativeAudioParam].setValueAtTime(...args);
+      this[kNapiObj].linearRampToValueAtTime(value, endTime);
     } catch (err) {
       throwSanitizedError(err);
     }
+
+    return this;
   }
 
-  linearRampToValueAtTime(...args) {
+  exponentialRampToValueAtTime(value, endTime) {
+    if (!(this instanceof AudioParam)) {
+      throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioParam\'');
+    }
+
+    if (arguments.length < 2) {
+      throw new TypeError(`Failed to execute 'exponentialRampToValueAtTime' on 'AudioParam': 2 argument required, but only ${arguments.length} present`);
+    }
+
+    value = conversions['float'](value, {
+      context: `Failed to execute 'exponentialRampToValueAtTime' on 'AudioParam': Parameter 1`,
+    });
+
+    endTime = conversions['double'](endTime, {
+      context: `Failed to execute 'exponentialRampToValueAtTime' on 'AudioParam': Parameter 2`,
+    });
+
     try {
-      return this[kNativeAudioParam].linearRampToValueAtTime(...args);
+      this[kNapiObj].exponentialRampToValueAtTime(value, endTime);
     } catch (err) {
       throwSanitizedError(err);
     }
+
+    return this;
   }
 
-  exponentialRampToValueAtTime(...args) {
+  setTargetAtTime(target, startTime, timeConstant) {
+    if (!(this instanceof AudioParam)) {
+      throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioParam\'');
+    }
+
+    if (arguments.length < 3) {
+      throw new TypeError(`Failed to execute 'setTargetAtTime' on 'AudioParam': 3 argument required, but only ${arguments.length} present`);
+    }
+
+    target = conversions['float'](target, {
+      context: `Failed to execute 'setTargetAtTime' on 'AudioParam': Parameter 1`,
+    });
+
+    startTime = conversions['double'](startTime, {
+      context: `Failed to execute 'setTargetAtTime' on 'AudioParam': Parameter 2`,
+    });
+
+    timeConstant = conversions['float'](timeConstant, {
+      context: `Failed to execute 'setTargetAtTime' on 'AudioParam': Parameter 3`,
+    });
+
     try {
-      return this[kNativeAudioParam].exponentialRampToValueAtTime(...args);
+      this[kNapiObj].setTargetAtTime(target, startTime, timeConstant);
     } catch (err) {
       throwSanitizedError(err);
     }
+
+    return this;
   }
 
-  setTargetAtTime(...args) {
+  setValueCurveAtTime(values, startTime, duration) {
+    if (!(this instanceof AudioParam)) {
+      throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioParam\'');
+    }
+
+    if (arguments.length < 3) {
+      throw new TypeError(`Failed to execute 'setValueCurveAtTime' on 'AudioParam': 3 argument required, but only ${arguments.length} present`);
+    }
+
     try {
-      return this[kNativeAudioParam].setTargetAtTime(...args);
+      values = toSanitizedSequence(values, Float32Array);
     } catch (err) {
-      throwSanitizedError(err);
+      throw new TypeError(`Failed to execute 'setValueCurveAtTime': Parameter 1 ${err.message}`);
     }
-  }
 
-  setValueCurveAtTime(...args) {
+    startTime = conversions['double'](startTime, {
+      context: `Failed to execute 'setValueCurveAtTime' on 'AudioParam': Parameter 2`,
+    });
+
+    duration = conversions['double'](duration, {
+      context: `Failed to execute 'setValueCurveAtTime' on 'AudioParam': Parameter 3`,
+    });
+
     try {
-      return this[kNativeAudioParam].setValueCurveAtTime(...args);
+      this[kNapiObj].setValueCurveAtTime(values, startTime, duration);
     } catch (err) {
       throwSanitizedError(err);
     }
+
+    return this;
   }
 
-  cancelScheduledValues(...args) {
+  cancelScheduledValues(cancelTime) {
+    if (!(this instanceof AudioParam)) {
+      throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioParam\'');
+    }
+
+    if (arguments.length < 1) {
+      throw new TypeError(`Failed to execute 'cancelScheduledValues' on 'AudioParam': 1 argument required, but only ${arguments.length} present`);
+    }
+
+    cancelTime = conversions['double'](cancelTime, {
+      context: `Failed to execute 'cancelScheduledValues' on 'AudioParam': Parameter 1`,
+    });
+
     try {
-      return this[kNativeAudioParam].cancelScheduledValues(...args);
+      this[kNapiObj].cancelScheduledValues(cancelTime);
     } catch (err) {
       throwSanitizedError(err);
     }
+
+    return this;
   }
 
-  cancelAndHoldAtTime(...args) {
+  cancelAndHoldAtTime(cancelTime) {
+    if (!(this instanceof AudioParam)) {
+      throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioParam\'');
+    }
+
+    if (arguments.length < 1) {
+      throw new TypeError(`Failed to execute 'cancelAndHoldAtTime' on 'AudioParam': 1 argument required, but only ${arguments.length} present`);
+    }
+
+    cancelTime = conversions['double'](cancelTime, {
+      context: `Failed to execute 'cancelAndHoldAtTime' on 'AudioParam': Parameter 1`,
+    });
+
     try {
-      return this[kNativeAudioParam].cancelAndHoldAtTime(...args);
+      this[kNapiObj].cancelAndHoldAtTime(cancelTime);
     } catch (err) {
       throwSanitizedError(err);
     }
+
+    return this;
   }
 
 }
 
-module.exports.kNativeAudioParam = kNativeAudioParam;
-module.exports.AudioParam = AudioParam;
+Object.defineProperties(AudioParam, {
+  length: {
+    __proto__: null,
+    writable: false,
+    enumerable: false,
+    configurable: true,
+    value: 0,
+  },
+});
 
+Object.defineProperties(AudioParam.prototype, {
+  [Symbol.toStringTag]: {
+    __proto__: null,
+    writable: false,
+    enumerable: false,
+    configurable: true,
+    value: 'AudioParam',
+  },
+  value: kEnumerableProperty,
+  automationRate: kEnumerableProperty,
+  defaultValue: kEnumerableProperty,
+  minValue: kEnumerableProperty,
+  maxValue: kEnumerableProperty,
+  setValueAtTime: kEnumerableProperty,
+  linearRampToValueAtTime: kEnumerableProperty,
+  exponentialRampToValueAtTime: kEnumerableProperty,
+  setTargetAtTime: kEnumerableProperty,
+  setValueCurveAtTime: kEnumerableProperty,
+  cancelScheduledValues: kEnumerableProperty,
+  cancelAndHoldAtTime: kEnumerableProperty,
+});
 
-  
+module.exports = AudioParam;

package/js/AudioScheduledSourceNode.js

@@ -0,0 +1,105 @@
+const conversions = require('webidl-conversions');
+
+const {
+  throwSanitizedError,
+} = require('./lib/errors.js');
+const {
+  isFunction,
+  kEnumerableProperty,
+} = require('./lib/utils.js');
+const {
+  kNapiObj,
+} = require('./lib/symbols.js');
+
+const AudioNode = require('./AudioNode.js');
+
+class AudioScheduledSourceNode extends AudioNode {
+  #onended = null;
+
+  constructor(context, options) {
+    // Make constructor "private"
+    if (
+      (typeof options !== 'object')
+      || !(kNapiObj in options)
+    ) {
+      throw new TypeError('Illegal constructor');
+    }
+
+    super(context, options);
+  }
+
+  get onended() {
+    if (!(this instanceof AudioScheduledSourceNode)) {
+      throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioScheduledSourceNode\'');
+    }
+
+    return this.#onended;
+  }
+
+  set onended(value) {
+    if (!(this instanceof AudioScheduledSourceNode)) {
+      throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioScheduledSourceNode\'');
+    }
+
+    if (isFunction(value) || value === null) {
+      this.#onended = value;
+    }
+  }
+
+  start(when = 0) {
+    if (!(this instanceof AudioScheduledSourceNode)) {
+      throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioScheduledSourceNode\'');
+    }
+
+    when = conversions['double'](when, {
+      context: `Failed to execute 'start' on 'AudioScheduledSourceNode': Parameter 1`,
+    });
+
+    try {
+      return this[kNapiObj].start(when);
+    } catch (err) {
+      throwSanitizedError(err);
+    }
+  }
+
+  stop(when = 0) {
+    if (!(this instanceof AudioScheduledSourceNode)) {
+      throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioScheduledSourceNode\'');
+    }
+
+    when = conversions['double'](when, {
+      context: `Failed to execute 'stop' on 'AudioScheduledSourceNode': Parameter 1`,
+    });
+
+    try {
+      return this[kNapiObj].stop(when);
+    } catch (err) {
+      throwSanitizedError(err);
+    }
+  }
+}
+
+Object.defineProperties(AudioScheduledSourceNode, {
+  length: {
+    __proto__: null,
+    writable: false,
+    enumerable: false,
+    configurable: true,
+    value: 0,
+  },
+});
+
+Object.defineProperties(AudioScheduledSourceNode.prototype, {
+  [Symbol.toStringTag]: {
+    __proto__: null,
+    writable: false,
+    enumerable: false,
+    configurable: true,
+    value: 'AudioScheduledSourceNode',
+  },
+  onended: kEnumerableProperty,
+  start: kEnumerableProperty,
+  stop: kEnumerableProperty,
+});
+
+module.exports = AudioScheduledSourceNode;