tone 15.2.1 → 15.2.3

package/Tone/component/envelope/Envelope.ts

@@ -116,7 +116,7 @@ export class Envelope extends ToneAudioNode<EnvelopeOptions> {
 
 	/**
 	 * After triggerRelease is called, the envelope's
-	 * value will fall to it's miminum value over the
+	 * value will fall to its minimum value over the
 	 * duration of the release time.
 	 * ```
 	 *           /\

package/Tone/component/filter/BiquadFilter.test.ts

@@ -89,16 +89,15 @@ describe("BiquadFilter", () => {
 			filter.dispose();
 		});
 
-		it("attenuates the incoming signal", () => {
-			return Offline(() => {
+		it("attenuates the incoming signal", async () => {
+			const buffer = await Offline(() => {
 				const filter = new BiquadFilter(700, "lowpass").toDestination();
 				filter.Q.value = 0;
 				const osc = new Oscillator(880).connect(filter);
 				osc.start(0);
-			}, 0.2).then((buffer) => {
-				expect(buffer.getRmsAtTime(0.05)).to.be.within(0.37, 0.53);
-				expect(buffer.getRmsAtTime(0.1)).to.be.within(0.37, 0.53);
-			});
+			}, 0.2);
+			expect(buffer.getRmsAtTime(0.05)).to.be.within(0.37, 0.53);
+			expect(buffer.getRmsAtTime(0.1)).to.be.within(0.37, 0.53);
 		});
 	});
 });

package/Tone/component/filter/Convolver.test.ts

@@ -41,19 +41,16 @@ describe("Convolver", () => {
 			});
 		});
 
-		it("load returns a Promise", (done) => {
+		it("load returns a Promise", async () => {
 			const convolver = new Convolver();
-			convolver.load(testFile).then(() => {
-				convolver.dispose();
-				done();
-			});
+			await convolver.load(testFile);
+			convolver.dispose();
 		});
 
-		it("load invokes the second callback", () => {
+		it("load invokes the second callback", async () => {
 			const convolver = new Convolver();
-			return convolver.load(testFile).then(() => {
-				convolver.dispose();
-			});
+			await convolver.load(testFile);
+			convolver.dispose();
 		});
 
 		it("can assign the buffer twice", () => {

package/Tone/component/filter/FeedbackCombFilter.test.ts

@@ -42,24 +42,23 @@ describe("FeedbackCombFilter", () => {
 			});
 		});
 
-		it("can delay by the delayTime", () => {
-			return Offline(() => {
+		it("can delay by the delayTime", async () => {
+			const buffer = await Offline(() => {
 				const fbcf = new FeedbackCombFilter({
 					delayTime: 0.1,
 					resonance: 0,
 				}).toDestination();
 				const sig = new Signal(0).connect(fbcf);
 				sig.setValueAtTime(1, 0);
-			}, 0.2).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.equal(0);
-				expect(buffer.getValueAtTime(0.999)).to.equal(0);
-				expect(buffer.getValueAtTime(0.101)).to.equal(1);
-				expect(buffer.getValueAtTime(0.15)).to.equal(1);
-			});
+			}, 0.2);
+			expect(buffer.getValueAtTime(0)).to.equal(0);
+			expect(buffer.getValueAtTime(0.999)).to.equal(0);
+			expect(buffer.getValueAtTime(0.101)).to.equal(1);
+			expect(buffer.getValueAtTime(0.15)).to.equal(1);
 		});
 
-		it("can delay with feedback", () => {
-			return Offline(() => {
+		it("can delay with feedback", async () => {
+			const buffer = await Offline(() => {
 				const fbcf = new FeedbackCombFilter({
 					delayTime: 0.1,
 					resonance: 0.5,
@@ -67,12 +66,11 @@ describe("FeedbackCombFilter", () => {
 				const sig = new Signal(0).connect(fbcf);
 				sig.setValueAtTime(1, 0);
 				sig.setValueAtTime(0, 0.1);
-			}, 0.4).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.equal(0);
-				expect(buffer.getValueAtTime(0.101)).to.equal(1);
-				expect(buffer.getValueAtTime(0.201)).to.equal(0.5);
-				expect(buffer.getValueAtTime(0.301)).to.equal(0.25);
-			});
+			}, 0.4);
+			expect(buffer.getValueAtTime(0)).to.equal(0);
+			expect(buffer.getValueAtTime(0.101)).to.equal(1);
+			expect(buffer.getValueAtTime(0.201)).to.equal(0.5);
+			expect(buffer.getValueAtTime(0.301)).to.equal(0.25);
 		});
 	});
 

package/Tone/component/filter/Filter.test.ts

@@ -110,16 +110,15 @@ describe("Filter", () => {
 			filter.dispose();
 		});
 
-		it("attenuates the incoming signal", () => {
-			return Offline(() => {
+		it("attenuates the incoming signal", async () => {
+			const buffer = await Offline(() => {
 				const filter = new Filter(700, "lowpass").toDestination();
 				filter.Q.value = 0;
 				const osc = new Oscillator(880).connect(filter);
 				osc.start(0);
-			}, 0.2).then((buffer) => {
-				expect(buffer.getRmsAtTime(0.05)).to.be.within(0.37, 0.53);
-				expect(buffer.getRmsAtTime(0.1)).to.be.within(0.37, 0.53);
-			});
+			}, 0.2);
+			expect(buffer.getRmsAtTime(0.05)).to.be.within(0.37, 0.53);
+			expect(buffer.getRmsAtTime(0.1)).to.be.within(0.37, 0.53);
 		});
 	});
 });

package/Tone/component/filter/LowpassCombFilter.test.ts

@@ -41,8 +41,8 @@ describe("LowpassCombFilter", () => {
 			});
 		});
 
-		it("produces a decay signal at high resonance", () => {
-			return Offline(() => {
+		it("produces a decay signal at high resonance", async () => {
+			const buffer = await Offline(() => {
 				const lpcf = new LowpassCombFilter(
 					0.01,
 					0.9,
@@ -51,27 +51,25 @@ describe("LowpassCombFilter", () => {
 				const burst = new Oscillator(440).connect(lpcf);
 				burst.start(0);
 				burst.stop(0.1);
-			}, 0.8).then((buffer) => {
-				expect(buffer.getRmsAtTime(0.05)).to.be.within(0.2, 0.6);
-				expect(buffer.getRmsAtTime(0.1)).to.be.within(0.2, 0.6);
-				expect(buffer.getRmsAtTime(0.15)).to.be.within(0.15, 0.4);
-				expect(buffer.getRmsAtTime(0.3)).to.be.within(0.01, 0.15);
-				expect(buffer.getRmsAtTime(0.7)).to.be.below(0.01);
-			});
+			}, 0.8);
+			expect(buffer.getRmsAtTime(0.05)).to.be.within(0.2, 0.6);
+			expect(buffer.getRmsAtTime(0.1)).to.be.within(0.2, 0.6);
+			expect(buffer.getRmsAtTime(0.15)).to.be.within(0.15, 0.4);
+			expect(buffer.getRmsAtTime(0.3)).to.be.within(0.01, 0.15);
+			expect(buffer.getRmsAtTime(0.7)).to.be.below(0.01);
 		});
 
-		it("produces a decay signal at moderate resonance", () => {
-			return Offline(() => {
+		it("produces a decay signal at moderate resonance", async () => {
+			const buffer = await Offline(() => {
 				const lpcf = new LowpassCombFilter(0.05, 0.5).toDestination();
 				const burst = new Oscillator(440).connect(lpcf);
 				burst.start(0);
 				burst.stop(0.1);
-			}, 0.6).then((buffer) => {
-				expect(buffer.getRmsAtTime(0.05)).to.be.closeTo(0.7, 0.1);
-				expect(buffer.getRmsAtTime(0.1)).to.be.within(0.7, 1.1);
-				expect(buffer.getRmsAtTime(0.2)).to.be.closeTo(0.25, 0.1);
-				expect(buffer.getRmsAtTime(0.4)).to.be.closeTo(0.015, 0.01);
-			});
+			}, 0.6);
+			expect(buffer.getRmsAtTime(0.05)).to.be.closeTo(0.7, 0.1);
+			expect(buffer.getRmsAtTime(0.1)).to.be.within(0.7, 1.1);
+			expect(buffer.getRmsAtTime(0.2)).to.be.closeTo(0.25, 0.1);
+			expect(buffer.getRmsAtTime(0.4)).to.be.closeTo(0.015, 0.01);
 		});
 	});
 });

package/Tone/component/filter/LowpassCombFilter.ts

@@ -51,7 +51,7 @@ export class LowpassCombFilter extends ToneAudioNode<LowpassCombFilterOptions> {
 	/**
 	 * @param delayTime The delay time of the comb filter
 	 * @param resonance The resonance (feedback) of the comb filter
-	 * @param dampening The cutoff of the lowpass filter dampens the signal as it is fedback.
+	 * @param dampening The cutoff of the lowpass filter dampens the signal as it is fed back.
 	 */
 	constructor(
 		delayTime?: Time,

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

@@ -162,41 +162,38 @@ describe("Clock", () => {
 			clock.start(startTime);
 		});
 
-		it("can be scheduled to start in the future", () => {
-			let invokations = 0;
-			return Offline(() => {
+		it("can be scheduled to start in the future", async () => {
+			let invocations = 0;
+			await Offline(() => {
 				const clock = new Clock((time) => {
-					invokations++;
+					invocations++;
 				}, 2).start(0.1);
-			}, 0.4).then(() => {
-				expect(invokations).to.equal(1);
-			});
+			}, 0.4);
+			expect(invocations).to.equal(1);
 		});
 
-		it("invokes the right number of callbacks given the duration", () => {
-			let invokations = 0;
-			return Offline(() => {
+		it("invokes the right number of callbacks given the duration", async () => {
+			let invocations = 0;
+			await Offline(() => {
 				new Clock((time) => {
-					invokations++;
+					invocations++;
 				}, 10)
 					.start(0)
 					.stop(0.45);
-			}, 0.6).then(() => {
-				expect(invokations).to.equal(5);
-			});
+			}, 0.6);
+			expect(invocations).to.equal(5);
 		});
 
-		it("can schedule the frequency of the clock", () => {
-			let invokations = 0;
-			return Offline(() => {
+		it("can schedule the frequency of the clock", async () => {
+			let invocations = 0;
+			await Offline(() => {
 				const clock = new Clock((time, ticks) => {
-					invokations++;
+					invocations++;
 				}, 2);
 				clock.start(0).stop(1.01);
 				clock.frequency.setValueAtTime(4, 0.5);
-			}, 2).then(() => {
-				expect(invokations).to.equal(4);
-			});
+			}, 2);
+			expect(invocations).to.equal(4);
 		});
 	});
 

package/Tone/core/clock/TickParam.ts

@@ -128,7 +128,7 @@ export class TickParam<
 	}
 
 	exponentialRampToValueAtTime(value: UnitMap[TypeName], time: Time): this {
-		// aproximate it with multiple linear ramps
+		// approximate it with multiple linear ramps
 		time = this.toSeconds(time);
 		const computedVal = this._fromType(value);
 

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

@@ -152,12 +152,12 @@ describe("TickSignal", () => {
 		expect(tickSignal0.getTimeOfTick(3)).to.be.closeTo(3, 0.01);
 		tickSignal0.dispose();
 
-		const tickSigna1 = new TickSignal(2);
-		expect(tickSigna1.getTimeOfTick(0)).to.be.closeTo(0, 0.01);
-		expect(tickSigna1.getTimeOfTick(1)).to.be.closeTo(0.5, 0.01);
-		expect(tickSigna1.getTimeOfTick(2)).to.be.closeTo(1, 0.01);
-		expect(tickSigna1.getTimeOfTick(3)).to.be.closeTo(1.5, 0.01);
-		tickSigna1.dispose();
+		const tickSignal = new TickSignal(2);
+		expect(tickSignal.getTimeOfTick(0)).to.be.closeTo(0, 0.01);
+		expect(tickSignal.getTimeOfTick(1)).to.be.closeTo(0.5, 0.01);
+		expect(tickSignal.getTimeOfTick(2)).to.be.closeTo(1, 0.01);
+		expect(tickSignal.getTimeOfTick(3)).to.be.closeTo(1.5, 0.01);
+		tickSignal.dispose();
 	});
 
 	it("computes the time of a given tick when setValueAtTime is scheduled", () => {
@@ -292,44 +292,41 @@ describe("TickSignal", () => {
 		});
 	});
 
-	it("outputs a signal", () => {
-		return Offline((context) => {
+	it("outputs a signal", async () => {
+		const buffer = await Offline((context) => {
 			const sched = new TickSignal(1).connect(context.destination);
 			sched.linearRampTo(3, 1, 0);
-		}, 1.01).then((buffer) => {
-			expect(buffer.getValueAtTime(0)).to.be.closeTo(1, 0.01);
-			expect(buffer.getValueAtTime(0.5)).to.be.closeTo(2, 0.01);
-			expect(buffer.getValueAtTime(1)).to.be.closeTo(3, 0.01);
-		});
+		}, 1.01);
+		expect(buffer.getValueAtTime(0)).to.be.closeTo(1, 0.01);
+		expect(buffer.getValueAtTime(0.5)).to.be.closeTo(2, 0.01);
+		expect(buffer.getValueAtTime(1)).to.be.closeTo(3, 0.01);
 	});
 
-	it("outputs a signal with bpm units", () => {
-		return Offline((context) => {
+	it("outputs a signal with bpm units", async () => {
+		const buffer = await Offline((context) => {
 			const sched = new TickSignal({
 				units: "bpm",
 				value: 120,
 			}).connect(context.destination);
 			sched.linearRampTo(60, 1, 0);
-		}, 1.01).then((buffer) => {
-			expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.01);
-			expect(buffer.getValueAtTime(0.5)).to.be.closeTo(1.5, 0.01);
-			expect(buffer.getValueAtTime(1)).to.be.closeTo(1, 0.01);
-		});
+		}, 1.01);
+		expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.01);
+		expect(buffer.getValueAtTime(0.5)).to.be.closeTo(1.5, 0.01);
+		expect(buffer.getValueAtTime(1)).to.be.closeTo(1, 0.01);
 	});
 
-	it("outputs a signal with bpm units and a multiplier", () => {
-		return Offline((context) => {
+	it("outputs a signal with bpm units and a multiplier", async () => {
+		const buffer = await Offline((context) => {
 			const sched = new TickSignal({
 				multiplier: 10,
 				units: "bpm",
 				value: 60,
 			}).connect(context.destination);
 			sched.linearRampTo(120, 1, 0);
-		}, 1.01).then((buffer) => {
-			expect(buffer.getValueAtTime(0)).to.be.closeTo(10, 0.01);
-			expect(buffer.getValueAtTime(0.5)).to.be.closeTo(15, 0.01);
-			expect(buffer.getValueAtTime(1)).to.be.closeTo(20, 0.01);
-		});
+		}, 1.01);
+		expect(buffer.getValueAtTime(0)).to.be.closeTo(10, 0.01);
+		expect(buffer.getValueAtTime(0.5)).to.be.closeTo(15, 0.01);
+		expect(buffer.getValueAtTime(1)).to.be.closeTo(20, 0.01);
 	});
 
 	context("Ticks <-> Time", () => {

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

@@ -149,7 +149,7 @@ describe("TickSource", () => {
 			source.dispose();
 		});
 
-		it("can invoke stop multiple times, takes the last invokation", () => {
+		it("can invoke stop multiple times, takes the last invocation", () => {
 			const source = new TickSource(1);
 			source.start(0).stop(3).stop(2).stop(4);
 			expect(source.getTicksAtTime(0)).to.be.closeTo(0, 0.01);