tone 15.1.22 → 15.2.0

package/Tone/core/context/Context.ts

@@ -346,9 +346,9 @@ export class Context extends BaseContext {
 	//--------------------------------------------
 
 	/**
-	 * Maps a module name to promise of the addModule method
+	 * A set of unsettled promises returned by the addModule method
 	 */
-	private _workletPromise: null | Promise<void> = null;
+	private _workletPromises = new Set<Promise<void>>();
 
 	/**
 	 * Create an audio worklet node from a name and options. The module
@@ -370,17 +370,19 @@ export class Context extends BaseContext {
 			isDefined(this.rawContext.audioWorklet),
 			"AudioWorkletNode is only available in a secure context (https or localhost)"
 		);
-		if (!this._workletPromise) {
-			this._workletPromise = this.rawContext.audioWorklet.addModule(url);
-		}
-		await this._workletPromise;
+		const workletPromise = this.rawContext.audioWorklet.addModule(url);
+
+		this._workletPromises.add(workletPromise);
+		workletPromise.finally(() => this._workletPromises.delete(workletPromise));
+
+		return workletPromise;
 	}
 
 	/**
 	 * Returns a promise which resolves when all of the worklets have been loaded on this context
 	 */
 	protected async workletsAreReady(): Promise<void> {
-		(await this._workletPromise) ? this._workletPromise : Promise.resolve();
+		await Promise.all(this._workletPromises);
 	}
 
 	//---------------------------

package/Tone/core/worklet/ToneAudioWorklet.ts

@@ -59,7 +59,15 @@ export abstract class ToneAudioWorklet<
 		this._dummyParam = this._dummyGain.gain;
 
 		// Register the processor
-		this.context.addAudioWorkletModule(blobUrl).then(() => {
+		let workletPromise = ToneAudioWorklet._workletPromises.get(this.context);
+
+		if (workletPromise === undefined) {
+			workletPromise = this.context.addAudioWorkletModule(blobUrl);
+
+			ToneAudioWorklet._workletPromises.set(this.context, workletPromise);
+		}
+
+		workletPromise.then(() => {
 			// create the worklet when it's read
 			if (!this.disposed) {
 				this._worklet = this.context.createAudioWorkletNode(
@@ -73,6 +81,8 @@ export abstract class ToneAudioWorklet<
 		});
 	}
 
+	private static _workletPromises = new WeakMap<any, Promise<void>>();
+
 	dispose(): this {
 		super.dispose();
 		this._dummyGain.disconnect();

package/Tone/signal/ToneConstantSource.test.ts

@@ -1,8 +1,8 @@
 import { expect } from "chai";
 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";
+import { Context } from "../core/context/Context.js";
 
 describe("ToneConstantSource", () => {
 	BasicTests(ToneConstantSource);
@@ -36,7 +36,7 @@ describe("ToneConstantSource", () => {
 			source.stop("+0.3");
 			const now = source.now();
 			source.onended = () => {
-				expect(source.now() - now).to.be.within(0.25, 0.5);
+				expect(source.now() - now).to.be.closeTo(0.3, 0.15);
 				source.dispose();
 				done();
 			};
@@ -186,4 +186,65 @@ describe("ToneConstantSource", () => {
 			}, 0.2);
 		});
 	});
+
+	context.only("Suspended AudioContext", () => {
+		it("does nothing when AudioContext returns to suspended", () => {
+			const context = new Context();
+			expect(context.state).to.equal("suspended");
+
+			const source = new ToneConstantSource({
+				context,
+			});
+
+			source.start(0);
+
+			context.dispose();
+			source.dispose();
+		});
+
+		it("starts when the audio context is resumed", async () => {
+			const context = new Context();
+			expect(context.state).to.equal("suspended");
+
+			const source = new ToneConstantSource({
+				context,
+			});
+
+			source.start(0);
+
+			await context.resume();
+
+			context.dispose();
+			source.dispose();
+		});
+
+		it("context can be suspended again", async () => {
+			const context = new Context();
+			expect(context.state).to.equal("suspended");
+
+			const source = new ToneConstantSource({
+				context,
+			});
+
+			source.start(0);
+
+			await context.resume();
+
+			source.stop(0.1);
+
+			await context.rawContext.suspend(0);
+
+			// wait for the context to be suspended
+			await new Promise<void>((resolve) =>
+				context.on("statechange", () => {
+					if (context.state === "suspended") {
+						resolve();
+					}
+				})
+			);
+
+			context.dispose();
+			source.dispose();
+		});
+	});
 });

package/Tone/signal/ToneConstantSource.ts

@@ -29,7 +29,7 @@ export class ToneConstantSource<
 	/**
 	 * The signal generator
 	 */
-	private _source = this.context.createConstantSource();
+	private _source?: ConstantSourceNode;
 
 	/**
 	 * The offset of the signal generator
@@ -49,12 +49,24 @@ export class ToneConstantSource<
 		);
 		super(options);
 
-		connect(this._source, this._gainNode);
+		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.offset = new Param({
 			context: this.context,
 			convert: options.convert,
-			param: this._source.offset,
+			param: isSuspended
+				? // placeholder param until the context is started
+					this.context.createGain().gain
+				: this._source?.offset,
+			swappable: isSuspended,
 			units: options.units,
 			value: options.offset,
 			minValue: options.minValue,
@@ -70,6 +82,21 @@ export class ToneConstantSource<
 		});
 	}
 
+	/**
+	 * Once the context is started, kick off source.
+	 */
+	private readonly _contextStarted = (state: AudioContextState) => {
+		if (state !== "running") {
+			return;
+		}
+		this._source = this.context.createConstantSource();
+		connect(this._source, this._gainNode);
+		this.offset.setParam(this._source.offset);
+		if (this.state === "started") {
+			this._source.start(0);
+		}
+	};
+
 	/**
 	 * Start the source node at the given time
 	 * @param  time When to start the source
@@ -78,12 +105,15 @@ export class ToneConstantSource<
 		const computedTime = this.toSeconds(time);
 		this.log("start", computedTime);
 		this._startGain(computedTime);
-		this._source.start(computedTime);
+		this._source?.start(computedTime);
 		return this;
 	}
 
 	protected _stopSource(time?: Seconds): void {
-		this._source.stop(time);
+		if (this.state === "stopped") {
+			return;
+		}
+		this._source?.stop(time);
 	}
 
 	dispose(): this {
@@ -91,8 +121,9 @@ export class ToneConstantSource<
 		if (this.state === "started") {
 			this.stop();
 		}
-		this._source.disconnect();
+		this._source?.disconnect();
 		this.offset.dispose();
+		this.context.off("statechange", this._contextStarted);
 		return this;
 	}
 }

package/Tone/version.ts

@@ -1 +1 @@
-export const version: string = "15.1.22";
+export const version: string = "15.2.0";