tone 15.5.1 → 15.5.3

package/Tone/effect/StereoWidener.ts

@@ -1,4 +1,3 @@
-import { connect } from "../core/context/ToneAudioNode.js";
 import { NormalRange } from "../core/type/Units.js";
 import { optionsFromArguments } from "../core/util/Defaults.js";
 import { readOnly } from "../core/util/Interface.js";
@@ -9,6 +8,7 @@ import {
 import { Multiply } from "../signal/Multiply.js";
 import { Signal } from "../signal/Signal.js";
 import { Subtract } from "../signal/Subtract.js";
+import { ToneConstantSource } from "../signal/ToneConstantSource.js";
 
 export interface StereoWidenerOptions extends MidSideEffectOptions {
 	width: NormalRange;
@@ -57,6 +57,11 @@ export class StereoWidener extends MidSideEffect<StereoWidenerOptions> {
 	 */
 	private _sideMult: Multiply;
 
+	/**
+	 * A constant source to get the value of 1 for the subtract node
+	 */
+	private _constant: ToneConstantSource;
+
 	/**
 	 * @param width The stereo width. A width of 0 is mono and 1 is stereo. 0.5 is no change.
 	 */
@@ -90,7 +95,11 @@ export class StereoWidener extends MidSideEffect<StereoWidenerOptions> {
 
 		this._oneMinusWidth = new Subtract({ context: this.context });
 		this._oneMinusWidth.connect(this._twoTimesWidthMid);
-		connect(this.context.getConstant(1), this._oneMinusWidth);
+		this._constant = new ToneConstantSource({
+			context: this.context,
+			offset: 1,
+		}).start();
+		this._constant.connect(this._oneMinusWidth);
 		this.width.connect(this._oneMinusWidth.subtrahend);
 
 		this._sideMult = new Multiply({ context: this.context });
@@ -113,6 +122,7 @@ export class StereoWidener extends MidSideEffect<StereoWidenerOptions> {
 		this._twoTimesWidthMid.dispose();
 		this._twoTimesWidthSide.dispose();
 		this._oneMinusWidth.dispose();
+		this._constant.dispose();
 		return this;
 	}
 }

package/Tone/effect/Tremolo.test.ts

@@ -3,7 +3,6 @@ import { expect } from "chai";
 import { BasicTests } from "../../test/helper/Basic.js";
 import { CompareToFile } from "../../test/helper/CompareToFile.js";
 import { EffectTests } from "../../test/helper/EffectTests.js";
-import { Offline } from "../../test/helper/Offline.js";
 import { Oscillator } from "../source/index.js";
 import { Tremolo } from "./Tremolo.js";
 
@@ -60,28 +59,5 @@ describe("Tremolo", () => {
 			expect(tremolo.frequency.value).to.be.closeTo(0.4, 0.01);
 			tremolo.dispose();
 		});
-
-		it("can sync the frequency to the transport", async () => {
-			const buffer = await Offline(({ transport }) => {
-				const tremolo = new Tremolo(2);
-				tremolo.sync();
-				tremolo.frequency.toDestination();
-				transport.bpm.setValueAtTime(transport.bpm.value * 2, 0.05);
-			}, 0.1);
-			expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
-			expect(buffer.getValueAtTime(0.05)).to.be.closeTo(4, 0.1);
-		});
-
-		it("can unsync the frequency to the transport", async () => {
-			const buffer = await Offline(({ transport }) => {
-				const tremolo = new Tremolo(2);
-				tremolo.sync();
-				tremolo.frequency.toDestination();
-				transport.bpm.setValueAtTime(transport.bpm.value * 2, 0.05);
-				tremolo.unsync();
-			}, 0.1);
-			expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
-			expect(buffer.getValueAtTime(0.05)).to.be.closeTo(2, 0.1);
-		});
 	});
 });

package/Tone/effect/Tremolo.ts

@@ -1,13 +1,12 @@
 import { Gain } from "../core/context/Gain.js";
-import { Degrees, Frequency, NormalRange, Time } from "../core/type/Units.js";
+import { Degrees, Frequency, NormalRange } from "../core/type/Units.js";
 import { optionsFromArguments } from "../core/util/Defaults.js";
 import { readOnly } from "../core/util/Interface.js";
 import { Signal } from "../signal/Signal.js";
-import { LFO } from "../source/oscillator/LFO.js";
 import { ToneOscillatorType } from "../source/oscillator/OscillatorInterface.js";
-import { StereoEffect, StereoEffectOptions } from "./StereoEffect.js";
+import { LFOStereoEffect, LFOStereoEffectOptions } from "./LFOStereoEffect.js";
 
-export interface TremoloOptions extends StereoEffectOptions {
+export interface TremoloOptions extends LFOStereoEffectOptions {
 	frequency: Frequency;
 	type: ToneOscillatorType;
 	depth: NormalRange;
@@ -26,19 +25,9 @@ export interface TremoloOptions extends StereoEffectOptions {
  *
  * @category Effect
  */
-export class Tremolo extends StereoEffect<TremoloOptions> {
+export class Tremolo extends LFOStereoEffect<TremoloOptions> {
 	readonly name: string = "Tremolo";
 
-	/**
-	 * The tremolo LFO in the left channel
-	 */
-	private _lfoL: LFO;
-
-	/**
-	 * The tremolo LFO in the left channel
-	 */
-	private _lfoR: LFO;
-
 	/**
 	 * Where the gain is multiplied
 	 */
@@ -49,11 +38,6 @@ export class Tremolo extends StereoEffect<TremoloOptions> {
 	 */
 	private _amplitudeR: Gain;
 
-	/**
-	 * The frequency of the tremolo.
-	 */
-	readonly frequency: Signal<"frequency">;
-
 	/**
 	 * The depth of the effect. A depth of 0, has no effect
 	 * on the amplitude, and a depth of 1 makes the amplitude
@@ -74,25 +58,16 @@ export class Tremolo extends StereoEffect<TremoloOptions> {
 		]);
 		super(options);
 
-		this._lfoL = new LFO({
-			context: this.context,
-			type: options.type,
-			min: 1,
-			max: 0,
-		});
-		this._lfoR = new LFO({
-			context: this.context,
-			type: options.type,
-			min: 1,
-			max: 0,
-		});
+		// invert the lfo min/max so it moves from full gain to 0 gain
+		this._lfoL.min = 1;
+		this._lfoL.max = 0;
+		this._lfoR.min = 1;
+		this._lfoR.max = 0;
+		this.type = options.type;
+
 		this._amplitudeL = new Gain({ context: this.context });
 		this._amplitudeR = new Gain({ context: this.context });
-		this.frequency = new Signal({
-			context: this.context,
-			value: options.frequency,
-			units: "frequency",
-		});
+
 		this.depth = new Signal({
 			context: this.context,
 			value: options.depth,
@@ -104,13 +79,12 @@ export class Tremolo extends StereoEffect<TremoloOptions> {
 		this.connectEffectRight(this._amplitudeR);
 		this._lfoL.connect(this._amplitudeL.gain);
 		this._lfoR.connect(this._amplitudeR.gain);
-		this.frequency.fan(this._lfoL.frequency, this._lfoR.frequency);
 		this.depth.fan(this._lfoR.amplitude, this._lfoL.amplitude);
 		this.spread = options.spread;
 	}
 
 	static getDefaults(): TremoloOptions {
-		return Object.assign(StereoEffect.getDefaults(), {
+		return Object.assign(LFOStereoEffect.getDefaults(), {
 			frequency: 10,
 			type: "sine" as const,
 			depth: 0.5,
@@ -118,44 +92,6 @@ export class Tremolo extends StereoEffect<TremoloOptions> {
 		});
 	}
 
-	/**
-	 * Start the tremolo.
-	 */
-	start(time?: Time): this {
-		this._lfoL.start(time);
-		this._lfoR.start(time);
-		return this;
-	}
-
-	/**
-	 * Stop the tremolo.
-	 */
-	stop(time?: Time): this {
-		this._lfoL.stop(time);
-		this._lfoR.stop(time);
-		return this;
-	}
-
-	/**
-	 * Sync the effect to the transport.
-	 */
-	sync(): this {
-		this._lfoL.sync();
-		this._lfoR.sync();
-		this.context.transport.syncSignal(this.frequency);
-		return this;
-	}
-
-	/**
-	 * Unsync the filter from the transport
-	 */
-	unsync(): this {
-		this._lfoL.unsync();
-		this._lfoR.unsync();
-		this.context.transport.unsyncSignal(this.frequency);
-		return this;
-	}
-
 	/**
 	 * The oscillator type.
 	 */
@@ -181,11 +117,8 @@ export class Tremolo extends StereoEffect<TremoloOptions> {
 
 	dispose(): this {
 		super.dispose();
-		this._lfoL.dispose();
-		this._lfoR.dispose();
 		this._amplitudeL.dispose();
 		this._amplitudeR.dispose();
-		this.frequency.dispose();
 		this.depth.dispose();
 		return this;
 	}

package/Tone/effect/Vibrato.ts

@@ -66,15 +66,17 @@ export class Vibrato extends Effect<VibratoOptions> {
 			max: options.maxDelay,
 			frequency: options.frequency,
 			phase: -90, // offset the phase so the resting position is in the center
-		})
-			.start()
-			.connect(this._delayNode.delayTime);
+		}).connect(this._delayNode.delayTime);
 		this.frequency = this._lfo.frequency;
 		this.depth = this._lfo.amplitude;
 
 		this.depth.value = options.depth;
 		readOnly(this, ["frequency", "depth"]);
 		this.effectSend.chain(this._delayNode, this.effectReturn);
+
+		this._onContextRunning(() => {
+			this._lfo.start();
+		});
 	}
 
 	static getDefaults(): VibratoOptions {

package/Tone/signal/ToneConstantSource.ts

@@ -49,24 +49,16 @@ export class ToneConstantSource<
 		);
 		super(options);
 
-		const isSuspended =
-			!this.context.isOffline && this.context.state !== "running";
-
-		if (!isSuspended) {
-			this._source = this.context.createConstantSource();
-			connect(this._source, this._gainNode);
-		} else {
-			this.context.on("statechange", this._contextStarted);
-		}
+		this._onContextRunning(() => this._contextStarted());
 
 		this.offset = new Param({
 			context: this.context,
 			convert: options.convert,
-			param: isSuspended
+			param: !this._source
 				? // placeholder param until the context is started
 					this.context.createGain().gain
-				: this._source?.offset,
-			swappable: isSuspended,
+				: this._source.offset,
+			swappable: !this._source,
 			units: options.units,
 			value: options.offset,
 			minValue: options.minValue,
@@ -85,17 +77,14 @@ export class ToneConstantSource<
 	/**
 	 * Once the context is started, kick off source.
 	 */
-	private readonly _contextStarted = (state: AudioContextState) => {
-		if (state !== "running") {
-			return;
-		}
+	private _contextStarted() {
 		this._source = this.context.createConstantSource();
 		connect(this._source, this._gainNode);
-		this.offset.setParam(this._source.offset);
+		this.offset?.setParam(this._source.offset);
 		if (this.state === "started") {
 			this._source.start(0);
 		}
-	};
+	}
 
 	/**
 	 * Start the source node at the given time
@@ -123,7 +112,6 @@ export class ToneConstantSource<
 		}
 		this._source?.disconnect();
 		this.offset.dispose();
-		this.context.off("statechange", this._contextStarted);
 		return this;
 	}
 }

package/Tone/signal/WaveShaper.ts

@@ -66,14 +66,9 @@ export class WaveShaper extends SignalOperator<WaveShaperOptions> {
 		);
 		super(options);
 
-		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);
-		}
+		this._onContextRunning(() => {
+			this.initCurve(options.mapping, options.length);
+		});
 	}
 
 	static getDefaults(): WaveShaperOptions {
@@ -82,6 +77,18 @@ export class WaveShaper extends SignalOperator<WaveShaperOptions> {
 		});
 	}
 
+	/**
+	 * Set the curve for the first time. This is run only after the audio context is
+	 * running to avoid any context warnings.
+	 */
+	private initCurve(mapping?: WaveShaperMapping, length?: number): void {
+		if (isArray(mapping) || mapping instanceof Float32Array) {
+			this.curve = Float32Array.from(mapping);
+		} else if (isFunction(mapping)) {
+			this.setMap(mapping, length);
+		}
+	}
+
 	/**
 	 * Uses a mapping function to set the value of the curve.
 	 * @param mapping The function used to define the values.

package/Tone/source/UserMedia.test.ts

@@ -1,7 +1,11 @@
-import { expect } from "chai";
+import { expect, use } from "chai";
+import sinon from "sinon";
+import sinonChai from "sinon-chai";
+use(sinonChai);
 
 import { BasicTests } from "../../test/helper/Basic.js";
-import { OfflineContext } from "../core/index.js";
+import { Context } from "../core/context/Context.js";
+import { OfflineContext } from "../core/context/OfflineContext.js";
 import { UserMedia } from "./UserMedia.js";
 
 describe("UserMedia", () => {
@@ -37,139 +41,154 @@ describe("UserMedia", () => {
 		});
 	});
 
-	context("Opening and closing", function () {
-		// long timeout to give testers time to allow the microphone
-		this.timeout(100000);
-
-		let HAS_USER_MEDIA_INPUTS = false;
-
-		before(() => {
-			return UserMedia.enumerateDevices().then((devices) => {
-				HAS_USER_MEDIA_INPUTS = devices.length > 0;
-			});
+	context("Opening and closing", () => {
+		beforeEach(() => {
+			const mockTrack = { stop: sinon.stub() };
+			const mockStream = {
+				active: true,
+				getAudioTracks: () => [mockTrack],
+			} as unknown as MediaStream;
+			const mockMediaStreamSource = {
+				connect: sinon.stub(),
+				disconnect: sinon.stub(),
+				numberOfOutputs: 1,
+			} as unknown as MediaStreamAudioSourceNode;
+			sinon.stub(UserMedia, "enumerateDevices").resolves([
+				{
+					deviceId: "default",
+					groupId: "default",
+					label: "Default Device",
+				},
+				{
+					deviceId: "other",
+					groupId: "default",
+					label: "Other Device",
+				},
+			] as MediaDeviceInfo[]);
+			sinon
+				.stub(navigator.mediaDevices, "getUserMedia")
+				.resolves(mockStream);
+			sinon
+				.stub(Context.prototype, "createMediaStreamSource")
+				.returns(mockMediaStreamSource);
+		});
+
+		afterEach(() => {
+			sinon.restore();
+		});
+
+		it("open returns a promise", async () => {
+			const extIn = new UserMedia();
+			const promise = extIn.open();
+			expect(promise).to.be.instanceOf(Promise);
+			await promise;
+			extIn.dispose();
 		});
 
-		it("open returns a promise", () => {
-			if (HAS_USER_MEDIA_INPUTS) {
-				const extIn = new UserMedia();
-				const promise = extIn.open();
-				expect(promise).to.have.property("then");
-				return promise.then(() => {
-					extIn.dispose();
-				});
-			}
+		it("can open an input", async () => {
+			const extIn = new UserMedia();
+			await extIn.open();
+			extIn.dispose();
 		});
 
-		it("can open an input", () => {
-			if (HAS_USER_MEDIA_INPUTS) {
-				const extIn = new UserMedia();
-				return extIn.open().then(() => {
-					extIn.dispose();
-				});
-			}
+		it("can open an input by name", async () => {
+			const extIn = new UserMedia();
+			const devices = await UserMedia.enumerateDevices();
+			const name = devices[0].deviceId;
+
+			await extIn.open(name);
+
+			expect(extIn.deviceId).to.equal(name);
+			expect(navigator.mediaDevices.getUserMedia).to.have.been.calledWith(
+				sinon.match.hasNested("audio.deviceId", name)
+			);
+			extIn.dispose();
 		});
 
-		it("can open an input by name", () => {
-			if (HAS_USER_MEDIA_INPUTS) {
-				const extIn = new UserMedia();
-				let name: string;
-				return UserMedia.enumerateDevices()
-					.then((devices) => {
-						name = devices[0].deviceId;
-						return extIn.open(name);
-					})
-					.then(() => {
-						expect(extIn.deviceId).to.equal(name);
-						extIn.dispose();
-					});
-			}
+		it("can open an input by index", async () => {
+			const extIn = new UserMedia();
+
+			await extIn.open(0);
+
+			expect(navigator.mediaDevices.getUserMedia).to.have.been.calledWith(
+				sinon.match.hasNested("audio.deviceId", "default")
+			);
+			extIn.dispose();
 		});
 
-		it("can open an input by index", () => {
-			if (HAS_USER_MEDIA_INPUTS) {
-				const extIn = new UserMedia();
-				return extIn.open(0).then(() => {
-					extIn.dispose();
-				});
-			}
+		it("can pass in additional constraints", async () => {
+			const extIn = new UserMedia();
+			await extIn.open({
+				preferCurrentTab: true,
+			});
+			expect(navigator.mediaDevices.getUserMedia).to.have.been.calledWith(
+				sinon.match.hasNested("preferCurrentTab", true)
+			);
+			extIn.dispose();
 		});
 
-		it("throws an error if it cant find the device name", () => {
-			if (HAS_USER_MEDIA_INPUTS) {
-				const extIn = new UserMedia();
-				return extIn
-					.open("doesn't exist")
-					.then(() => {
-						throw new Error("shouldn't call 'then'");
-					})
-					.catch(() => {
-						extIn.dispose();
-					});
+		it("throws an error if it cant find the device name", async () => {
+			const extIn = new UserMedia();
+			try {
+				await extIn.open("doesn't exist");
+				throw new Error("shouldn't reach here");
+			} catch {
+				extIn.dispose();
 			}
 		});
 
-		it("is 'started' after media is open and 'stopped' otherwise", () => {
-			if (HAS_USER_MEDIA_INPUTS) {
-				const extIn = new UserMedia();
-				expect(extIn.state).to.equal("stopped");
-				return extIn.open().then(() => {
-					expect(extIn.state).to.equal("started");
-					extIn.dispose();
-				});
-			}
+		it("is 'started' after media is open and 'stopped' otherwise", async () => {
+			const extIn = new UserMedia();
+			expect(extIn.state).to.equal("stopped");
+
+			await extIn.open();
+
+			expect(extIn.state).to.equal("started");
+			extIn.dispose();
 		});
 
-		it("has a label, group and device id when open", () => {
-			if (HAS_USER_MEDIA_INPUTS) {
-				const extIn = new UserMedia();
-				return extIn.open().then(() => {
-					expect(extIn.deviceId).to.be.a("string");
-					expect(extIn.groupId).to.be.a("string");
-					expect(extIn.label).to.be.a("string");
-					extIn.dispose();
-				});
-			}
+		it("has a label, group and device id when open", async () => {
+			const extIn = new UserMedia();
+			expect(extIn.deviceId).to.be.undefined;
+			expect(extIn.groupId).to.be.undefined;
+			expect(extIn.label).to.be.undefined;
+
+			await extIn.open();
+
+			expect(extIn.deviceId).to.be.a("string");
+			expect(extIn.groupId).to.be.a("string");
+			expect(extIn.label).to.be.a("string");
+			extIn.dispose();
 		});
 
-		it("can reopen an input", () => {
-			if (HAS_USER_MEDIA_INPUTS) {
-				const extIn = new UserMedia();
-				return extIn
-					.open()
-					.then(() => {
-						return extIn.open();
-					})
-					.then(() => {
-						extIn.dispose();
-					});
-			}
+		it("can reopen an input", async () => {
+			const extIn = new UserMedia();
+			await extIn.open();
+			extIn.close();
+			await extIn.open();
+			extIn.dispose();
 		});
 
-		it("can close an input", () => {
-			if (HAS_USER_MEDIA_INPUTS) {
-				const extIn = new UserMedia();
-				return extIn.open().then(() => {
-					extIn.close();
-					extIn.dispose();
-				});
-			}
+		it("can close an input", async () => {
+			const extIn = new UserMedia();
+			await extIn.open();
+			extIn.close();
+			extIn.dispose();
 		});
 
-		it("can enumerate devices", () => {
-			return UserMedia.enumerateDevices().then((devices) => {
-				expect(devices).to.be.instanceOf(Array);
-			});
+		it("can enumerate devices", async () => {
+			const devices = await UserMedia.enumerateDevices();
+			expect(devices).to.be.instanceOf(Array);
 		});
 
-		it("doesn't work in OfflineContext", (done) => {
-			if (HAS_USER_MEDIA_INPUTS) {
-				const context = new OfflineContext(2, 2, 44100);
-				const extIn = new UserMedia({ context });
-				extIn.open().catch(() => {
-					done();
-				});
-			} else {
-				done();
+		it("doesn't work in OfflineContext", async () => {
+			const context = new OfflineContext(2, 2, 44100);
+			const extIn = new UserMedia({ context });
+			try {
+				await extIn.open();
+				throw new Error("shouldn't reach here");
+			} catch {
+				// expected to throw in OfflineContext
 			}
 		});
 	});