tone 15.2.0 → 15.2.2

package/Tone/source/oscillator/LFO.test.ts

@@ -65,62 +65,57 @@ describe("LFO", () => {
 			});
 		});
 
-		it("can be creates an oscillation in a specific range", () => {
-			return Offline(() => {
+		it("can be creates an oscillation in a specific range", async () => {
+			const buffer = await Offline(() => {
 				const lfo = new LFO(100, 10, 20).toDestination();
 				lfo.start();
-			}).then((buffer) => {
-				expect(buffer.min()).to.be.gte(10);
-				expect(buffer.max()).to.be.lte(20);
 			});
+			expect(buffer.min()).to.be.gte(10);
+			expect(buffer.max()).to.be.lte(20);
 		});
 
-		it("can change the oscillation range", () => {
-			return Offline(() => {
+		it("can change the oscillation range", async () => {
+			const buffer = await Offline(() => {
 				const lfo = new LFO(100, 10, 20).toDestination();
 				lfo.start();
 				lfo.min = 15;
 				lfo.max = 18;
-			}).then((buffer) => {
-				expect(buffer.min()).to.be.gte(15);
-				expect(buffer.max()).to.be.lte(18);
 			});
+			expect(buffer.min()).to.be.gte(15);
+			expect(buffer.max()).to.be.lte(18);
 		});
 
-		it("initially outputs a signal at the center of it's phase", () => {
-			return Offline(() => {
+		it("initially outputs a signal at the center of it's phase", async () => {
+			const buffer = await Offline(() => {
 				new LFO(100, 10, 20).toDestination();
-			}).then((buffer) => {
-				expect(buffer.value()).to.be.closeTo(15, 0.1);
 			});
+			expect(buffer.value()).to.be.closeTo(15, 0.1);
 		});
 
-		it("outputs a signal at the correct phase angle", () => {
-			return Offline(() => {
+		it("outputs a signal at the correct phase angle", async () => {
+			const buffer = await Offline(() => {
 				new LFO({
 					min: 0,
 					phase: 90,
 				}).toDestination();
-			}).then((buffer) => {
-				expect(buffer.value()).to.be.closeTo(0, 0.1);
 			});
+			expect(buffer.value()).to.be.closeTo(0, 0.1);
 		});
 
-		it("outputs the right phase when setting a new phase", () => {
-			return Offline(() => {
+		it("outputs the right phase when setting a new phase", async () => {
+			const buffer = await Offline(() => {
 				const lfo = new LFO({
 					max: 1,
 					min: -1,
 					phase: 0,
 				}).toDestination();
 				lfo.phase = 270;
-			}).then((buffer) => {
-				expect(buffer.value()).to.be.closeTo(1, 0.1);
 			});
+			expect(buffer.value()).to.be.closeTo(1, 0.1);
 		});
 
-		it("can convert to other units", () => {
-			return Offline(() => {
+		it("can convert to other units", async () => {
+			const buffer = await Offline(() => {
 				const lfo = new LFO({
 					frequency: 20,
 					max: 5,
@@ -128,14 +123,13 @@ describe("LFO", () => {
 					units: "decibels",
 				}).toDestination();
 				lfo.start();
-			}).then((buffer) => {
-				expect(buffer.min()).to.be.closeTo(0.099, 0.01);
-				expect(buffer.max()).to.be.closeTo(1.78, 0.01);
 			});
+			expect(buffer.min()).to.be.closeTo(0.099, 0.01);
+			expect(buffer.max()).to.be.closeTo(1.78, 0.01);
 		});
 
-		it("can converts to the units of the connecting node", () => {
-			return Offline(() => {
+		it("can converts to the units of the connecting node", async () => {
+			const buffer = await Offline(() => {
 				const lfo = new LFO(20, -35, -10);
 				const signal = new Signal(0, "decibels");
 				expect(lfo.units).to.equal("number");
@@ -143,14 +137,13 @@ describe("LFO", () => {
 				lfo.connect(signal);
 				expect(lfo.units).to.equal("decibels");
 				lfo.start();
-			}).then((buffer) => {
-				expect(buffer.min()).to.be.closeTo(0.017, 0.01);
-				expect(buffer.max()).to.be.closeTo(0.31, 0.01);
 			});
+			expect(buffer.min()).to.be.closeTo(0.017, 0.01);
+			expect(buffer.max()).to.be.closeTo(0.31, 0.01);
 		});
 
-		it("does not convert to the connected value if that is not set to convert", () => {
-			return Offline(() => {
+		it("does not convert to the connected value if that is not set to convert", async () => {
+			const buffer = await Offline(() => {
 				const lfo = new LFO(20, -35, -10);
 				const signal = new Signal({
 					convert: false,
@@ -162,61 +155,56 @@ describe("LFO", () => {
 				lfo.connect(signal);
 				expect(lfo.units).to.equal("decibels");
 				lfo.start();
-			}).then((buffer) => {
-				expect(buffer.min()).to.be.closeTo(-35, 0.01);
-				expect(buffer.max()).to.be.closeTo(-10, 0.01);
 			});
+			expect(buffer.min()).to.be.closeTo(-35, 0.01);
+			expect(buffer.max()).to.be.closeTo(-10, 0.01);
 		});
 
-		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 lfo = new LFO(2);
 				lfo.sync();
 				lfo.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 lfo = new LFO(2);
 				lfo.sync();
 				lfo.frequency.toDestination();
 				transport.bpm.setValueAtTime(transport.bpm.value * 2, 0.05);
 				lfo.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);
 		});
 
-		it("can adjust the amplitude", () => {
-			return Offline(() => {
+		it("can adjust the amplitude", async () => {
+			const buffer = await Offline(() => {
 				const lfo = new LFO(10, -10, 10);
 				lfo.amplitude.value = 0.5;
 				lfo.toDestination();
 				lfo.start();
-			}, 0.1).then((buffer) => {
-				expect(buffer.min()).to.be.closeTo(-5, 0.1);
-				expect(buffer.max()).to.be.closeTo(5, 0.1);
-			});
+			}, 0.1);
+			expect(buffer.min()).to.be.closeTo(-5, 0.1);
+			expect(buffer.max()).to.be.closeTo(5, 0.1);
 		});
 
-		it("can adjust the amplitude not centered at 0", () => {
-			return Offline(() => {
+		it("can adjust the amplitude not centered at 0", async () => {
+			const buffer = await Offline(() => {
 				const lfo = new LFO(10, 400, 4000);
 				lfo.amplitude.value = 0.5;
 				lfo.toDestination();
 				lfo.start();
-			}, 0.1).then((buffer) => {
-				expect(buffer.min()).to.be.closeTo(1300, 1);
-				expect(buffer.max()).to.be.closeTo(3100, 1);
-			});
+			}, 0.1);
+			expect(buffer.min()).to.be.closeTo(1300, 1);
+			expect(buffer.max()).to.be.closeTo(3100, 1);
 		});
 
 		it("can pass in partials to the constructor", () => {

package/Tone/source/oscillator/Oscillator.test.ts

@@ -49,41 +49,39 @@ describe("Oscillator", () => {
 	});
 
 	context("Phase Rotation", () => {
-		it("can change the phase to 90", () => {
-			return Offline(() => {
+		it("can change the phase to 90", async () => {
+			const buffer = await Offline(() => {
 				const instance = new Oscillator({
 					frequency: 1,
 					phase: 90,
 				});
 				instance.toDestination();
 				instance.start(0);
-			}, 1).then((buffer) => {
-				buffer.forEach((sample, time) => {
-					if (time < 0.25) {
-						expect(sample).to.be.within(-1, 0);
-					} else if (time > 0.25 && time < 0.5) {
-						expect(sample).to.be.within(0, 1);
-					}
-				});
+			}, 1);
+			buffer.forEach((sample, time) => {
+				if (time < 0.25) {
+					expect(sample).to.be.within(-1, 0);
+				} else if (time > 0.25 && time < 0.5) {
+					expect(sample).to.be.within(0, 1);
+				}
 			});
 		});
 
-		it("can change the phase to -90", () => {
-			return Offline(() => {
+		it("can change the phase to -90", async () => {
+			const buffer = await Offline(() => {
 				const instance = new Oscillator({
 					frequency: 1,
 					phase: 270,
 				});
 				instance.toDestination();
 				instance.start(0);
-			}, 1).then((buffer) => {
-				buffer.forEach((sample, time) => {
-					if (time < 0.25) {
-						expect(sample).to.be.within(0, 1);
-					} else if (time > 0.25 && time < 0.5) {
-						expect(sample).to.be.within(-1, 0);
-					}
-				});
+			}, 1);
+			buffer.forEach((sample, time) => {
+				if (time < 0.25) {
+					expect(sample).to.be.within(0, 1);
+				} else if (time > 0.25 && time < 0.5) {
+					expect(sample).to.be.within(-1, 0);
+				}
 			});
 		});
 
@@ -225,29 +223,27 @@ describe("Oscillator", () => {
 	});
 
 	context("Synchronization", () => {
-		it("can sync the frequency to the Transport", () => {
-			return Offline(({ transport }) => {
+		it("can unsync the frequency from the Transport", async () => {
+			const buffer = await Offline(({ transport }) => {
 				transport.bpm.value = 120;
 				const osc = new Oscillator(2);
 				osc.frequency.toDestination();
 				osc.syncFrequency();
 				transport.bpm.value = 240;
-			}).then((buffer) => {
-				expect(buffer.value()).to.be.closeTo(4, 0.001);
 			});
+			expect(buffer.value()).to.be.closeTo(4, 0.001);
 		});
 
-		it("can unsync the frequency from the Transport", () => {
-			return Offline(({ transport }) => {
+		it("can sync the frequency to the Transport", async () => {
+			const buffer = await Offline(({ transport }) => {
 				transport.bpm.value = 120;
 				const osc = new Oscillator(2);
 				osc.frequency.toDestination();
 				osc.syncFrequency();
 				transport.bpm.value = 240;
 				osc.unsyncFrequency();
-			}).then((buffer) => {
-				expect(buffer.value()).to.be.closeTo(2, 0.001);
 			});
+			expect(buffer.value()).to.be.closeTo(2, 0.001);
 		});
 	});
 

package/Tone/source/oscillator/PulseOscillator.test.ts

@@ -26,8 +26,8 @@ describe("PulseOscillator", () => {
 	});
 
 	context("Phase Rotation", () => {
-		it("can change the phase to 90", () => {
-			return Offline(() => {
+		it("can change the phase to 90", async () => {
+			const buffer = await Offline(() => {
 				const osc = new PulseOscillator({
 					frequency: 1,
 					phase: 90,
@@ -35,19 +35,18 @@ describe("PulseOscillator", () => {
 				});
 				osc.toDestination();
 				osc.start(0);
-			}, 1).then(async (buffer) => {
-				buffer.forEach((sample, time) => {
-					if (time < 0.25) {
-						expect(sample).to.be.within(-1, 0);
-					} else if (time > 0.25 && time < 0.5) {
-						expect(sample).to.be.within(0, 1);
-					}
-				});
+			}, 1);
+			buffer.forEach((sample, time) => {
+				if (time < 0.25) {
+					expect(sample).to.be.within(-1, 0);
+				} else if (time > 0.25 && time < 0.5) {
+					expect(sample).to.be.within(0, 1);
+				}
 			});
 		});
 
-		it("can change the phase to -90", () => {
-			return Offline(() => {
+		it("can change the phase to -90", async () => {
+			const buffer = await Offline(() => {
 				const osc = new PulseOscillator({
 					frequency: 1,
 					phase: 270,
@@ -55,14 +54,13 @@ describe("PulseOscillator", () => {
 				});
 				osc.toDestination();
 				osc.start(0);
-			}, 1).then((buffer) => {
-				buffer.forEach((sample, time) => {
-					if (time < 0.25) {
-						expect(sample).to.be.within(0, 1);
-					} else if (time > 0.25 && time < 0.5) {
-						expect(sample).to.be.within(-1, 0);
-					}
-				});
+			}, 1);
+			buffer.forEach((sample, time) => {
+				if (time < 0.25) {
+					expect(sample).to.be.within(0, 1);
+				} else if (time > 0.25 && time < 0.5) {
+					expect(sample).to.be.within(-1, 0);
+				}
 			});
 		});
 	});
@@ -76,41 +74,39 @@ describe("PulseOscillator", () => {
 			osc.dispose();
 		});
 
-		it("outputs correctly with a width of 0", () => {
-			return Offline(() => {
+		it("outputs correctly with a width of 0", async () => {
+			const buffer = await Offline(() => {
 				const osc = new PulseOscillator({
 					frequency: 1,
 					width: 0,
 				});
 				osc.toDestination();
 				osc.start(0);
-			}, 0.9).then((buffer) => {
-				buffer.forEach((sample, time) => {
-					if (time > 0.51) {
-						expect(sample).to.be.within(-1, 0);
-					}
-				});
+			}, 0.9);
+			buffer.forEach((sample, time) => {
+				if (time > 0.51) {
+					expect(sample).to.be.within(-1, 0);
+				}
 			});
 		});
 
-		it("outputs correctly with a width of 0.5", () => {
-			return Offline(() => {
+		it("outputs correctly with a width of 0.5", async () => {
+			const buffer = await Offline(() => {
 				const osc = new PulseOscillator({
 					frequency: 1,
 					width: 0.5,
 				});
 				osc.toDestination();
 				osc.start(0);
-			}, 1).then((buffer) => {
-				buffer.forEach((sample, time) => {
-					if (time <= 0.6) {
-						expect(sample).to.be.within(0, 1);
-					} else if (time >= 0.63 && time <= 0.87) {
-						expect(sample).to.be.within(-1, 0);
-					} else if (time > 0.9) {
-						expect(sample).to.be.within(0, 1);
-					}
-				});
+			}, 1);
+			buffer.forEach((sample, time) => {
+				if (time <= 0.6) {
+					expect(sample).to.be.within(0, 1);
+				} else if (time >= 0.63 && time <= 0.87) {
+					expect(sample).to.be.within(-1, 0);
+				} else if (time > 0.9) {
+					expect(sample).to.be.within(0, 1);
+				}
 			});
 		});
 	});

package/Tone/source/oscillator/ToneOscillatorNode.test.ts

@@ -99,9 +99,9 @@ describe("ToneOscillatorNode", () => {
 			};
 		});
 
-		it("invokes the onended callback in the offline context", () => {
+		it("invokes the onended callback in the offline context", async () => {
 			let wasInvoked = false;
-			return Offline(() => {
+			await Offline(() => {
 				const osc = new ToneOscillatorNode();
 				osc.start(0);
 				osc.stop(0.2);
@@ -110,14 +110,13 @@ describe("ToneOscillatorNode", () => {
 					osc.dispose();
 					wasInvoked = true;
 				};
-			}, 0.3).then(() => {
-				expect(wasInvoked).to.equal(true);
-			});
+			}, 0.3);
+			expect(wasInvoked).to.equal(true);
 		});
 
-		it("invokes the onended callback only once in offline context", () => {
+		it("invokes the onended callback only once in offline context", async () => {
 			let wasInvoked = false;
-			return Offline(() => {
+			await Offline(() => {
 				const osc = new ToneOscillatorNode();
 				osc.start(0);
 				osc.stop(0.1);
@@ -129,9 +128,8 @@ describe("ToneOscillatorNode", () => {
 					expect(wasInvoked).to.equal(false);
 					wasInvoked = true;
 				};
-			}, 0.4).then(() => {
-				expect(wasInvoked).to.equal(true);
-			});
+			}, 0.4);
+			expect(wasInvoked).to.equal(true);
 		});
 	});
 
@@ -145,27 +143,25 @@ describe("ToneOscillatorNode", () => {
 			osc.dispose();
 		});
 
-		it("can play for a specific duration", () => {
-			return Offline(() => {
+		it("can play for a specific duration", async () => {
+			const buffer = await Offline(() => {
 				const osc = new ToneOscillatorNode().toDestination();
 				osc.start(0).stop(0.1);
-			}, 0.4).then((buffer) => {
-				expect(buffer.getRmsAtTime(0)).to.be.above(0);
-				expect(buffer.getRmsAtTime(0.09)).to.be.above(0);
-				expect(buffer.getRmsAtTime(0.1)).to.equal(0);
-			});
+			}, 0.4);
+			expect(buffer.getRmsAtTime(0)).to.be.above(0);
+			expect(buffer.getRmsAtTime(0.09)).to.be.above(0);
+			expect(buffer.getRmsAtTime(0.1)).to.equal(0);
 		});
 
-		it("can call stop multiple times and takes the last value", () => {
-			return Offline(() => {
+		it("can call stop multiple times and takes the last value", async () => {
+			const buffer = await Offline(() => {
 				const osc = new ToneOscillatorNode().toDestination();
 				osc.start(0).stop(0.1).stop(0.2);
-			}, 0.4).then((buffer) => {
-				expect(buffer.getRmsAtTime(0)).to.be.above(0);
-				expect(buffer.getRmsAtTime(0.1)).to.be.above(0);
-				expect(buffer.getRmsAtTime(0.19)).to.be.above(0);
-				expect(buffer.getRmsAtTime(0.2)).to.equal(0);
-			});
+			}, 0.4);
+			expect(buffer.getRmsAtTime(0)).to.be.above(0);
+			expect(buffer.getRmsAtTime(0.1)).to.be.above(0);
+			expect(buffer.getRmsAtTime(0.19)).to.be.above(0);
+			expect(buffer.getRmsAtTime(0.2)).to.equal(0);
 		});
 
 		it("clamps start time to the currentTime", () => {
@@ -196,8 +192,8 @@ describe("ToneOscillatorNode", () => {
 	});
 
 	context("State", () => {
-		it("reports the right state", () => {
-			return Offline(() => {
+		it("reports the right state", async () => {
+			await Offline(() => {
 				const osc = new ToneOscillatorNode();
 				osc.start(0);
 				osc.stop(0.05);
@@ -212,8 +208,8 @@ describe("ToneOscillatorNode", () => {
 			}, 0.1);
 		});
 
-		it("can call stop multiple times, takes the last value", () => {
-			return Offline(() => {
+		it("can call stop multiple times, takes the last value", async () => {
+			await Offline(() => {
 				const osc = new ToneOscillatorNode();
 				osc.start(0);
 				osc.stop(0.05);

package/Tone/version.ts

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