tone 15.2.1 → 15.2.3

package/Tone/effect/AutoFilter.test.ts

@@ -86,30 +86,28 @@ describe("AutoFilter", () => {
 			autoFilter.dispose();
 		});
 
-		it("can sync the frequency to the transport", () => {
-			return Offline(({ transport }) => {
+		it("can sync the frequency to the transport", async () => {
+			const buffer = await Offline(({ transport }) => {
 				const autoFilter = new AutoFilter(2);
 				autoFilter.sync();
 				autoFilter.frequency.toDestination();
 				transport.bpm.setValueAtTime(transport.bpm.value * 2, 0.05);
 				// transport.start(0)
-			}, 0.1).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
-				expect(buffer.getValueAtTime(0.05)).to.be.closeTo(4, 0.1);
-			});
+			}, 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", () => {
-			return Offline(({ transport }) => {
+		it("can unsync the frequency to the transport", async () => {
+			const buffer = await Offline(({ transport }) => {
 				const autoFilter = new AutoFilter(2);
 				autoFilter.sync();
 				autoFilter.frequency.toDestination();
 				transport.bpm.setValueAtTime(transport.bpm.value * 2, 0.05);
 				autoFilter.unsync();
-			}, 0.1).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
-				expect(buffer.getValueAtTime(0.05)).to.be.closeTo(2, 0.1);
-			});
+			}, 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/AutoPanner.test.ts

@@ -62,31 +62,29 @@ describe("AutoPanner", () => {
 			autoPanner.dispose();
 		});
 
-		it("can sync the frequency to the transport", () => {
-			return Offline(({ transport }) => {
+		it("can sync the frequency to the transport", async () => {
+			const buffer = await Offline(({ transport }) => {
 				const panner = new AutoPanner(2);
 				panner.sync();
 				panner.frequency.toDestination();
 				transport.bpm.setValueAtTime(transport.bpm.value * 2, 0.05);
 				// transport.start(0)
-			}, 0.1).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
-				expect(buffer.getValueAtTime(0.05)).to.be.closeTo(4, 0.1);
-			});
+			}, 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", () => {
-			return Offline(({ transport }) => {
+		it("can unsync the frequency to the transport", async () => {
+			const buffer = await Offline(({ transport }) => {
 				const panner = new AutoPanner(2);
 				panner.sync();
 				panner.frequency.toDestination();
 				transport.bpm.setValueAtTime(transport.bpm.value * 2, 0.05);
 				panner.unsync();
 				// transport.start(0)
-			}, 0.1).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
-				expect(buffer.getValueAtTime(0.05)).to.be.closeTo(2, 0.1);
-			});
+			}, 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/AutoWah.ts

@@ -75,7 +75,7 @@ export class AutoWah extends Effect<AutoWahOptions> {
 	private _bandpass: Filter;
 
 	/**
-	 * The peaking fitler
+	 * The peaking filter
 	 */
 	private _peaking: Filter;
 

package/Tone/effect/Chorus.test.ts

@@ -60,31 +60,27 @@ describe("Chorus", () => {
 			chorus.dispose();
 		});
 
-		it("can sync the frequency to the transport", () => {
-			return Offline(({ transport }) => {
+		it("can sync the frequency to the transport", async () => {
+			const buffer = await Offline(({ transport }) => {
 				const chorus = new Chorus(2);
 				chorus.sync();
 				chorus.frequency.toDestination();
 				transport.bpm.setValueAtTime(transport.bpm.value * 2, 0.05);
-				// transport.start(0)
-			}, 0.1).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
-				expect(buffer.getValueAtTime(0.05)).to.be.closeTo(4, 0.1);
-			});
+			}, 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", () => {
-			return Offline(({ transport }) => {
+		it("can unsync the frequency to the transport", async () => {
+			const buffer = await Offline(({ transport }) => {
 				const chorus = new Chorus(2);
 				chorus.sync();
 				chorus.frequency.toDestination();
 				transport.bpm.setValueAtTime(transport.bpm.value * 2, 0.05);
 				chorus.unsync();
-				// transport.start(0)
-			}, 0.1).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
-				expect(buffer.getValueAtTime(0.05)).to.be.closeTo(2, 0.1);
-			});
+			}, 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/FrequencyShifter.test.ts

@@ -41,17 +41,16 @@ describe("FrequencyShifter", () => {
 			shifter.dispose();
 		});
 
-		it("passes audio from input to output", () => {
-			return Offline(() => {
+		it("passes audio from input to output", async () => {
+			const buffer = await Offline(() => {
 				const osc = new Oscillator();
 				osc.start(0).stop(0.1);
 				const shifter = new FrequencyShifter(0.2).toDestination();
 				osc.connect(shifter);
-			}, 0.3).then((buffer) => {
-				expect(buffer.getRmsAtTime(0.05)).to.be.greaterThan(0);
-				expect(buffer.getRmsAtTime(0.1)).to.be.greaterThan(0);
-				expect(buffer.getRmsAtTime(0.2)).to.be.greaterThan(0);
-			});
+			}, 0.3);
+			expect(buffer.getRmsAtTime(0.05)).to.be.greaterThan(0);
+			expect(buffer.getRmsAtTime(0.1)).to.be.greaterThan(0);
+			expect(buffer.getRmsAtTime(0.2)).to.be.greaterThan(0);
 		});
 	});
 });

package/Tone/effect/FrequencyShifter.ts

@@ -20,7 +20,7 @@ export interface FrequencyShifterOptions extends EffectOptions {
  * Note: Contrary to pitch shifting, all frequencies are shifted by the same amount,
  * destroying the harmonic relationship between them. This leads to the classic ring modulator timbre distortion.
  * The algorithm will produces some aliasing towards the high end, especially if your source material
- * contains a lot of high frequencies. Unfortunatelly the webaudio API does not support resampling
+ * contains a lot of high frequencies. Unfortunately the Web Audio API does not support resampling
  * buffers in real time, so it is not possible to fix it properly. Depending on the use case it might
  * be an option to low pass filter your input before frequency shifting it to get ride of the aliasing.
  * You can find a very detailed description of the algorithm here: https://larzeitlin.github.io/RMFS/

package/Tone/effect/MidSideEffect.ts

@@ -10,7 +10,7 @@ export type MidSideEffectOptions = EffectOptions;
  * (which comes out of both the left and the right channel)
  * and the 'side' (which only comes out of the the side channels)
  * and effects them separately before being recombined.
- * Applies a Mid/Side seperation and recombination.
+ * Applies a Mid/Side separation and recombination.
  * Algorithm found in [kvraudio forums](http://www.kvraudio.com/forum/viewtopic.php?t=212587).
  * This is a base-class for Mid/Side Effects.
  * @category Effect

package/Tone/effect/Reverb.test.ts

@@ -36,38 +36,35 @@ describe("Reverb", () => {
 			reverb.dispose();
 		});
 
-		it("can generate an IR", () => {
+		it("can generate an IR", async () => {
 			const reverb = new Reverb();
 			const promise = reverb.generate();
 			expect(promise).to.have.property("then");
-			return promise.then(() => {
-				reverb.dispose();
-			});
+			await promise;
+			reverb.dispose();
 		});
 
-		it.skip("is silent before the reverb is generated", () => {
-			return Offline(() => {
+		it.skip("is silent before the reverb is generated", async () => {
+			const buffer = await Offline(() => {
 				const osc = new Oscillator();
 				osc.start(0).stop(0.1);
 				const reverb = new Reverb(0.2).toDestination();
 				osc.connect(reverb);
-			}).then((buffer) => {
-				expect(buffer.isSilent()).to.be.true;
 			});
+			expect(buffer.isSilent()).to.be.true;
 		});
 
-		it("passes audio from input to output", () => {
-			return Offline(async () => {
+		it("passes audio from input to output", async () => {
+			const buffer = await Offline(async () => {
 				const osc = new Oscillator();
 				osc.start(0).stop(0.1);
 				const reverb = new Reverb(0.2).toDestination();
 				osc.connect(reverb);
 				await reverb.ready;
-			}, 0.3).then((buffer) => {
-				expect(buffer.getRmsAtTime(0.05)).to.be.greaterThan(0);
-				expect(buffer.getRmsAtTime(0.1)).to.be.greaterThan(0);
-				expect(buffer.getRmsAtTime(0.2)).to.be.greaterThan(0);
-			});
+			}, 0.3);
+			expect(buffer.getRmsAtTime(0.05)).to.be.greaterThan(0);
+			expect(buffer.getRmsAtTime(0.1)).to.be.greaterThan(0);
+			expect(buffer.getRmsAtTime(0.2)).to.be.greaterThan(0);
 		});
 
 		it("parses number from string in input", () => {

package/Tone/effect/StereoWidener.ts

@@ -15,7 +15,7 @@ export interface StereoWidenerOptions extends MidSideEffectOptions {
 }
 
 /**
- * Applies a width factor to the mid/side seperation.
+ * Applies a width factor to the mid/side separation.
  * 0 is all mid and 1 is all side.
  * Algorithm found in [kvraudio forums](http://www.kvraudio.com/forum/viewtopic.php?t=212587).
  * ```

package/Tone/effect/Tremolo.test.ts

@@ -60,29 +60,27 @@ describe("Tremolo", () => {
 			tremolo.dispose();
 		});
 
-		it("can sync the frequency to the transport", () => {
-			return Offline(({ transport }) => {
+		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).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
-				expect(buffer.getValueAtTime(0.05)).to.be.closeTo(4, 0.1);
-			});
+			}, 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", () => {
-			return Offline(({ transport }) => {
+		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).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
-				expect(buffer.getValueAtTime(0.05)).to.be.closeTo(2, 0.1);
-			});
+			}, 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/Vibrato.ts

@@ -65,7 +65,7 @@ export class Vibrato extends Effect<VibratoOptions> {
 			min: 0,
 			max: options.maxDelay,
 			frequency: options.frequency,
-			phase: -90, // offse the phase so the resting position is in the center
+			phase: -90, // offset the phase so the resting position is in the center
 		})
 			.start()
 			.connect(this._delayNode.delayTime);

package/Tone/event/Loop.test.ts

@@ -97,22 +97,21 @@ describe("Loop", () => {
 			}, 0.3);
 		});
 
-		it("is invoked after it's started", () => {
+		it("is invoked after it's started", async () => {
 			let invoked = false;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				const loop = new Loop(() => {
 					invoked = true;
 					loop.dispose();
 				}, 0.05).start(0);
 				transport.start();
-			}).then(() => {
-				expect(invoked).to.be.true;
 			});
+			expect(invoked).to.be.true;
 		});
 
-		it("passes in the scheduled time to the callback", () => {
+		it("passes in the scheduled time to the callback", async () => {
 			let invoked = false;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				const now = transport.now() + 0.1;
 				const loop = new Loop((time) => {
 					expect(time).to.be.a("number");
@@ -122,9 +121,8 @@ describe("Loop", () => {
 				});
 				transport.start(now);
 				loop.start(0.3);
-			}, 0.5).then(() => {
-				expect(invoked).to.be.true;
-			});
+			}, 0.5);
+			expect(invoked).to.be.true;
 		});
 
 		it("can mute the callback", () => {
@@ -218,9 +216,9 @@ describe("Loop", () => {
 	});
 
 	context("Looping", () => {
-		it("loops", () => {
+		it("loops", async () => {
 			let callCount = 0;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				new Loop({
 					interval: 0.1,
 					callback: () => {
@@ -228,14 +226,13 @@ describe("Loop", () => {
 					},
 				}).start(0);
 				transport.start();
-			}, 0.81).then(() => {
-				expect(callCount).to.equal(9);
-			});
+			}, 0.81);
+			expect(callCount).to.equal(9);
 		});
 
-		it("loops for the specified interval", () => {
+		it("loops for the specified interval", async () => {
 			let invoked = false;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				let lastCall;
 				new Loop({
 					interval: "8n",
@@ -248,14 +245,13 @@ describe("Loop", () => {
 					},
 				}).start(0);
 				transport.start();
-			}, 1).then(() => {
-				expect(invoked).to.be.true;
-			});
+			}, 1);
+			expect(invoked).to.be.true;
 		});
 
-		it("can loop a specific number of iterations", () => {
+		it("can loop a specific number of iterations", async () => {
 			let callCount = 0;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				new Loop({
 					interval: 0.1,
 					iterations: 2,
@@ -264,13 +260,12 @@ describe("Loop", () => {
 					},
 				}).start(0);
 				transport.start();
-			}, 0.4).then(() => {
-				expect(callCount).to.equal(2);
-			});
+			}, 0.4);
+			expect(callCount).to.equal(2);
 		});
 
-		it("reports the progress of the loop", () => {
-			return Offline(({ transport }) => {
+		it("reports the progress of the loop", async () => {
+			await Offline(({ transport }) => {
 				const loop = new Loop({
 					interval: 1,
 				}).start(0);
@@ -283,9 +278,9 @@ describe("Loop", () => {
 	});
 
 	context("playbackRate", () => {
-		it("can adjust the playbackRate", () => {
+		it("can adjust the playbackRate", async () => {
 			let invoked = false;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				let lastCall;
 				const loop = new Loop({
 					playbackRate: 2,
@@ -300,14 +295,13 @@ describe("Loop", () => {
 				}).start(0);
 				expect(loop.playbackRate).to.equal(2);
 				transport.start();
-			}, 0.7).then(() => {
-				expect(invoked).to.be.true;
-			});
+			}, 0.7);
+			expect(invoked).to.be.true;
 		});
 
-		it("can playback at a faster rate", () => {
+		it("can playback at a faster rate", async () => {
 			let callCount = 0;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				const loop = new Loop({
 					interval: 0.1,
 					callback: () => {
@@ -317,9 +311,8 @@ describe("Loop", () => {
 				loop.playbackRate = 1.5;
 				expect(loop.playbackRate).to.equal(1.5);
 				transport.start();
-			}, 0.81).then(() => {
-				expect(callCount).to.equal(13);
-			});
+			}, 0.81);
+			expect(callCount).to.equal(13);
 		});
 	});
 });