tone 14.9.16 → 15.0.0

package/Tone/signal/SyncedSignal.ts

@@ -1,19 +1,27 @@
-import { Signal, SignalOptions } from "./Signal";
-import { NormalRange, Seconds, Time, TransportTime, UnitMap, UnitName } from "../core/type/Units";
-import { optionsFromArguments } from "../core/util/Defaults";
-import { TransportTimeClass } from "../core/type/TransportTime";
-import { ToneConstantSource } from "./ToneConstantSource";
-import { OutputNode } from "../core/context/ToneAudioNode";
-import type { TransportClass } from "../core/clock/Transport";
+import { Signal, SignalOptions } from "./Signal.js";
+import {
+	NormalRange,
+	Seconds,
+	Time,
+	TransportTime,
+	UnitMap,
+	UnitName,
+} from "../core/type/Units.js";
+import { optionsFromArguments } from "../core/util/Defaults.js";
+import { TransportTimeClass } from "../core/type/TransportTime.js";
+import { ToneConstantSource } from "./ToneConstantSource.js";
+import { OutputNode } from "../core/context/ToneAudioNode.js";
+import type { TransportClass } from "../core/clock/Transport.js";
 
 /**
  * Adds the ability to synchronize the signal to the {@link TransportClass}
  * @category Signal
  */
-export class SyncedSignal<TypeName extends UnitName = "number"> extends Signal<TypeName> {
-
+export class SyncedSignal<
+	TypeName extends UnitName = "number",
+> extends Signal<TypeName> {
 	readonly name: string = "SyncedSignal";
-	
+
 	/**
 	 * Don't override when something is connected to the input
 	 */
@@ -43,12 +51,22 @@ export class SyncedSignal<TypeName extends UnitName = "number"> extends Signal<T
 	constructor(value?: UnitMap[TypeName], units?: TypeName);
 	constructor(options?: Partial<SignalOptions<TypeName>>);
 	constructor() {
-
-		super(optionsFromArguments(Signal.getDefaults(), arguments, ["value", "units"]));
-		const options = optionsFromArguments(Signal.getDefaults(), arguments, ["value", "units"]) as SignalOptions<TypeName>;
+		super(
+			optionsFromArguments(Signal.getDefaults(), arguments, [
+				"value",
+				"units",
+			])
+		);
+		const options = optionsFromArguments(Signal.getDefaults(), arguments, [
+			"value",
+			"units",
+		]) as SignalOptions<TypeName>;
 
 		this._lastVal = options.value;
-		this._synced = this.context.transport.scheduleRepeat(this._onTick.bind(this), "1i");
+		this._synced = this.context.transport.scheduleRepeat(
+			this._onTick.bind(this),
+			"1i"
+		);
 
 		this._syncedCallback = this._anchorValue.bind(this);
 		this.context.transport.on("start", this._syncedCallback);
@@ -60,7 +78,7 @@ export class SyncedSignal<TypeName extends UnitName = "number"> extends Signal<T
 		this._constantSource.stop(0);
 
 		// create a new one
-		this._constantSource = this.output = new ToneConstantSource<TypeName>({ 
+		this._constantSource = this.output = new ToneConstantSource<TypeName>({
 			context: this.context,
 			offset: options.value,
 			units: options.units,
@@ -91,73 +109,133 @@ export class SyncedSignal<TypeName extends UnitName = "number"> extends Signal<T
 	}
 
 	getValueAtTime(time: TransportTime): UnitMap[TypeName] {
-		const computedTime = new TransportTimeClass(this.context, time).toSeconds();
+		const computedTime = new TransportTimeClass(
+			this.context,
+			time
+		).toSeconds();
 		return super.getValueAtTime(computedTime);
 	}
-	
+
 	setValueAtTime(value: UnitMap[TypeName], time: TransportTime) {
-		const computedTime = new TransportTimeClass(this.context, time).toSeconds();
+		const computedTime = new TransportTimeClass(
+			this.context,
+			time
+		).toSeconds();
 		super.setValueAtTime(value, computedTime);
 		return this;
 	}
 
 	linearRampToValueAtTime(value: UnitMap[TypeName], time: TransportTime) {
-		const computedTime = new TransportTimeClass(this.context, time).toSeconds();
+		const computedTime = new TransportTimeClass(
+			this.context,
+			time
+		).toSeconds();
 		super.linearRampToValueAtTime(value, computedTime);
 		return this;
 	}
 
-	exponentialRampToValueAtTime(value: UnitMap[TypeName], time: TransportTime) {
-		const computedTime = new TransportTimeClass(this.context, time).toSeconds();
+	exponentialRampToValueAtTime(
+		value: UnitMap[TypeName],
+		time: TransportTime
+	) {
+		const computedTime = new TransportTimeClass(
+			this.context,
+			time
+		).toSeconds();
 		super.exponentialRampToValueAtTime(value, computedTime);
 		return this;
 	}
 
-	setTargetAtTime(value, startTime: TransportTime, timeConstant: number): this {
-		const computedTime = new TransportTimeClass(this.context, startTime).toSeconds();
+	setTargetAtTime(
+		value,
+		startTime: TransportTime,
+		timeConstant: number
+	): this {
+		const computedTime = new TransportTimeClass(
+			this.context,
+			startTime
+		).toSeconds();
 		super.setTargetAtTime(value, computedTime, timeConstant);
 		return this;
 	}
 
 	cancelScheduledValues(startTime: TransportTime): this {
-		const computedTime = new TransportTimeClass(this.context, startTime).toSeconds();
+		const computedTime = new TransportTimeClass(
+			this.context,
+			startTime
+		).toSeconds();
 		super.cancelScheduledValues(computedTime);
 		return this;
 	}
 
-	setValueCurveAtTime(values: UnitMap[TypeName][], startTime: TransportTime, duration: Time, scaling: NormalRange): this {
-		const computedTime = new TransportTimeClass(this.context, startTime).toSeconds();
+	setValueCurveAtTime(
+		values: UnitMap[TypeName][],
+		startTime: TransportTime,
+		duration: Time,
+		scaling: NormalRange
+	): this {
+		const computedTime = new TransportTimeClass(
+			this.context,
+			startTime
+		).toSeconds();
 		duration = this.toSeconds(duration);
 		super.setValueCurveAtTime(values, computedTime, duration, scaling);
 		return this;
 	}
 
 	cancelAndHoldAtTime(time: TransportTime): this {
-		const computedTime = new TransportTimeClass(this.context, time).toSeconds();
+		const computedTime = new TransportTimeClass(
+			this.context,
+			time
+		).toSeconds();
 		super.cancelAndHoldAtTime(computedTime);
 		return this;
 	}
-	
+
 	setRampPoint(time: TransportTime): this {
-		const computedTime = new TransportTimeClass(this.context, time).toSeconds();
+		const computedTime = new TransportTimeClass(
+			this.context,
+			time
+		).toSeconds();
 		super.setRampPoint(computedTime);
 		return this;
 	}
-	
-	exponentialRampTo(value: UnitMap[TypeName], rampTime: Time, startTime?: TransportTime): this {
-		const computedTime = new TransportTimeClass(this.context, startTime).toSeconds();
+
+	exponentialRampTo(
+		value: UnitMap[TypeName],
+		rampTime: Time,
+		startTime?: TransportTime
+	): this {
+		const computedTime = new TransportTimeClass(
+			this.context,
+			startTime
+		).toSeconds();
 		super.exponentialRampTo(value, rampTime, computedTime);
 		return this;
 	}
-	
-	linearRampTo(value: UnitMap[TypeName], rampTime: Time, startTime?: TransportTime): this {
-		const computedTime = new TransportTimeClass(this.context, startTime).toSeconds();
+
+	linearRampTo(
+		value: UnitMap[TypeName],
+		rampTime: Time,
+		startTime?: TransportTime
+	): this {
+		const computedTime = new TransportTimeClass(
+			this.context,
+			startTime
+		).toSeconds();
 		super.linearRampTo(value, rampTime, computedTime);
 		return this;
 	}
 
-	targetRampTo(value: UnitMap[TypeName], rampTime: Time, startTime?: TransportTime): this {
-		const computedTime = new TransportTimeClass(this.context, startTime).toSeconds();
+	targetRampTo(
+		value: UnitMap[TypeName],
+		rampTime: Time,
+		startTime?: TransportTime
+	): this {
+		const computedTime = new TransportTimeClass(
+			this.context,
+			startTime
+		).toSeconds();
 		super.targetRampTo(value, rampTime, computedTime);
 		return this;
 	}

package/Tone/signal/ToneConstantSource.test.ts

@@ -1,16 +1,13 @@
 import { expect } from "chai";
-import { BasicTests } from "test/helper/Basic";
-import { CompareToFile } from "test/helper/CompareToFile";
-import { Offline, whenBetween } from "test/helper/Offline";
-import { ONLINE_TESTING } from "test/helper/Supports";
-import { ToneConstantSource } from "./ToneConstantSource";
+import { BasicTests } from "../../test/helper/Basic.js";
+import { CompareToFile } from "../../test/helper/CompareToFile.js";
+import { Offline, whenBetween } from "../../test/helper/Offline.js";
+import { ToneConstantSource } from "./ToneConstantSource.js";
 
 describe("ToneConstantSource", () => {
-
 	BasicTests(ToneConstantSource);
 
 	context("Constructor", () => {
-
 		it("can be constructed with an offset", () => {
 			const source = new ToneConstantSource(330);
 			expect(source.offset.value).to.equal(330);
@@ -30,39 +27,34 @@ describe("ToneConstantSource", () => {
 			expect(source.offset.value).to.be.closeTo(2, 0.01);
 			source.dispose();
 		});
-
 	});
 
 	context("onended", () => {
+		it("invokes the onended callback in the online context", (done) => {
+			const source = new ToneConstantSource();
+			source.start();
+			source.stop("+0.3");
+			const now = source.now();
+			source.onended = () => {
+				expect(source.now() - now).to.be.within(0.25, 0.5);
+				source.dispose();
+				done();
+			};
+		});
 
-		if (ONLINE_TESTING) {
-
-			it("invokes the onended callback in the online context", (done) => {
-				const source = new ToneConstantSource();
-				source.start();
-				source.stop("+0.3");
-				const now = source.now();
-				source.onended = () => {
-					expect(source.now() - now).to.be.within(0.25, 0.5);
-					source.dispose();
-					done();
-				};
-			});
-
-			it("invokes the onended callback only once in the online context", (done) => {
-				const source = new ToneConstantSource();
-				source.start();
-				source.stop("+0.1");
-				source.stop("+0.2");
-				source.stop("+0.3");
-				const now = source.now();
-				source.onended = () => {
-					expect(source.now() - now).to.be.within(0.25, 0.5);
-					source.dispose();
-					done();
-				};
-			});
-		}
+		it("invokes the onended callback only once in the online context", (done) => {
+			const source = new ToneConstantSource();
+			source.start();
+			source.stop("+0.1");
+			source.stop("+0.2");
+			source.stop("+0.3");
+			const now = source.now();
+			source.onended = () => {
+				expect(source.now() - now).to.be.within(0.25, 0.5);
+				source.dispose();
+				done();
+			};
+		});
 
 		it("invokes the onended callback in the offline context", () => {
 			let wasInvoked = false;
@@ -101,7 +93,6 @@ describe("ToneConstantSource", () => {
 	});
 
 	context("Scheduling", () => {
-
 		it("throw an error if start is called multiple time", () => {
 			const source = new ToneConstantSource();
 			source.start();
@@ -115,7 +106,7 @@ describe("ToneConstantSource", () => {
 			return Offline(() => {
 				const source = new ToneConstantSource().toDestination();
 				source.start(0).stop(0.1);
-			}, 0.4).then(buffer => {
+			}, 0.4).then((buffer) => {
 				expect(buffer.getValueAtTime(0)).to.be.above(0);
 				expect(buffer.getValueAtTime(0.09)).to.be.above(0);
 				expect(buffer.getValueAtTime(0.1)).to.equal(0);
@@ -134,38 +125,35 @@ describe("ToneConstantSource", () => {
 			});
 		});
 
-		if (ONLINE_TESTING) {
+		it("clamps start time to the currentTime", () => {
+			const source = new ToneConstantSource();
+			source.start(0);
+			const currentTime = source.context.currentTime;
+			expect(source.getStateAtTime(0)).to.equal("stopped");
+			expect(source.getStateAtTime(currentTime)).to.equal("started");
+			source.dispose();
+		});
 
-			it("clamps start time to the currentTime", () => {
-				const source = new ToneConstantSource();
-				source.start(0);
-				const currentTime = source.context.currentTime;
-				expect(source.getStateAtTime(0)).to.equal("stopped");
-				expect(source.getStateAtTime(currentTime)).to.equal("started");
+		it("clamps stop time to the currentTime", (done) => {
+			const source = new ToneConstantSource();
+			source.start(0);
+			let currentTime = source.context.currentTime;
+			expect(source.getStateAtTime(0)).to.equal("stopped");
+			expect(source.getStateAtTime(currentTime)).to.equal("started");
+			setTimeout(() => {
+				currentTime = source.now();
+				source.stop(0);
+				expect(source.getStateAtTime(currentTime + 0.01)).to.equal(
+					"stopped"
+				);
 				source.dispose();
-			});
-
-			it("clamps stop time to the currentTime", (done) => {
-				const source = new ToneConstantSource();
-				source.start(0);
-				let currentTime = source.context.currentTime;
-				expect(source.getStateAtTime(0)).to.equal("stopped");
-				expect(source.getStateAtTime(currentTime)).to.equal("started");
-				setTimeout(() => {
-					currentTime = source.now();
-					source.stop(0);
-					expect(source.getStateAtTime(currentTime + 0.01)).to.equal("stopped");
-					source.dispose();
-					done();
-				}, 100);
-			});
-		}
+				done();
+			}, 100);
+		});
 	});
 
 	context("State", () => {
-
 		it("reports the right state", () => {
-
 			return Offline(() => {
 				const source = new ToneConstantSource();
 				source.start(0);
@@ -182,7 +170,6 @@ describe("ToneConstantSource", () => {
 		});
 
 		it("can call stop multiple times, takes the last value", () => {
-
 			return Offline(() => {
 				const source = new ToneConstantSource();
 				source.start(0);

package/Tone/signal/ToneConstantSource.ts

@@ -1,10 +1,14 @@
-import { connect } from "../core/context/ToneAudioNode";
-import { Param } from "../core/context/Param";
-import { Seconds, Time, UnitMap, UnitName } from "../core/type/Units";
-import { optionsFromArguments } from "../core/util/Defaults";
-import { OneShotSource, OneShotSourceOptions } from "../source/OneShotSource";
+import { connect } from "../core/context/ToneAudioNode.js";
+import { Param } from "../core/context/Param.js";
+import { Seconds, Time, UnitMap, UnitName } from "../core/type/Units.js";
+import { optionsFromArguments } from "../core/util/Defaults.js";
+import {
+	OneShotSource,
+	OneShotSourceOptions,
+} from "../source/OneShotSource.js";
 
-export interface ToneConstantSourceOptions<TypeName extends UnitName> extends OneShotSourceOptions {
+export interface ToneConstantSourceOptions<TypeName extends UnitName>
+	extends OneShotSourceOptions {
 	convert: boolean;
 	offset: UnitMap[TypeName];
 	units: TypeName;
@@ -17,8 +21,9 @@ export interface ToneConstantSourceOptions<TypeName extends UnitName> extends On
  * Adds the ability to reschedule the stop method.
  * @category Signal
  */
-export class ToneConstantSource<TypeName extends UnitName = "number"> extends OneShotSource<ToneConstantSourceOptions<TypeName>> {
-
+export class ToneConstantSource<
+	TypeName extends UnitName = "number",
+> extends OneShotSource<ToneConstantSourceOptions<TypeName>> {
 	readonly name: string = "ToneConstantSource";
 
 	/**
@@ -37,9 +42,16 @@ export class ToneConstantSource<TypeName extends UnitName = "number"> extends On
 	constructor(offset: UnitMap[TypeName]);
 	constructor(options?: Partial<ToneConstantSourceOptions<TypeName>>);
 	constructor() {
-
-		super(optionsFromArguments(ToneConstantSource.getDefaults(), arguments, ["offset"]));
-		const options = optionsFromArguments(ToneConstantSource.getDefaults(), arguments, ["offset"]);
+		super(
+			optionsFromArguments(ToneConstantSource.getDefaults(), arguments, [
+				"offset",
+			])
+		);
+		const options = optionsFromArguments(
+			ToneConstantSource.getDefaults(),
+			arguments,
+			["offset"]
+		);
 
 		connect(this._source, this._gainNode);
 

package/Tone/signal/WaveShaper.test.ts

@@ -1,16 +1,14 @@
 import { expect } from "chai";
-import { BasicTests } from "test/helper/Basic";
-import { ConstantOutput } from "test/helper/ConstantOutput";
-import { Offline } from "test/helper/Offline";
-import { Signal } from "./Signal";
-import { WaveShaper } from "./WaveShaper";
+import { BasicTests } from "../../test/helper/Basic.js";
+import { ConstantOutput } from "../../test/helper/ConstantOutput.js";
+import { Offline } from "../../test/helper/Offline.js";
+import { Signal } from "./Signal.js";
+import { WaveShaper } from "./WaveShaper.js";
 
 describe("WaveShaper", () => {
-
 	BasicTests(WaveShaper);
 
 	describe("Construction Options", () => {
-
 		it("can be constructed with an array", () => {
 			const waveshaper = new WaveShaper([1, 2, 3, 4, 5, 6]);
 			expect(waveshaper.curve && waveshaper.curve[0]).to.equal(1);
@@ -42,11 +40,9 @@ describe("WaveShaper", () => {
 				waveshaper.oversample = "3x";
 			}).to.throw(Error);
 		});
-
 	});
 
 	describe("Logic", () => {
-
 		it("shapes the output of the incoming signal", () => {
 			return ConstantOutput(() => {
 				const signal = new Signal(1);
@@ -86,10 +82,9 @@ describe("WaveShaper", () => {
 				signal.linearRampToValueAtTime(1, 1);
 			}, 1).then((buffer) => {
 				buffer.forEach((sample, time) => {
-					expect(sample).to.be.closeTo(2 * ((time * 2) - 1), 0.005);
+					expect(sample).to.be.closeTo(2 * (time * 2 - 1), 0.005);
 				});
 			});
 		});
-
 	});
 });

package/Tone/signal/WaveShaper.ts

@@ -1,9 +1,9 @@
-import { ToneAudioNodeOptions } from "../core/context/ToneAudioNode";
-import { optionsFromArguments } from "../core/util/Defaults";
-import { isArray, isFunction } from "../core/util/TypeCheck";
-import { assert } from "../core/util/Debug";
-import { Signal } from "./Signal";
-import { SignalOperator } from "./SignalOperator";
+import { ToneAudioNodeOptions } from "../core/context/ToneAudioNode.js";
+import { optionsFromArguments } from "../core/util/Defaults.js";
+import { isArray, isFunction } from "../core/util/TypeCheck.js";
+import { assert } from "../core/util/Debug.js";
+import { Signal } from "./Signal.js";
+import { SignalOperator } from "./SignalOperator.js";
 
 export type WaveShaperMappingFn = (value: number, index?: number) => number;
 
@@ -27,7 +27,6 @@ interface WaveShaperOptions extends ToneAudioNodeOptions {
  * @category Signal
  */
 export class WaveShaper extends SignalOperator<WaveShaperOptions> {
-
 	readonly name: string = "WaveShaper";
 
 	/**
@@ -60,10 +59,24 @@ export class WaveShaper extends SignalOperator<WaveShaperOptions> {
 	constructor(mapping?: WaveShaperMapping, length?: number);
 	constructor(options?: Partial<WaveShaperOptions>);
 	constructor() {
-		super(Object.assign(optionsFromArguments(WaveShaper.getDefaults(), arguments, ["mapping", "length"])));
-		const options = optionsFromArguments(WaveShaper.getDefaults(), arguments, ["mapping", "length"]);
-
-		if (isArray(options.mapping) || options.mapping instanceof Float32Array) {
+		super(
+			Object.assign(
+				optionsFromArguments(WaveShaper.getDefaults(), arguments, [
+					"mapping",
+					"length",
+				])
+			)
+		);
+		const options = optionsFromArguments(
+			WaveShaper.getDefaults(),
+			arguments,
+			["mapping", "length"]
+		);
+
+		if (
+			isArray(options.mapping) ||
+			options.mapping instanceof Float32Array
+		) {
 			this.curve = Float32Array.from(options.mapping);
 		} else if (isFunction(options.mapping)) {
 			this.setMap(options.mapping, options.length);
@@ -120,8 +133,13 @@ export class WaveShaper extends SignalOperator<WaveShaperOptions> {
 	}
 
 	set oversample(oversampling: OverSampleType) {
-		const isOverSampleType = ["none", "2x", "4x"].some(str => str.includes(oversampling));
-		assert(isOverSampleType, "oversampling must be either 'none', '2x', or '4x'");
+		const isOverSampleType = ["none", "2x", "4x"].some((str) =>
+			str.includes(oversampling)
+		);
+		assert(
+			isOverSampleType,
+			"oversampling must be either 'none', '2x', or '4x'"
+		);
 		this._shaper.oversample = oversampling;
 	}
 

package/Tone/signal/Zero.test.ts

@@ -1,14 +1,12 @@
 import { expect } from "chai";
-import { BasicTests } from "test/helper/Basic";
-import { ConstantOutput } from "test/helper/ConstantOutput";
-import { Zero } from "./Zero";
+import { BasicTests } from "../../test/helper/Basic.js";
+import { ConstantOutput } from "../../test/helper/ConstantOutput.js";
+import { Zero } from "./Zero.js";
 
 describe("Zero", () => {
-
 	BasicTests(Zero);
 
 	context("Zero", () => {
-
 		it("has 0 inputs and 1 output", () => {
 			const zero = new Zero();
 			expect(zero.numberOfInputs).to.equal(0);
@@ -17,9 +15,13 @@ describe("Zero", () => {
 		});
 
 		it("always outputs 0", () => {
-			return ConstantOutput(() => {
-				new Zero().toDestination();
-			}, 0, 0);
+			return ConstantOutput(
+				() => {
+					new Zero().toDestination();
+				},
+				0,
+				0
+			);
 		});
 	});
 });

package/Tone/signal/Zero.ts

@@ -1,7 +1,11 @@
-import { Gain } from "../core/context/Gain";
-import { connect, disconnect, ToneAudioNodeOptions } from "../core/context/ToneAudioNode";
-import { optionsFromArguments } from "../core/util/Defaults";
-import { SignalOperator } from "./SignalOperator";
+import { Gain } from "../core/context/Gain.js";
+import {
+	connect,
+	disconnect,
+	ToneAudioNodeOptions,
+} from "../core/context/ToneAudioNode.js";
+import { optionsFromArguments } from "../core/util/Defaults.js";
+import { SignalOperator } from "./SignalOperator.js";
 
 /**
  * Tone.Zero outputs 0's at audio-rate. The reason this has to be
@@ -10,7 +14,6 @@ import { SignalOperator } from "./SignalOperator";
  * @category Signal
  */
 export class Zero extends SignalOperator<ToneAudioNodeOptions> {
-
 	readonly name: string = "Zero";
 
 	/**
@@ -30,7 +33,9 @@ export class Zero extends SignalOperator<ToneAudioNodeOptions> {
 
 	constructor(options?: Partial<ToneAudioNodeOptions>);
 	constructor() {
-		super(Object.assign(optionsFromArguments(Zero.getDefaults(), arguments)));
+		super(
+			Object.assign(optionsFromArguments(Zero.getDefaults(), arguments))
+		);
 		connect(this.context.getConstant(0), this._gain);
 	}
 

package/Tone/signal/index.ts

@@ -1,16 +1,16 @@
-export * from "./Add";
-export * from "./Abs";
-export * from "./AudioToGain";
-export * from "./GainToAudio";
-export * from "./GreaterThan";
-export * from "./GreaterThanZero";
-export * from "./Multiply";
-export * from "./Negate";
-export * from "./Pow";
-export * from "./Signal";
-export * from "./Scale";
-export * from "./ScaleExp";
-export * from "./Subtract";
-export * from "./SyncedSignal";
-export * from "./WaveShaper";
-export * from "./Zero";
+export * from "./Add.js";
+export * from "./Abs.js";
+export * from "./AudioToGain.js";
+export * from "./GainToAudio.js";
+export * from "./GreaterThan.js";
+export * from "./GreaterThanZero.js";
+export * from "./Multiply.js";
+export * from "./Negate.js";
+export * from "./Pow.js";
+export * from "./Signal.js";
+export * from "./Scale.js";
+export * from "./ScaleExp.js";
+export * from "./Subtract.js";
+export * from "./SyncedSignal.js";
+export * from "./WaveShaper.js";
+export * from "./Zero.js";