tone 15.2.0 → 15.2.2

package/Tone/instrument/Sampler.test.ts

@@ -75,15 +75,14 @@ describe("Sampler", () => {
 			sampler.dispose();
 		});
 
-		it("urls can be described as either midi or notes", () => {
-			return Offline(() => {
+		it("urls can be described as either midi or notes", async () => {
+			const buffer = await Offline(() => {
 				const sampler = new Sampler({
 					A4: A4_buffer,
 				}).toDestination();
 				sampler.triggerAttack("A4");
-			}).then((buffer) => {
-				expect(buffer.isSilent()).to.be.false;
 			});
+			expect(buffer.isSilent()).to.be.false;
 		});
 
 		it("throws an error if there are no available notes to play", () => {
@@ -103,7 +102,7 @@ describe("Sampler", () => {
 			}).throws(Error);
 		});
 
-		it("invokes onerror if the ", (done) => {
+		it("invokes onerror if the ", async () => {
 			const sampler = new Sampler({
 				urls: {
 					40: "./nosuchfile.wav",
@@ -111,9 +110,9 @@ describe("Sampler", () => {
 				onerror(e) {
 					expect(e).to.be.instanceOf(Error);
 					sampler.dispose();
-					done();
 				},
 			});
+			await Offline(() => {});
 		});
 
 		it("can get and set envelope attributes", () => {
@@ -168,19 +167,18 @@ describe("Sampler", () => {
 	});
 
 	context("Makes sound", () => {
-		it("repitches the note", () => {
-			return Offline(() => {
+		it("repitches the note", async () => {
+			const buffer = await Offline(() => {
 				const sampler = new Sampler({
 					A4: A4_buffer,
 				}).toDestination();
 				sampler.triggerAttack("G4");
-			}).then((buffer) => {
-				expect(buffer.isSilent()).to.be.false;
 			});
+			expect(buffer.isSilent()).to.be.false;
 		});
 
-		it("is silent after the release", () => {
-			return Offline(() => {
+		it("is silent after the release", async () => {
+			const buffer = await Offline(() => {
 				const sampler = new Sampler(
 					{
 						A4: A4_buffer,
@@ -191,13 +189,12 @@ describe("Sampler", () => {
 				).toDestination();
 				sampler.triggerAttack("A4", 0);
 				sampler.triggerRelease("A4", 0.2);
-			}, 0.3).then((buffer) => {
-				expect(buffer.getTimeOfLastSound()).to.be.closeTo(0.2, 0.01);
-			});
+			}, 0.3);
+			expect(buffer.getTimeOfLastSound()).to.be.closeTo(0.2, 0.01);
 		});
 
-		it("can triggerRelease after the buffer has already stopped", () => {
-			return Offline(() => {
+		it("can triggerRelease after the buffer has already stopped", async () => {
+			const buffer = await Offline(() => {
 				const sampler = new Sampler(
 					{
 						A4: A4_buffer,
@@ -210,16 +207,15 @@ describe("Sampler", () => {
 				return atTime(A4_buffer.duration + 0.01, () => {
 					sampler.triggerRelease("A4");
 				});
-			}, A4_buffer.duration + 0.1).then((buffer) => {
-				expect(buffer.getTimeOfLastSound()).to.be.closeTo(
-					A4_buffer.duration,
-					0.01
-				);
-			});
+			}, A4_buffer.duration + 0.1);
+			expect(buffer.getTimeOfLastSound()).to.be.closeTo(
+				A4_buffer.duration,
+				0.01
+			);
 		});
 
-		it("can release multiple notes", () => {
-			return Offline(() => {
+		it("can release multiple notes", async () => {
+			const buffer = await Offline(() => {
 				const sampler = new Sampler(
 					{
 						A4: A4_buffer,
@@ -233,13 +229,12 @@ describe("Sampler", () => {
 				sampler.triggerAttack("A4", 0.1);
 				sampler.triggerAttack("G4", 0.1);
 				sampler.releaseAll(0.2);
-			}, 0.3).then((buffer) => {
-				expect(buffer.getTimeOfLastSound()).to.be.closeTo(0.2, 0.01);
-			});
+			}, 0.3);
+			expect(buffer.getTimeOfLastSound()).to.be.closeTo(0.2, 0.01);
 		});
 
-		it("can trigger the attack and release", () => {
-			return Offline(() => {
+		it("can trigger the attack and release", async () => {
+			const buffer = await Offline(() => {
 				const sampler = new Sampler(
 					{
 						A4: A4_buffer,
@@ -249,14 +244,13 @@ describe("Sampler", () => {
 					}
 				).toDestination();
 				sampler.triggerAttackRelease("A4", 0.2, 0.1);
-			}, 0.4).then((buffer) => {
-				expect(buffer.getTimeOfFirstSound()).to.be.closeTo(0.1, 0.01);
-				expect(buffer.getTimeOfLastSound()).to.be.closeTo(0.3, 0.01);
-			});
+			}, 0.4);
+			expect(buffer.getTimeOfFirstSound()).to.be.closeTo(0.1, 0.01);
+			expect(buffer.getTimeOfLastSound()).to.be.closeTo(0.3, 0.01);
 		});
 
-		it("can trigger polyphonic attack release", () => {
-			return Offline(() => {
+		it("can trigger polyphonic attack release", async () => {
+			const buffer = await Offline(() => {
 				const sampler = new Sampler(
 					{
 						A4: A4_buffer,
@@ -266,32 +260,29 @@ describe("Sampler", () => {
 					}
 				).toDestination();
 				sampler.triggerAttackRelease(["A4", "C4"], [0.2, 0.3], 0.1);
-			}, 0.5).then((buffer) => {
-				expect(buffer.getTimeOfFirstSound()).to.be.closeTo(0.1, 0.01);
-				expect(buffer.getTimeOfLastSound()).to.be.closeTo(0.4, 0.01);
-			});
+			}, 0.5);
+			expect(buffer.getTimeOfFirstSound()).to.be.closeTo(0.1, 0.01);
+			expect(buffer.getTimeOfLastSound()).to.be.closeTo(0.4, 0.01);
 		});
 	});
 
 	context("add samples", () => {
-		it("can add a note with it's midi value", () => {
-			return Offline(() => {
+		it("can add a note with it's midi value", async () => {
+			const buffer = await Offline(() => {
 				const sampler = new Sampler().toDestination();
 				sampler.add(69, A4_buffer);
 				sampler.triggerAttack("B4");
-			}).then((buffer) => {
-				expect(buffer.isSilent()).to.be.false;
 			});
+			expect(buffer.isSilent()).to.be.false;
 		});
 
-		it("can add a note with it's note name", () => {
-			return Offline(() => {
+		it("can add a note with it's note name", async () => {
+			const buffer = await Offline(() => {
 				const sampler = new Sampler().toDestination();
 				sampler.add("A4", A4_buffer);
 				sampler.triggerAttack("G4");
-			}).then((buffer) => {
-				expect(buffer.isSilent()).to.be.false;
 			});
+			expect(buffer.isSilent()).to.be.false;
 		});
 
 		it("can pass in a url and invokes the callback", (done) => {

package/Tone/instrument/Synth.test.ts

@@ -87,17 +87,16 @@ describe("Synth", () => {
 			simple.dispose();
 		});
 
-		it("can be trigged with a Tone.Frequency", () => {
-			return Offline(() => {
+		it("can be trigged with a Tone.Frequency", async () => {
+			const buffer = await Offline(() => {
 				const synth = new Synth().toDestination();
 				synth.triggerAttack(Frequency("C4"), 0);
-			}).then((buffer) => {
-				expect(buffer.isSilent()).to.be.false;
 			});
+			expect(buffer.isSilent()).to.be.false;
 		});
 
-		it("is silent after triggerAttack if sustain is 0", () => {
-			return Offline(() => {
+		it("is silent after triggerAttack if sustain is 0", async () => {
+			const buffer = await Offline(() => {
 				const synth = new Synth({
 					envelope: {
 						attack: 0.1,
@@ -106,25 +105,23 @@ describe("Synth", () => {
 					},
 				}).toDestination();
 				synth.triggerAttack("C4", 0);
-			}, 0.5).then((buffer) => {
-				expect(buffer.getTimeOfLastSound()).to.be.closeTo(0.2, 0.01);
-			});
+			}, 0.5);
+			expect(buffer.getTimeOfLastSound()).to.be.closeTo(0.2, 0.01);
 		});
 	});
 
 	context("Transport sync", () => {
-		it("is silent until the transport is started", () => {
-			return Offline(({ transport }) => {
+		it("is silent until the transport is started", async () => {
+			const buffer = await Offline(({ transport }) => {
 				const synth = new Synth().sync().toDestination();
 				synth.triggerAttackRelease("C4", 0.5);
 				transport.start(0.5);
-			}, 1).then((buffer) => {
-				expect(buffer.getTimeOfFirstSound()).is.closeTo(0.5, 0.1);
-			});
+			}, 1);
+			expect(buffer.getTimeOfFirstSound()).is.closeTo(0.5, 0.1);
 		});
 
-		it("stops when the transport is stopped", () => {
-			return Offline(({ transport }) => {
+		it("stops when the transport is stopped", async () => {
+			const buffer = await Offline(({ transport }) => {
 				const synth = new Synth({
 					envelope: {
 						release: 0,
@@ -134,13 +131,12 @@ describe("Synth", () => {
 					.toDestination();
 				synth.triggerAttackRelease("C4", 0.5);
 				transport.start(0.5).stop(1);
-			}, 1.5).then((buffer) => {
-				expect(buffer.getTimeOfLastSound()).is.closeTo(1, 0.1);
-			});
+			}, 1.5);
+			expect(buffer.getTimeOfLastSound()).is.closeTo(1, 0.1);
 		});
 
-		it("goes silent at the loop boundary", () => {
-			return Offline(({ transport }) => {
+		it("goes silent at the loop boundary", async () => {
+			const buffer = await Offline(({ transport }) => {
 				const synth = new Synth({
 					envelope: {
 						release: 0,
@@ -152,16 +148,15 @@ describe("Synth", () => {
 				transport.loopEnd = 1;
 				transport.loop = true;
 				transport.start();
-			}, 2).then((buffer) => {
-				expect(buffer.getRmsAtTime(0)).to.be.closeTo(0, 0.05);
-				expect(buffer.getRmsAtTime(0.6)).to.be.closeTo(0.2, 0.05);
-				expect(buffer.getRmsAtTime(1.1)).to.be.closeTo(0, 0.05);
-				expect(buffer.getRmsAtTime(1.6)).to.be.closeTo(0.2, 0.05);
-			});
+			}, 2);
+			expect(buffer.getRmsAtTime(0)).to.be.closeTo(0, 0.05);
+			expect(buffer.getRmsAtTime(0.6)).to.be.closeTo(0.2, 0.05);
+			expect(buffer.getRmsAtTime(1.1)).to.be.closeTo(0, 0.05);
+			expect(buffer.getRmsAtTime(1.6)).to.be.closeTo(0.2, 0.05);
 		});
 
-		it("can unsync", () => {
-			return Offline(({ transport }) => {
+		it("can unsync", async () => {
+			const buffer = await Offline(({ transport }) => {
 				const synth = new Synth({
 					envelope: {
 						sustain: 1,
@@ -173,18 +168,17 @@ describe("Synth", () => {
 					.unsync();
 				synth.triggerAttackRelease("C4", 1, 0.5);
 				transport.start().stop(1);
-			}, 2).then((buffer) => {
-				expect(buffer.getRmsAtTime(0)).to.be.closeTo(0, 0.05);
-				expect(buffer.getRmsAtTime(0.6)).to.be.closeTo(0.6, 0.05);
-				expect(buffer.getRmsAtTime(1.4)).to.be.closeTo(0.6, 0.05);
-				expect(buffer.getRmsAtTime(1.6)).to.be.closeTo(0, 0.05);
-			});
+			}, 2);
+			expect(buffer.getRmsAtTime(0)).to.be.closeTo(0, 0.05);
+			expect(buffer.getRmsAtTime(0.6)).to.be.closeTo(0.6, 0.05);
+			expect(buffer.getRmsAtTime(1.4)).to.be.closeTo(0.6, 0.05);
+			expect(buffer.getRmsAtTime(1.6)).to.be.closeTo(0, 0.05);
 		});
 	});
 
 	context("Portamento", () => {
-		it("can play notes with a portamento", () => {
-			return Offline(() => {
+		it("can play notes with a portamento", async () => {
+			const buffer = await Offline(() => {
 				const synth = new Synth({
 					portamento: 0.1,
 				});
@@ -192,16 +186,15 @@ describe("Synth", () => {
 				synth.frequency.toDestination();
 				synth.triggerAttack(440, 0);
 				synth.triggerAttack(880, 0.1);
-			}, 0.2).then((buffer) => {
-				buffer.forEach((val, time) => {
-					if (time < 0.1) {
-						expect(val).to.be.closeTo(440, 1);
-					} else if (time < 0.2) {
-						expect(val).to.within(440, 880);
-					} else {
-						expect(val).to.be.closeTo(880, 1);
-					}
-				});
+			}, 0.2);
+			buffer.forEach((val, time) => {
+				if (time < 0.1) {
+					expect(val).to.be.closeTo(440, 1);
+				} else if (time < 0.2) {
+					expect(val).to.within(440, 880);
+				} else {
+					expect(val).to.be.closeTo(880, 1);
+				}
 			});
 		});
 	});

package/Tone/signal/AudioToGain.test.ts

@@ -11,16 +11,15 @@ import { Zero } from "./Zero.js";
 describe("AudioToGain", () => {
 	BasicTests(AudioToGain);
 
-	it("normalizes an oscillator to 0,1", () => {
-		return Offline(() => {
+	it("normalizes an oscillator to 0,1", async () => {
+		const buffer = await Offline(() => {
 			const osc = new Oscillator(1000).start();
 			const a2g = new AudioToGain();
 			osc.connect(a2g);
 			a2g.toDestination();
-		}).then((buffer) => {
-			expect(buffer.min()).to.be.closeTo(0, 0.01);
-			expect(buffer.max()).to.be.closeTo(1, 0.01);
 		});
+		expect(buffer.min()).to.be.closeTo(0, 0.01);
+		expect(buffer.max()).to.be.closeTo(1, 0.01);
 	});
 
 	it("outputs 0.5 for an input value of 0", () => {