tone 15.2.1 → 15.2.2

package/Tone/component/analysis/Follower.test.ts

@@ -28,74 +28,70 @@ describe("Follower", () => {
 			follower.dispose();
 		});
 
-		it("smooths the incoming signal at 0.1", () => {
-			return Offline(() => {
+		it("smooths the incoming signal at 0.1", async () => {
+			const buffer = await Offline(() => {
 				const foll = new Follower(0.1).toDestination();
 				const sig = new Signal(0);
 				sig.connect(foll);
 				sig.setValueAtTime(1, 0.1);
 				sig.setValueAtTime(0, 0.3);
-			}, 0.41).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.01);
-				expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.0, 0.01);
-				expect(buffer.getValueAtTime(0.15)).to.be.closeTo(0.95, 0.05);
-				expect(buffer.getValueAtTime(0.2)).to.be.closeTo(1, 0.01);
-				expect(buffer.getValueAtTime(0.3)).to.be.closeTo(1, 0.01);
-				expect(buffer.getValueAtTime(0.35)).to.be.closeTo(0.05, 0.05);
-				expect(buffer.getValueAtTime(0.4)).to.be.closeTo(0, 0.01);
-			});
+			}, 0.41);
+			expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.01);
+			expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.0, 0.01);
+			expect(buffer.getValueAtTime(0.15)).to.be.closeTo(0.95, 0.05);
+			expect(buffer.getValueAtTime(0.2)).to.be.closeTo(1, 0.01);
+			expect(buffer.getValueAtTime(0.3)).to.be.closeTo(1, 0.01);
+			expect(buffer.getValueAtTime(0.35)).to.be.closeTo(0.05, 0.05);
+			expect(buffer.getValueAtTime(0.4)).to.be.closeTo(0, 0.01);
 		});
 
-		it("smooths the incoming signal at 0.05", () => {
-			return Offline(() => {
+		it("smooths the incoming signal at 0.05", async () => {
+			const buffer = await Offline(() => {
 				const foll = new Follower(0.05).toDestination();
 				const sig = new Signal(0);
 				sig.connect(foll);
 				sig.setValueAtTime(1, 0.1);
 				sig.setValueAtTime(0, 0.3);
-			}, 0.41).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.01);
-				expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.0, 0.01);
-				expect(buffer.getValueAtTime(0.125)).to.be.closeTo(0.95, 0.05);
-				expect(buffer.getValueAtTime(0.15)).to.be.closeTo(1, 0.01);
-				expect(buffer.getValueAtTime(0.3)).to.be.closeTo(1, 0.01);
-				expect(buffer.getValueAtTime(0.325)).to.be.closeTo(0.05, 0.05);
-				expect(buffer.getValueAtTime(0.35)).to.be.closeTo(0, 0.01);
-			});
+			}, 0.41);
+			expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.01);
+			expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.0, 0.01);
+			expect(buffer.getValueAtTime(0.125)).to.be.closeTo(0.95, 0.05);
+			expect(buffer.getValueAtTime(0.15)).to.be.closeTo(1, 0.01);
+			expect(buffer.getValueAtTime(0.3)).to.be.closeTo(1, 0.01);
+			expect(buffer.getValueAtTime(0.325)).to.be.closeTo(0.05, 0.05);
+			expect(buffer.getValueAtTime(0.35)).to.be.closeTo(0, 0.01);
 		});
 
-		it("smooths the incoming signal at 0.2", () => {
-			return Offline(() => {
+		it("smooths the incoming signal at 0.2", async () => {
+			const buffer = await Offline(() => {
 				const foll = new Follower(0.2).toDestination();
 				const sig = new Signal(0);
 				sig.connect(foll);
 				sig.setValueAtTime(1, 0.1);
 				sig.setValueAtTime(0, 0.3);
-			}, 0.51).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.01);
-				expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.0, 0.01);
-				expect(buffer.getValueAtTime(0.2)).to.be.closeTo(0.95, 0.05);
-				expect(buffer.getValueAtTime(0.3)).to.be.closeTo(1, 0.01);
-				expect(buffer.getValueAtTime(0.4)).to.be.closeTo(0.05, 0.05);
-				expect(buffer.getValueAtTime(0.5)).to.be.closeTo(0, 0.01);
-			});
+			}, 0.51);
+			expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.01);
+			expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.0, 0.01);
+			expect(buffer.getValueAtTime(0.2)).to.be.closeTo(0.95, 0.05);
+			expect(buffer.getValueAtTime(0.3)).to.be.closeTo(1, 0.01);
+			expect(buffer.getValueAtTime(0.4)).to.be.closeTo(0.05, 0.05);
+			expect(buffer.getValueAtTime(0.5)).to.be.closeTo(0, 0.01);
 		});
 
-		it("smooths the incoming signal at 0.5", () => {
-			return Offline(() => {
+		it("smooths the incoming signal at 0.5", async () => {
+			const buffer = await Offline(() => {
 				const foll = new Follower(0.5).toDestination();
 				const sig = new Signal(0);
 				sig.connect(foll);
 				sig.setValueAtTime(1, 0.1);
 				sig.setValueAtTime(0, 0.6);
-			}, 1.11).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.01);
-				expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.0, 0.01);
-				expect(buffer.getValueAtTime(0.35)).to.be.closeTo(0.95, 0.05);
-				expect(buffer.getValueAtTime(0.6)).to.be.closeTo(1, 0.01);
-				expect(buffer.getValueAtTime(0.85)).to.be.closeTo(0.05, 0.05);
-				expect(buffer.getValueAtTime(1.1)).to.be.closeTo(0, 0.01);
-			});
+			}, 1.11);
+			expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.01);
+			expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.0, 0.01);
+			expect(buffer.getValueAtTime(0.35)).to.be.closeTo(0.95, 0.05);
+			expect(buffer.getValueAtTime(0.6)).to.be.closeTo(1, 0.01);
+			expect(buffer.getValueAtTime(0.85)).to.be.closeTo(0.05, 0.05);
+			expect(buffer.getValueAtTime(1.1)).to.be.closeTo(0, 0.01);
 		});
 
 		it("passes the incoming signal through", () => {

package/Tone/component/channel/Channel.test.ts

@@ -37,14 +37,13 @@ describe("Channel", () => {
 			});
 		});
 
-		it("can mute the input", () => {
-			return Offline(() => {
+		it("can mute the input", async () => {
+			const buffer = await Offline(() => {
 				const channel = new Channel(0).toDestination();
 				new Signal(1).connect(channel);
 				channel.mute = true;
-			}).then((buffer) => {
-				expect(buffer.isSilent()).to.be.true;
 			});
+			expect(buffer.isSilent()).to.be.true;
 		});
 
 		it("reports itself as muted when either muted or another channel is soloed", () => {

package/Tone/component/channel/Merge.test.ts

@@ -40,8 +40,8 @@ describe("Merge", () => {
 			});
 		});
 
-		it("merge two signal into one stereo signal", () => {
-			return Offline(
+		it("merge two signal into one stereo signal", async () => {
+			const buffer = await Offline(
 				() => {
 					const sigL = new Signal(1);
 					const sigR = new Signal(2);
@@ -52,10 +52,9 @@ describe("Merge", () => {
 				},
 				0.1,
 				2
-			).then((buffer) => {
-				expect(buffer.toArray()[0][0]).to.be.closeTo(1, 0.001);
-				expect(buffer.toArray()[1][0]).to.be.closeTo(2, 0.001);
-			});
+			);
+			expect(buffer.toArray()[0][0]).to.be.closeTo(1, 0.001);
+			expect(buffer.toArray()[1][0]).to.be.closeTo(2, 0.001);
 		});
 	});
 });

package/Tone/component/channel/MidSideSplit.test.ts

@@ -19,47 +19,44 @@ describe("MidSideSplit", () => {
 			split.dispose();
 		});
 
-		it("mid is if both L and R are the same", () => {
-			return Offline(() => {
+		it("mid is if both L and R are the same", async () => {
+			const buffer = await Offline(() => {
 				const split = new MidSideSplit();
 				split.mid.toDestination();
 				const merge = new Merge().connect(split);
 				new Signal(0.5).connect(merge, 0, 0);
 				new Signal(0.5).connect(merge, 0, 1);
-			}).then((buffer) => {
-				expect(buffer.min()).to.be.closeTo(0.707, 0.01);
-				expect(buffer.max()).to.be.closeTo(0.707, 0.01);
 			});
+			expect(buffer.min()).to.be.closeTo(0.707, 0.01);
+			expect(buffer.max()).to.be.closeTo(0.707, 0.01);
 		});
 
-		it("side is 0 if both L and R are the same", () => {
-			return Offline(() => {
+		it("side is 0 if both L and R are the same", async () => {
+			const buffer = await Offline(() => {
 				const split = new MidSideSplit();
 				split.side.toDestination();
 				const merge = new Merge().connect(split);
 				new Signal(0.5).connect(merge, 0, 0);
 				new Signal(0.5).connect(merge, 0, 1);
-			}).then((buffer) => {
-				expect(buffer.min()).to.be.closeTo(0, 0.01);
-				expect(buffer.max()).to.be.closeTo(0, 0.01);
 			});
+			expect(buffer.min()).to.be.closeTo(0, 0.01);
+			expect(buffer.max()).to.be.closeTo(0, 0.01);
 		});
 
-		it("mid is 0 if both L and R opposites", () => {
-			return Offline(() => {
+		it("mid is 0 if both L and R opposites", async () => {
+			const buffer = await Offline(() => {
 				const split = new MidSideSplit();
 				split.mid.toDestination();
 				const merge = new Merge().connect(split);
 				new Signal(-1).connect(merge, 0, 0);
 				new Signal(1).connect(merge, 0, 1);
-			}).then((buffer) => {
-				expect(buffer.min()).to.be.closeTo(0, 0.01);
-				expect(buffer.max()).to.be.closeTo(0, 0.01);
 			});
+			expect(buffer.min()).to.be.closeTo(0, 0.01);
+			expect(buffer.max()).to.be.closeTo(0, 0.01);
 		});
 
-		it("can decompose and reconstruct a signal", () => {
-			return Offline(
+		it("can decompose and reconstruct a signal", async () => {
+			const buffer = await Offline(
 				() => {
 					const midSideMerge = new MidSideMerge().toDestination();
 					const split = new MidSideSplit();
@@ -71,14 +68,13 @@ describe("MidSideSplit", () => {
 				},
 				0.1,
 				2
-			).then((buffer) => {
-				buffer
-					.toArray()[0]
-					.forEach((l) => expect(l).to.be.closeTo(0.2, 0.01));
-				buffer
-					.toArray()[1]
-					.forEach((r) => expect(r).to.be.closeTo(0.4, 0.01));
-			});
+			);
+			buffer
+				.toArray()[0]
+				.forEach((l) => expect(l).to.be.closeTo(0.2, 0.01));
+			buffer
+				.toArray()[1]
+				.forEach((r) => expect(r).to.be.closeTo(0.4, 0.01));
 		});
 	});
 });

package/Tone/component/channel/Mono.test.ts

@@ -9,40 +9,38 @@ describe("Mono", () => {
 	BasicTests(Mono);
 
 	context("Mono", () => {
-		it("Makes a mono signal in both channels", () => {
-			return Offline(
+		it("Makes a mono signal in both channels", async () => {
+			const buffer = await Offline(
 				() => {
 					const mono = new Mono().toDestination();
 					const signal = new Signal(2).connect(mono);
 				},
 				0.1,
 				2
-			).then((buffer) => {
-				expect(buffer.toArray()[0][0]).to.equal(2);
-				expect(buffer.toArray()[1][0]).to.equal(2);
-				expect(buffer.toArray()[0][100]).to.equal(2);
-				expect(buffer.toArray()[1][100]).to.equal(2);
-				expect(buffer.toArray()[0][1000]).to.equal(2);
-				expect(buffer.toArray()[1][1000]).to.equal(2);
-			});
+			);
+			expect(buffer.toArray()[0][0]).to.equal(2);
+			expect(buffer.toArray()[1][0]).to.equal(2);
+			expect(buffer.toArray()[0][100]).to.equal(2);
+			expect(buffer.toArray()[1][100]).to.equal(2);
+			expect(buffer.toArray()[0][1000]).to.equal(2);
+			expect(buffer.toArray()[1][1000]).to.equal(2);
 		});
 
-		it("Sums a stereo signal into a mono signal", () => {
-			return Offline(
+		it("Sums a stereo signal into a mono signal", async () => {
+			const buffer = await Offline(
 				() => {
 					const mono = new Mono().toDestination();
 					const signal = StereoSignal(2, 2).connect(mono);
 				},
 				0.1,
 				2
-			).then((buffer) => {
-				expect(buffer.toArray()[0][0]).to.equal(2);
-				expect(buffer.toArray()[1][0]).to.equal(2);
-				expect(buffer.toArray()[0][100]).to.equal(2);
-				expect(buffer.toArray()[1][100]).to.equal(2);
-				expect(buffer.toArray()[0][1000]).to.equal(2);
-				expect(buffer.toArray()[1][1000]).to.equal(2);
-			});
+			);
+			expect(buffer.toArray()[0][0]).to.equal(2);
+			expect(buffer.toArray()[1][0]).to.equal(2);
+			expect(buffer.toArray()[0][100]).to.equal(2);
+			expect(buffer.toArray()[1][100]).to.equal(2);
+			expect(buffer.toArray()[0][1000]).to.equal(2);
+			expect(buffer.toArray()[1][1000]).to.equal(2);
 		});
 	});
 });

package/Tone/component/channel/PanVol.test.ts

@@ -42,14 +42,13 @@ describe("PanVol", () => {
 			});
 		});
 
-		it("can mute the volume", () => {
-			return Offline(() => {
+		it("can mute the volume", async () => {
+			const buffer = await Offline(() => {
 				const vol = new PanVol(0).toDestination();
 				new Signal(1).connect(vol);
 				vol.mute = true;
-			}).then((buffer) => {
-				expect(buffer.isSilent()).to.be.true;
 			});
+			expect(buffer.isSilent()).to.be.true;
 		});
 	});
 });

package/Tone/component/channel/Panner.test.ts

@@ -30,56 +30,53 @@ describe("Panner", () => {
 			});
 		});
 
-		it("pans hard left when the pan is set to -1", () => {
-			return Offline(
+		it("pans hard left when the pan is set to -1", async () => {
+			const buffer = await Offline(
 				() => {
 					const panner = new Panner(-1).toDestination();
 					new Signal(1).connect(panner);
 				},
 				0.1,
 				2
-			).then((buffer) => {
-				const l = buffer.toArray()[0];
-				const r = buffer.toArray()[1];
-				expect(l[0]).to.be.closeTo(1, 0.01);
-				expect(r[0]).to.be.closeTo(0, 0.01);
-			});
+			);
+			const l = buffer.toArray()[0];
+			const r = buffer.toArray()[1];
+			expect(l[0]).to.be.closeTo(1, 0.01);
+			expect(r[0]).to.be.closeTo(0, 0.01);
 		});
 
-		it("pans hard right when the pan is set to 1", () => {
-			return Offline(
+		it("pans hard right when the pan is set to 1", async () => {
+			const buffer = await Offline(
 				() => {
 					const panner = new Panner(1).toDestination();
 					new Signal(1).connect(panner);
 				},
 				0.1,
 				2
-			).then((buffer) => {
-				const l = buffer.toArray()[0];
-				const r = buffer.toArray()[1];
-				expect(l[0]).to.be.closeTo(0, 0.01);
-				expect(r[0]).to.be.closeTo(1, 0.01);
-			});
+			);
+			const l = buffer.toArray()[0];
+			const r = buffer.toArray()[1];
+			expect(l[0]).to.be.closeTo(0, 0.01);
+			expect(r[0]).to.be.closeTo(1, 0.01);
 		});
 
-		it("mixes the signal in equal power when panned center", () => {
-			return Offline(
+		it("mixes the signal in equal power when panned center", async () => {
+			const buffer = await Offline(
 				() => {
 					const panner = new Panner(0).toDestination();
 					new Signal(1).connect(panner);
 				},
 				0.1,
 				2
-			).then((buffer) => {
-				const l = buffer.toArray()[0];
-				const r = buffer.toArray()[1];
-				expect(l[0]).to.be.closeTo(0.707, 0.01);
-				expect(r[0]).to.be.closeTo(0.707, 0.01);
-			});
+			);
+			const l = buffer.toArray()[0];
+			const r = buffer.toArray()[1];
+			expect(l[0]).to.be.closeTo(0.707, 0.01);
+			expect(r[0]).to.be.closeTo(0.707, 0.01);
 		});
 
-		it("can chain two panners when channelCount is 2", () => {
-			return Offline(
+		it("can chain two panners when channelCount is 2", async () => {
+			const buffer = await Offline(
 				() => {
 					const panner1 = new Panner({
 						channelCount: 2,
@@ -89,12 +86,11 @@ describe("Panner", () => {
 				},
 				0.1,
 				2
-			).then((buffer) => {
-				const l = buffer.toArray()[0];
-				const r = buffer.toArray()[1];
-				expect(l[0]).to.be.closeTo(1, 0.01);
-				expect(r[0]).to.be.closeTo(0, 0.01);
-			});
+			);
+			const l = buffer.toArray()[0];
+			const r = buffer.toArray()[1];
+			expect(l[0]).to.be.closeTo(1, 0.01);
+			expect(r[0]).to.be.closeTo(0, 0.01);
 		});
 	});
 });

package/Tone/component/channel/Recorder.ts

@@ -121,7 +121,7 @@ export class Recorder extends ToneAudioNode<RecorderOptions> {
 
 			this._recorder.addEventListener("start", handleStart, false);
 		});
-		if(this.state === "stopped") {
+		if (this.state === "stopped") {
 			this._recorder.start();
 		} else {
 			this._recorder.resume();

package/Tone/component/channel/Volume.test.ts

@@ -74,33 +74,30 @@ describe("Volume", () => {
 			// });
 		});
 
-		it("can lower the volume", () => {
-			return Offline(() => {
+		it("can lower the volume", async () => {
+			const buffer = await Offline(() => {
 				const vol = new Volume(-10).toDestination();
 				new Signal(1).connect(vol);
-			}).then((buffer) => {
-				expect(buffer.value()).to.be.closeTo(0.315, 0.01);
 			});
+			expect(buffer.value()).to.be.closeTo(0.315, 0.01);
 		});
 
-		it("can mute the volume", () => {
-			return Offline(() => {
+		it("can mute the volume", async () => {
+			const buffer = await Offline(() => {
 				const vol = new Volume(0).toDestination();
 				new Signal(1).connect(vol);
 				vol.mute = true;
-			}).then((buffer) => {
-				expect(buffer.isSilent()).to.equal(true);
 			});
+			expect(buffer.isSilent()).to.equal(true);
 		});
 
-		it("muted when volume is set to -Infinity", () => {
-			return Offline(() => {
+		it("muted when volume is set to -Infinity", async () => {
+			const buffer = await Offline(() => {
 				const vol = new Volume(-Infinity).toDestination();
 				new Signal(1).connect(vol);
 				expect(vol.mute).to.equal(true);
-			}).then((buffer) => {
-				expect(buffer.isSilent()).to.equal(true);
 			});
+			expect(buffer.isSilent()).to.equal(true);
 		});
 
 		it("setting the volume unmutes it and reports itself as unmuted", () => {

package/Tone/component/dynamics/Gate.test.ts

@@ -46,28 +46,24 @@ describe("Gate", () => {
 			gate.dispose();
 		});
 
-		it("gates the incoming signal when below the threshold", () => {
-			return Offline(() => {
+		it("gates the incoming signal when below the threshold", async () => {
+			const buffer = await Offline(() => {
 				const gate = new Gate(-9);
 				const sig = new Signal(-12, "decibels");
 				sig.connect(gate);
 				gate.toDestination();
-			}).then((buffer) => {
-				expect(buffer.isSilent()).to.be.true;
 			});
+			expect(buffer.isSilent()).to.be.true;
 		});
 
-		it("passes the incoming signal when above the threshold", () => {
-			it("gates the incoming signal when below the threshold", () => {
-				return Offline(() => {
-					const gate = new Gate(-11);
-					const sig = new Signal(-10, "decibels");
-					sig.connect(gate);
-					gate.toDestination();
-				}).then((buffer) => {
-					expect(buffer.min()).to.be.above(0);
-				});
+		it("passes the incoming signal when above the threshold", async () => {
+			const buffer = await Offline(() => {
+				const gate = new Gate(-11);
+				const sig = new Signal(-10, "decibels");
+				sig.connect(gate);
+				gate.toDestination();
 			});
+			expect(buffer.min()).to.be.above(0);
 		});
 	});
 });

package/Tone/component/envelope/AmplitudeEnvelope.test.ts

@@ -74,23 +74,21 @@ describe("AmplitudeEnvelope", () => {
 			ampEnv.dispose();
 		});
 
-		it("passes no signal before being triggered", () => {
-			return Offline(() => {
+		it("passes no signal before being triggered", async () => {
+			const buffer = await Offline(() => {
 				const ampEnv = new AmplitudeEnvelope().toDestination();
 				new Signal(1).connect(ampEnv);
-			}).then((buffer) => {
-				expect(buffer.isSilent()).to.be.true;
 			});
+			expect(buffer.isSilent()).to.be.true;
 		});
 
-		it("passes signal once triggered", () => {
-			return Offline(() => {
+		it("passes signal once triggered", async () => {
+			const buffer = await Offline(() => {
 				const ampEnv = new AmplitudeEnvelope().toDestination();
 				new Signal(1).connect(ampEnv);
 				ampEnv.triggerAttack(0.1);
-			}, 0.2).then((buffer) => {
-				expect(buffer.getTimeOfFirstSound()).to.be.closeTo(0.1, 0.001);
-			});
+			}, 0.2);
+			expect(buffer.getTimeOfFirstSound()).to.be.closeTo(0.1, 0.001);
 		});
 	});
 });