tone 15.2.1 → 15.2.3

package/Tone/core/clock/TransportRepeatEvent.test.ts

@@ -4,8 +4,8 @@ import { TransportClass } from "./Transport.js";
 import { TransportRepeatEvent } from "./TransportRepeatEvent.js";
 
 describe("TransportRepeatEvent", () => {
-	it("can be created and disposed", () => {
-		return Offline((context) => {
+	it("can be created and disposed", async () => {
+		await Offline((context) => {
 			const transport = new TransportClass({ context });
 			const event = new TransportRepeatEvent(transport, {
 				duration: 100,
@@ -16,8 +16,8 @@ describe("TransportRepeatEvent", () => {
 		});
 	});
 
-	it("generates a unique event ID", () => {
-		return Offline((context) => {
+	it("generates a unique event ID", async () => {
+		await Offline((context) => {
 			const transport = new TransportClass({ context });
 			const event = new TransportRepeatEvent(transport, {
 				time: 0,
@@ -27,8 +27,8 @@ describe("TransportRepeatEvent", () => {
 		});
 	});
 
-	it("is removed from the Transport when disposed", () => {
-		return Offline((context) => {
+	it("is removed from the Transport when disposed", async () => {
+		await Offline((context) => {
 			const transport = new TransportClass({ context });
 			const event = new TransportRepeatEvent(transport, {
 				time: 0,

package/Tone/core/context/Context.test.ts

@@ -279,20 +279,19 @@ describe("Context", () => {
 			}, 0.01);
 		});
 
-		it("is invoked in the offline context", () => {
+		it("is invoked in the offline context", async () => {
 			let invocationCount = 0;
-			return Offline((context) => {
+			await Offline((context) => {
 				context.setInterval(() => {
 					invocationCount++;
 				}, 0.01);
-			}, 0.051).then(() => {
-				expect(invocationCount).to.equal(4);
-			});
+			}, 0.051);
+			expect(invocationCount).to.equal(4);
 		});
 
-		it("is invoked in with the right interval", () => {
+		it("is invoked with the right interval", async () => {
 			let numberOfInvocations = 0;
-			return Offline((context) => {
+			await Offline((context) => {
 				let intervalTime = context.now();
 				context.setInterval(() => {
 					expect(context.now() - intervalTime).to.be.closeTo(
@@ -302,9 +301,8 @@ describe("Context", () => {
 					intervalTime = context.now();
 					numberOfInvocations++;
 				}, 0.01);
-			}, 0.051).then(() => {
-				expect(numberOfInvocations).to.equal(4);
-			});
+			}, 0.051);
+			expect(numberOfInvocations).to.equal(4);
 		});
 	});
 

package/Tone/core/context/Context.ts

@@ -394,7 +394,7 @@ export class Context extends BaseContext {
 	/**
 	 * How often the interval callback is invoked.
 	 * This number corresponds to how responsive the scheduling
-	 * can be. Setting to 0 will result in the lowest practial interval
+	 * can be. Setting to 0 will result in the lowest practical interval
 	 * based on context properties. context.updateInterval + context.lookAhead
 	 * gives you the total latency between scheduling an event and hearing it.
 	 */

package/Tone/core/context/Destination.test.ts

@@ -26,13 +26,12 @@ describe("Destination", () => {
 		});
 	});
 
-	it("passes no audio when muted", () => {
-		return Offline((context) => {
+	it("passes no audio when muted", async () => {
+		const buffer = await Offline((context) => {
 			new Oscillator().toDestination().start(0);
 			context.destination.mute = true;
-		}).then((buffer) => {
-			expect(buffer.isSilent()).to.equal(true);
 		});
+		expect(buffer.isSilent()).to.equal(true);
 	});
 
 	it("has a master volume control", () => {

package/Tone/core/context/Offline.test.ts

@@ -16,63 +16,45 @@ describe("Offline", () => {
 		return ret;
 	});
 
-	it("generates a buffer", () => {
-		return Offline(noOp, 0.01).then((buffer) => {
-			expect(buffer).to.be.instanceOf(ToneAudioBuffer);
-		});
+	it("generates a buffer", async () => {
+		const buffer = await Offline(noOp, 0.01);
+		expect(buffer).to.be.instanceOf(ToneAudioBuffer);
 	});
 
-	it("silent by default", () => {
-		return Offline(noOp, 0.01, 1).then((buffer) => {
-			const isSilent = buffer.toArray().every((sample) => sample === 0);
-			expect(isSilent).to.equal(true);
-		});
+	it("silent by default", async () => {
+		const buffer = await Offline(noOp, 0.01, 1);
+		const isSilent = buffer.toArray().every((sample) => sample === 0);
+		expect(isSilent).to.equal(true);
 	});
 
-	it("records the master output", () => {
-		return Offline(() => {
+	it("records the master output", async () => {
+		const buffer = await Offline(() => {
 			new ToneOscillatorNode().toDestination().start();
-		}, 0.01).then((buffer) => {
-			const testBuff = new TestAudioBuffer(buffer.get() as AudioBuffer);
-			expect(testBuff.isSilent()).is.equal(false);
-		});
+		}, 0.01);
+		const testBuff = new TestAudioBuffer(buffer.get() as AudioBuffer);
+		expect(testBuff.isSilent()).is.equal(false);
 	});
 
-	it("returning a promise defers the rendering till the promise resolves", () => {
+	it("returning a promise defers the rendering till the promise resolves", async () => {
 		let wasInvoked = false;
-		return Offline(() => {
+		const buffer = await Offline(() => {
 			new ToneOscillatorNode().toDestination().start();
 			return new Promise((done) => {
 				setTimeout(done, 100);
 			}).then(() => {
 				wasInvoked = true;
 			});
-		}, 0.01).then((buffer) => {
-			const testBuff = new TestAudioBuffer(buffer.get() as AudioBuffer);
-			expect(wasInvoked).is.equal(true);
-			expect(testBuff.isSilent()).to.equal(false);
-		});
+		}, 0.01);
+		const testBuff = new TestAudioBuffer(buffer.get() as AudioBuffer);
+		expect(wasInvoked).is.equal(true);
+		expect(testBuff.isSilent()).to.equal(false);
 	});
 
-	it("can schedule specific timing outputs", () => {
-		return Offline(() => {
+	it("can schedule specific timing outputs", async () => {
+		const buffer = await Offline(() => {
 			new ToneOscillatorNode().toDestination().start(0.05);
-		}, 0.1).then((buffer) => {
-			const testBuff = new TestAudioBuffer(buffer.get() as AudioBuffer);
-			expect(testBuff.getTimeOfFirstSound()).to.be.closeTo(0.05, 0.0001);
-		});
+		}, 0.1);
+		const testBuff = new TestAudioBuffer(buffer.get() as AudioBuffer);
+		expect(testBuff.getTimeOfFirstSound()).to.be.closeTo(0.05, 0.0001);
 	});
-
-	// it("can schedule Transport events", () => {
-	// 	return Offline(function (Transport) {
-	// 		var osc = new Oscillator().toDestination();
-	// 		Transport.schedule(function (time) {
-	// 			osc.start(time);
-	// 		}, 0.05);
-	// 		Transport.start(0);
-	// 	}, 0.1).then((buffer) => {
-	// 		BufferTest(buffer);
-	// 		expect(buffer.getFirstSoundTime()).to.be.closeTo(0.05, 0.001);
-	// 	});
-	// });
 });

package/Tone/core/context/OfflineContext.test.ts

@@ -25,39 +25,37 @@ context("OfflineContext", () => {
 		return ctx.close();
 	});
 
-	it("can render audio", () => {
+	it("can render audio", async () => {
 		const ctx = new OfflineContext(1, 0.2, 44100);
 		const osc = ctx.createOscillator();
 		osc.connect(ctx.rawContext.destination);
 		osc.start(0.1);
-		return ctx.render().then((buffer) => {
-			expect(buffer).to.have.property("length");
-			expect(buffer).to.have.property("sampleRate");
-			const array = buffer.getChannelData(0);
-			for (let i = 0; i < array.length; i++) {
-				if (array[i] !== 0) {
-					expect(i / array.length).to.be.closeTo(0.5, 0.01);
-					break;
-				}
+		const buffer = await ctx.render();
+		expect(buffer).to.have.property("length");
+		expect(buffer).to.have.property("sampleRate");
+		const array = buffer.getChannelData(0);
+		for (let i = 0; i < array.length; i++) {
+			if (array[i] !== 0) {
+				expect(i / array.length).to.be.closeTo(0.5, 0.01);
+				break;
 			}
-		});
+		}
 	});
 
-	it("can render audio not async", () => {
+	it("can render audio not async", async () => {
 		const ctx = new OfflineContext(1, 0.2, 44100);
 		const osc = ctx.createOscillator();
 		osc.connect(ctx.rawContext.destination);
 		osc.start(0.1);
-		return ctx.render(false).then((buffer) => {
-			expect(buffer).to.have.property("length");
-			expect(buffer).to.have.property("sampleRate");
-			const array = buffer.getChannelData(0);
-			for (let i = 0; i < array.length; i++) {
-				if (array[i] !== 0) {
-					expect(i / array.length).to.be.closeTo(0.5, 0.01);
-					break;
-				}
+		const buffer = await ctx.render(false);
+		expect(buffer).to.have.property("length");
+		expect(buffer).to.have.property("sampleRate");
+		const array = buffer.getChannelData(0);
+		for (let i = 0; i < array.length; i++) {
+			if (array[i] !== 0) {
+				expect(i / array.length).to.be.closeTo(0.5, 0.01);
+				break;
 			}
-		});
+		}
 	});
 });

package/Tone/core/context/Param.test.ts

@@ -308,9 +308,9 @@ describe("Param", () => {
 	});
 
 	context("apply", () => {
-		it("can apply a scheduled curve", () => {
+		it("can apply a scheduled curve", async () => {
 			let sig;
-			return Offline((context) => {
+			const buffer = await Offline((context) => {
 				const signal = new Signal();
 				sig = signal;
 				signal.setValueAtTime(0, 0);
@@ -325,20 +325,18 @@ describe("Param", () => {
 				return atTime(0.4, () => {
 					signal.apply(source.offset);
 				});
-			}, 2).then(async (buffer) => {
-				for (let time = 0.41; time < 2; time += 0.1) {
-					expect(buffer.getValueAtTime(time)).to.be.closeTo(
-						sig.getValueAtTime(time),
-						0.01
-					);
-				}
-				document.body.appendChild(await Plot.signal(buffer));
-			});
+			}, 2);
+			for (let time = 0.41; time < 2; time += 0.1) {
+				expect(buffer.getValueAtTime(time)).to.be.closeTo(
+					sig.getValueAtTime(time),
+					0.01
+				);
+			}
 		});
 
-		it("can apply a scheduled curve that starts with a setTargetAtTime", () => {
+		it("can apply a scheduled curve that starts with a setTargetAtTime", async () => {
 			let sig;
-			return Offline((context) => {
+			const buffer = await Offline((context) => {
 				const signal = new Signal();
 				sig = signal;
 				signal.setTargetAtTime(2, 0, 0.2);
@@ -348,20 +346,18 @@ describe("Param", () => {
 				return atTime(0.4, () => {
 					signal.apply(source.offset);
 				});
-			}, 2).then(async (buffer) => {
-				for (let time = 0.41; time < 2; time += 0.1) {
-					expect(buffer.getValueAtTime(time)).to.be.closeTo(
-						sig.getValueAtTime(time),
-						0.05
-					);
-				}
-				// document.body.appendChild(await Plot.signal(buffer));
-			});
+			}, 2);
+			for (let time = 0.41; time < 2; time += 0.1) {
+				expect(buffer.getValueAtTime(time)).to.be.closeTo(
+					sig.getValueAtTime(time),
+					0.05
+				);
+			}
 		});
 
-		it("can apply a scheduled curve that starts with a setTargetAtTime and then schedules other things", () => {
+		it("can apply a scheduled curve that starts with a setTargetAtTime and then schedules other things", async () => {
 			let sig;
-			return Offline((context) => {
+			const buffer = await Offline((context) => {
 				const signal = new Signal();
 				sig = signal;
 				signal.setTargetAtTime(2, 0, 0.2);
@@ -373,19 +369,17 @@ describe("Param", () => {
 				return atTime(0.4, () => {
 					signal.apply(source.offset);
 				});
-			}, 2).then(async (buffer) => {
-				for (let time = 0.41; time < 2; time += 0.1) {
-					expect(buffer.getValueAtTime(time)).to.be.closeTo(
-						sig.getValueAtTime(time),
-						0.05
-					);
-				}
-				// document.body.appendChild(await Plot.signal(buffer));
-			});
+			}, 2);
+			for (let time = 0.41; time < 2; time += 0.1) {
+				expect(buffer.getValueAtTime(time)).to.be.closeTo(
+					sig.getValueAtTime(time),
+					0.05
+				);
+			}
 		});
 
-		it("can set the param if the Param is marked as swappable", () => {
-			return Offline((context) => {
+		it("can set the param if the Param is marked as swappable", async () => {
+			const buffer = await Offline((context) => {
 				const constSource = context.createConstantSource();
 				const param = new Param({
 					swappable: true,
@@ -398,11 +392,10 @@ describe("Param", () => {
 				constSource2.start(0);
 				param.setParam(constSource2.offset);
 				connect(constSource2, context.destination);
-			}, 0.5).then((buffer) => {
-				expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.1, 0.001);
-				expect(buffer.getValueAtTime(0.2)).to.be.closeTo(0.2, 0.001);
-				expect(buffer.getValueAtTime(0.3)).to.be.closeTo(0.3, 0.001);
-			});
+			}, 0.5);
+			expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.1, 0.001);
+			expect(buffer.getValueAtTime(0.2)).to.be.closeTo(0.2, 0.001);
+			expect(buffer.getValueAtTime(0.3)).to.be.closeTo(0.3, 0.001);
 		});
 
 		it("throws an error if the param is not set to swappable", () => {

package/Tone/core/context/ToneAudioBuffer.test.ts

@@ -192,16 +192,9 @@ describe("ToneAudioBuffer", () => {
 			expect(hadError).to.equal(true);
 		});
 
-		it("instance .load method returns Promise", (done) => {
-			const promise = new ToneAudioBuffer().load(testFile);
-			expect(promise).to.have.property("then");
-			promise.then((buff) => {
-				expect(buff).to.be.instanceOf(ToneAudioBuffer);
-				done();
-			});
-			promise.catch(() => {
-				throw new Error("shouldn't invoke this function");
-			});
+		it("instance .load method returns Promise", async () => {
+			const buffer = await new ToneAudioBuffer().load(testFile);
+			expect(buffer).to.be.instanceOf(ToneAudioBuffer);
 		});
 
 		it("invokes the error callback if the file is corrupt", (done) => {
@@ -275,7 +268,7 @@ describe("ToneAudioBuffer", () => {
 			buffer.dispose();
 		});
 
-		it("can convert from a multidimentional array", () => {
+		it("can convert from a multidimensional array", () => {
 			const buffer = new ToneAudioBuffer();
 			const arr = [
 				new Float32Array(0.5 * buffer.sampleRate),

package/Tone/core/context/ToneAudioBuffers.test.ts

@@ -38,7 +38,7 @@ describe("ToneAudioBuffers", () => {
 		);
 	});
 
-	it("throws an error when it tries to get an object that doesnt exist", (done) => {
+	it("throws an error when it tries to get an object that doesn't exist", (done) => {
 		const buffer = new ToneAudioBuffers(
 			{
 				sine: testFile,
@@ -110,18 +110,16 @@ describe("ToneAudioBuffers", () => {
 		expect(buffer.loaded).to.be.false;
 	});
 
-	it("can load from a base url", (done) => {
+	it("can load from a base url", async () => {
 		const buffer = new ToneAudioBuffers(
 			{
 				hat: "hh.wav",
 			},
-			() => {
-				expect(buffer.get("hat")).to.be.instanceof(ToneAudioBuffer);
-				buffer.dispose();
-				done();
-			},
+			() => {},
 			"./test/audio/"
 		);
+		await ToneAudioBuffer.loaded();
+		expect(buffer.get("hat")).to.be.instanceof(ToneAudioBuffer);
 	});
 
 	it("can add a buffer", (done) => {
@@ -157,13 +155,11 @@ describe("ToneAudioBuffers", () => {
 		expect(buffer.get("name").get()).to.equal(buff.get());
 	});
 
-	it("can add an AudioBuffer", (done) => {
-		ToneAudioBuffer.load(testFile).then((buff) => {
-			const buffer = new ToneAudioBuffers();
-			buffer.add("name", buff);
-			expect(buffer.get("name").get()).to.equal(buff);
-			done();
-		});
+	it("can add an AudioBuffer", async () => {
+		const audioBuffer = await ToneAudioBuffer.load(testFile);
+		const buffer = new ToneAudioBuffers();
+		buffer.add("name", audioBuffer);
+		expect(buffer.get("name").get()).to.equal(audioBuffer);
 	});
 
 	it("can be constructed with ToneAudioBuffers", () => {

package/Tone/core/context/ToneAudioBuffers.ts

@@ -18,7 +18,7 @@ interface ToneAudioBuffersOptions {
 }
 
 /**
- * A data structure for holding multiple buffers in a Map-like datastructure.
+ * A data structure for holding multiple buffers in a Map-like data structure.
  *
  * @example
  * const pianoSamples = new Tone.ToneAudioBuffers({
@@ -141,7 +141,7 @@ export class ToneAudioBuffers extends Tone {
 	/**
 	 * Add a buffer by name and url to the Buffers
 	 * @param  name      A unique name to give the buffer
-	 * @param  url  Either the url of the bufer, or a buffer which will be added with the given name.
+	 * @param  url  Either the url of the buffer, or a buffer which will be added with the given name.
 	 * @param  callback  The callback to invoke when the url is loaded.
 	 * @param  onerror  Invoked if the buffer can't be loaded
 	 */

package/Tone/core/type/Frequency.test.ts

@@ -112,27 +112,27 @@ describe("FrequencyClass", () => {
 			});
 		});
 
-		it("evalutes hertz", () => {
+		it("evaluates hertz", () => {
 			expect(Frequency("1hz").valueOf()).to.equal(1);
 			expect(Frequency("2hz").valueOf()).to.equal(2);
 			expect(Frequency(4, "hz").valueOf()).to.equal(4);
 			expect(Frequency("0.25hz").valueOf()).to.equal(0.25);
 		});
 
-		it("evalutes ticks", () => {
+		it("evaluates ticks", () => {
 			return Offline(({ transport }) => {
 				expect(Frequency(transport.PPQ, "i").valueOf()).to.equal(2);
 				expect(Frequency(1, "i").valueOf()).to.equal(transport.PPQ * 2);
 			});
 		});
 
-		it("evalutes transport time", () => {
+		it("evaluates transport time", () => {
 			expect(Frequency("1:0").valueOf()).to.equal(0.5);
 			expect(Frequency("1:4:0").valueOf()).to.equal(0.25);
 			// expect(Frequency("2:1:0").valueOf()).to.equal(0.25);
 		});
 
-		it("evalutes midi", () => {
+		it("evaluates midi", () => {
 			expect(Frequency(48, "midi").valueOf()).to.be.closeTo(
 				TonalMidi.midiToFreq(48),
 				0.0001
@@ -143,7 +143,7 @@ describe("FrequencyClass", () => {
 			);
 		});
 
-		it("evalutes hz", () => {
+		it("evaluates hz", () => {
 			expect(Frequency(48, "hz").valueOf()).to.equal(48);
 			expect(Frequency(480, "hz").valueOf()).to.equal(480);
 		});
@@ -218,7 +218,7 @@ describe("FrequencyClass", () => {
 			);
 		});
 
-		it("can accomidate different concert tuning", () => {
+		it("can accommodate different concert tuning", () => {
 			FrequencyClass.A4 = 444;
 			expect(Frequency("C4").valueOf()).to.be.closeTo(
 				TonalMidi.midiToFreq(

package/Tone/core/type/Ticks.test.ts

@@ -133,7 +133,7 @@ describe("TicksClass", () => {
 			});
 		});
 
-		it("can get the next subdivison when the transport is started", () => {
+		it("can get the next subdivision when the transport is started", () => {
 			return Offline((context) => {
 				const transport = context.transport;
 				transport.start();

package/Tone/core/type/Time.test.ts

@@ -72,7 +72,7 @@ describe("TimeClass", () => {
 			});
 		});
 
-		it("evalutes objects", () => {
+		it("evaluates objects", () => {
 			return Offline(() => {
 				expect(Time({ "4n": 3 }).valueOf()).to.equal(1.5);
 				expect(Time({ "8t": 2, "1m": 3 }).valueOf()).to.be.closeTo(
@@ -98,7 +98,7 @@ describe("TimeClass", () => {
 			expect(Time(2).quantize(8, 0.75).valueOf()).to.equal(0.5);
 		});
 
-		it("can get the next subdivison when the transport is started", () => {
+		it("can get the next subdivision when the transport is started", () => {
 			return Offline((context) => {
 				const transport = context.transport;
 				transport.start(0.1);

package/Tone/core/type/TransportTime.test.ts

@@ -116,7 +116,7 @@ describe("TransportTimeClass", () => {
 			});
 		});
 
-		it("can get the next subdivison when the transport is started", () => {
+		it("can get the next subdivision when the transport is started", () => {
 			return Offline((context) => {
 				const transport = context.transport;
 				transport.start();

package/Tone/core/util/IntervalTimeline.test.ts

@@ -26,7 +26,7 @@ describe("IntervalTimeline", () => {
 			sched.dispose();
 		});
 
-		it("computes the lenght of the timeline correctly after adding events", () => {
+		it("computes the length of the timeline correctly after adding events", () => {
 			const sched = new IntervalTimeline();
 			sched.add({
 				duration: 0.2,

package/Tone/core/util/IntervalTimeline.ts

@@ -26,7 +26,7 @@ export class IntervalTimeline extends Tone {
 	readonly name: string = "IntervalTimeline";
 
 	/**
-	 * The root node of the inteval tree
+	 * The root node of the interval tree
 	 */
 	private _root: IntervalNode | null = null;
 

package/Tone/core/util/StateTimeline.test.ts

@@ -51,7 +51,7 @@ describe("StateTimeline", () => {
 		sched.dispose();
 	});
 
-	it("gets the last occurance of the state at or before the given time", () => {
+	it("gets the last occurrence of the state at or before the given time", () => {
 		const sched = new StateTimeline();
 		sched.setStateAtTime("started", 0);
 		sched.setStateAtTime("stopped", 1);
@@ -68,7 +68,7 @@ describe("StateTimeline", () => {
 		sched.dispose();
 	});
 
-	it("gets the next occurance of the state at or before the given time", () => {
+	it("gets the next occurrence of the state at or before the given time", () => {
 		const sched = new StateTimeline();
 		sched.setStateAtTime("started", 0);
 		sched.setStateAtTime("stopped", 1);

package/Tone/core/util/Timeline.test.ts

@@ -303,7 +303,7 @@ describe("Timeline", () => {
 		sched.dispose();
 	});
 
-	it("inforces increasing time", () => {
+	it("enforces increasing time", () => {
 		const sched = new Timeline({
 			increasing: true,
 		});

package/Tone/core/util/Timeline.ts

@@ -348,7 +348,7 @@ export class Timeline<GenericEvent extends TimelineEvent> extends Tone {
 
 	/**
 	 * Iterate over everything in the array between the startTime and endTime.
-	 * The timerange is inclusive of the startTime, but exclusive of the endTime.
+	 * The time range is inclusive of the startTime, but exclusive of the endTime.
 	 * range = [startTime, endTime).
 	 * @param  startTime The time to check if items are before
 	 * @param  endTime The end of the test interval.

package/Tone/core/worklet/ToneAudioWorklet.ts

@@ -59,7 +59,9 @@ export abstract class ToneAudioWorklet<
 		this._dummyParam = this._dummyGain.gain;
 
 		// Register the processor
-		let workletPromise = ToneAudioWorklet._workletPromises.get(this.context);
+		let workletPromise = ToneAudioWorklet._workletPromises.get(
+			this.context
+		);
 
 		if (workletPromise === undefined) {
 			workletPromise = this.context.addAudioWorkletModule(blobUrl);