tone 15.2.0 → 15.2.2

package/Tone/event/ToneEvent.test.ts

@@ -65,8 +65,8 @@ describe("ToneEvent", () => {
 			});
 		});
 
-		it("can set get a the values as an object", () => {
-			return Offline(() => {
+		it("can set get a the values as an object", async () => {
+			await Offline(() => {
 				const callback = noOp;
 				const note = new ToneEvent({
 					callback,
@@ -82,8 +82,8 @@ describe("ToneEvent", () => {
 	});
 
 	context("ToneEvent callback", () => {
-		it("does not invoke get invoked until started", () => {
-			return Offline(({ transport }) => {
+		it("does not invoke get invoked until started", async () => {
+			await Offline(({ transport }) => {
 				const event = new ToneEvent(() => {
 					throw new Error("shouldn't call this callback");
 				}, "C4");
@@ -91,22 +91,21 @@ describe("ToneEvent", () => {
 			}, 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 note = new ToneEvent(() => {
 					note.dispose();
 					invoked = true;
 				}, "C4").start(0);
 				transport.start();
-			}, 0.3).then(() => {
-				expect(invoked).to.be.true;
-			});
+			}, 0.3);
+			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 = 0.1;
 				const note = new ToneEvent((time) => {
 					expect(time).to.be.a("number");
@@ -116,14 +115,13 @@ describe("ToneEvent", () => {
 				});
 				note.start(0.3);
 				transport.start(now);
-			}, 0.5).then(() => {
-				expect(invoked).to.be.true;
-			});
+			}, 0.5);
+			expect(invoked).to.be.true;
 		});
 
-		it("passes in the value to the callback", () => {
+		it("passes in the value to the callback", async () => {
 			let invoked = false;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				const note = new ToneEvent((time, thing) => {
 					expect(time).to.be.a("number");
 					expect(thing).to.equal("thing");
@@ -131,9 +129,8 @@ describe("ToneEvent", () => {
 					invoked = true;
 				}, "thing").start();
 				transport.start();
-			}, 0.3).then(() => {
-				expect(invoked).to.be.true;
-			});
+			}, 0.3);
+			expect(invoked).to.be.true;
 		});
 
 		it("can mute the callback", () => {
@@ -196,8 +193,8 @@ describe("ToneEvent", () => {
 			}, 1);
 		});
 
-		it("can be cancelled", () => {
-			return Offline(({ transport }) => {
+		it("can be cancelled", async () => {
+			await Offline(({ transport }) => {
 				const note = new ToneEvent().start(0);
 				expect(note.state).to.equal("started");
 				transport.start();
@@ -227,9 +224,9 @@ describe("ToneEvent", () => {
 	});
 
 	context("Looping", () => {
-		it("can be set to loop", () => {
+		it("can be set to loop", async () => {
 			let callCount = 0;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				new ToneEvent({
 					callback(): void {
 						callCount++;
@@ -238,13 +235,12 @@ describe("ToneEvent", () => {
 					loopEnd: 0.25,
 				}).start(0);
 				transport.start(0);
-			}, 0.8).then(() => {
-				expect(callCount).to.equal(4);
-			});
+			}, 0.8);
+			expect(callCount).to.equal(4);
 		});
 
-		it("can be set to loop at a specific interval", () => {
-			return Offline(({ transport }) => {
+		it("can be set to loop at a specific interval", async () => {
+			await Offline(({ transport }) => {
 				let lastCall;
 				new ToneEvent({
 					callback(time): void {
@@ -279,9 +275,9 @@ describe("ToneEvent", () => {
 			}, 0.8);
 		});
 
-		it("can loop a specific number of times", () => {
+		it("can loop a specific number of times", async () => {
 			let callCount = 0;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				new ToneEvent({
 					loop: 3,
 					loopEnd: 0.125,
@@ -290,14 +286,13 @@ describe("ToneEvent", () => {
 					},
 				}).start(0);
 				transport.start();
-			}, 0.8).then(() => {
-				expect(callCount).to.equal(3);
-			});
+			}, 0.8);
+			expect(callCount).to.equal(3);
 		});
 
-		it("plays once when loop is 1", () => {
+		it("plays once when loop is 1", async () => {
 			let callCount = 0;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				new ToneEvent({
 					loop: 1,
 					loopEnd: 0.125,
@@ -306,14 +301,13 @@ describe("ToneEvent", () => {
 					},
 				}).start(0);
 				transport.start();
-			}, 0.8).then(() => {
-				expect(callCount).to.equal(1);
-			});
+			}, 0.8);
+			expect(callCount).to.equal(1);
 		});
 
-		it("plays once when loop is 0", () => {
+		it("plays once when loop is 0", async () => {
 			let callCount = 0;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				new ToneEvent({
 					loop: 0,
 					loopEnd: 0.125,
@@ -322,14 +316,13 @@ describe("ToneEvent", () => {
 					},
 				}).start(0);
 				transport.start();
-			}, 0.8).then(() => {
-				expect(callCount).to.equal(1);
-			});
+			}, 0.8);
+			expect(callCount).to.equal(1);
 		});
 
-		it("plays once when loop is false", () => {
+		it("plays once when loop is false", async () => {
 			let callCount = 0;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				new ToneEvent({
 					loop: false,
 					loopEnd: 0.125,
@@ -338,18 +331,16 @@ describe("ToneEvent", () => {
 					},
 				}).start(0);
 				transport.start();
-			}, 0.8).then(() => {
-				expect(callCount).to.equal(1);
-			});
+			}, 0.8);
+			expect(callCount).to.equal(1);
 		});
 
-		it("can be started and stopped multiple times", () => {
-			return Offline(({ transport }) => {
-				const eventTimes = [
-					0.3, 0.39, 0.9, 0.99, 1.3, 1.39, 1.48, 1.57, 1.66, 1.75,
-					1.84,
-				];
-				let eventTimeIndex = 0;
+		it("can be started and stopped multiple times", async () => {
+			const eventTimes = [
+				0.3, 0.39, 0.9, 0.99, 1.3, 1.39, 1.48, 1.57, 1.66, 1.75, 1.84,
+			];
+			let eventTimeIndex = 0;
+			await Offline(({ transport }) => {
 				new ToneEvent({
 					loop: true,
 					loopEnd: 0.09,
@@ -370,9 +361,9 @@ describe("ToneEvent", () => {
 			}, 2);
 		});
 
-		it("loops the correct amount of times when the event is started in the transport's past", () => {
+		it("loops the correct amount of times when the event is started in the transport's past", async () => {
 			let callCount = 0;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				const note = new ToneEvent({
 					loop: 3,
 					loopEnd: 0.2,
@@ -388,13 +379,12 @@ describe("ToneEvent", () => {
 						note.start(0);
 					}
 				};
-			}, 1).then(() => {
-				expect(callCount).to.equal(2);
-			});
+			}, 1);
+			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 note = new ToneEvent({
 					loop: true,
 					loopEnd: 1,
@@ -408,8 +398,8 @@ describe("ToneEvent", () => {
 			}, 0.8);
 		});
 
-		it("progress is 0 when not looping", () => {
-			Offline(({ transport }) => {
+		it("progress is 0 when not looping", async () => {
+			await Offline(({ transport }) => {
 				const note = new ToneEvent({
 					loop: false,
 					loopEnd: 0.25,
@@ -423,8 +413,8 @@ describe("ToneEvent", () => {
 	});
 
 	context("playbackRate and humanize", () => {
-		it("can adjust the playbackRate", () => {
-			return Offline(({ transport }) => {
+		it("can adjust the playbackRate", async () => {
+			await Offline(({ transport }) => {
 				let lastCall;
 				new ToneEvent({
 					loop: true,
@@ -441,8 +431,8 @@ describe("ToneEvent", () => {
 			}, 0.7);
 		});
 
-		it("can adjust the playbackRate after starting", () => {
-			return Offline(({ transport }) => {
+		it("can adjust the playbackRate after starting", async () => {
+			await Offline(({ transport }) => {
 				let lastCall;
 				const note = new ToneEvent({
 					loop: true,
@@ -461,8 +451,8 @@ describe("ToneEvent", () => {
 			}, 1.2);
 		});
 
-		it("can humanize the callback by some amount", () => {
-			return Offline(({ transport }) => {
+		it("can humanize the callback by some amount", async () => {
+			await Offline(({ transport }) => {
 				let lastCall;
 				const note = new ToneEvent({
 					humanize: 0.05,

package/Tone/instrument/MonoSynth.test.ts

@@ -71,7 +71,7 @@ describe("MonoSynth", () => {
 		});
 
 		it("is silent after triggerAttack if sustain is 0", async () => {
-			return await Offline(() => {
+			const buffer = await Offline(() => {
 				const synth = new MonoSynth({
 					envelope: {
 						attack: 0.1,
@@ -80,9 +80,8 @@ describe("MonoSynth", () => {
 					},
 				}).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);
 		});
 	});
 });

package/Tone/instrument/PolySynth.test.ts

@@ -76,29 +76,28 @@ describe("PolySynth", () => {
 	});
 
 	context("Playing Notes", () => {
-		it("triggerAttackRelease can take an array of durations", () => {
-			return OutputAudio(() => {
+		it("triggerAttackRelease can take an array of durations", async () => {
+			await OutputAudio(() => {
 				const polySynth = new PolySynth();
 				polySynth.toDestination();
 				polySynth.triggerAttackRelease(["C4", "D4"], [0.1, 0.2]);
 			});
 		});
 
-		it("triggerAttack and triggerRelease can be invoked without arrays", () => {
-			return Offline(() => {
+		it("triggerAttack and triggerRelease can be invoked without arrays", async () => {
+			const buffer = await Offline(() => {
 				const polySynth = new PolySynth();
 				polySynth.set({ envelope: { release: 0.1 } });
 				polySynth.toDestination();
 				polySynth.triggerAttack("C4", 0);
 				polySynth.triggerRelease("C4", 0.1);
-			}, 0.3).then((buffer) => {
-				expect(buffer.getTimeOfFirstSound()).to.be.closeTo(0, 0.01);
-				expect(buffer.getValueAtTime(0.2)).to.be.closeTo(0, 0.01);
-			});
+			}, 0.3);
+			expect(buffer.getTimeOfFirstSound()).to.be.closeTo(0, 0.01);
+			expect(buffer.getValueAtTime(0.2)).to.be.closeTo(0, 0.01);
 		});
 
-		it("can stop all of the currently playing sounds", () => {
-			return Offline(() => {
+		it("can stop all of the currently playing sounds", async () => {
+			const buffer = await Offline(() => {
 				const polySynth = new PolySynth();
 				polySynth.set({ envelope: { release: 0.1 } });
 				polySynth.toDestination();
@@ -106,33 +105,30 @@ describe("PolySynth", () => {
 				return atTime(0.1, () => {
 					polySynth.releaseAll();
 				});
-			}, 0.3).then((buffer) => {
-				expect(buffer.getTimeOfFirstSound()).to.be.closeTo(0, 0.01);
-				expect(buffer.getTimeOfLastSound()).to.be.closeTo(0.2, 0.01);
-			});
+			}, 0.3);
+			expect(buffer.getTimeOfFirstSound()).to.be.closeTo(0, 0.01);
+			expect(buffer.getTimeOfLastSound()).to.be.closeTo(0.2, 0.01);
 		});
 
-		it("is silent before being triggered", () => {
-			return Offline(() => {
+		it("is silent before being triggered", async () => {
+			const buffer = await Offline(() => {
 				const polySynth = new PolySynth();
 				polySynth.toDestination();
-			}).then((buffer) => {
-				expect(buffer.isSilent()).to.be.true;
 			});
+			expect(buffer.isSilent()).to.be.true;
 		});
 
-		it("can be scheduled to start in the future", () => {
-			return Offline(() => {
+		it("can be scheduled to start in the future", async () => {
+			const buffer = await Offline(() => {
 				const polySynth = new PolySynth();
 				polySynth.toDestination();
 				polySynth.triggerAttack("C4", 0.1);
-			}, 0.3).then((buffer) => {
-				expect(buffer.getTimeOfFirstSound()).to.be.closeTo(0.1, 0.01);
-			});
+			}, 0.3);
+			expect(buffer.getTimeOfFirstSound()).to.be.closeTo(0.1, 0.01);
 		});
 
-		it("can stop all sounds scheduled to start in the future when disposed", () => {
-			return Offline(() => {
+		it("can stop all sounds scheduled to start in the future when disposed", async () => {
+			const buffer = await Offline(() => {
 				const polySynth = new PolySynth();
 				polySynth.set({ envelope: { release: 0.1 } });
 				polySynth.toDestination();
@@ -140,13 +136,12 @@ describe("PolySynth", () => {
 				return atTime(0.1, () => {
 					polySynth.dispose();
 				});
-			}, 0.3).then((buffer) => {
-				expect(buffer.isSilent()).to.be.true;
-			});
+			}, 0.3);
+			expect(buffer.isSilent()).to.be.true;
 		});
 
-		it("disposes voices when they are no longer used", () => {
-			return Offline(() => {
+		it("disposes voices when they are no longer used", async () => {
+			await Offline(() => {
 				const polySynth = new PolySynth(Synth, {
 					envelope: {
 						release: 0.1,
@@ -181,8 +176,8 @@ describe("PolySynth", () => {
 			});
 		});
 
-		it("reports the active notes", () => {
-			return Offline(() => {
+		it("reports the active notes", async () => {
+			await Offline(() => {
 				const polySynth = new PolySynth();
 				polySynth.set({ envelope: { release: 0.1 } });
 				polySynth.toDestination();
@@ -222,9 +217,9 @@ describe("PolySynth", () => {
 			}, 1);
 		});
 
-		it("can trigger another attack before the release has ended", () => {
+		it("can trigger another attack before the release has ended", async () => {
 			// compute the end time
-			return Offline(() => {
+			const buffer = await Offline(() => {
 				const synth = new PolySynth(Synth, {
 					envelope: {
 						release: 0.1,
@@ -235,14 +230,13 @@ describe("PolySynth", () => {
 				synth.triggerRelease("C4", 0.1);
 				synth.triggerAttack("C4", 0.15);
 				synth.triggerRelease("C4", 0.2);
-			}, 1).then((buffer) => {
-				expect(buffer.getTimeOfLastSound()).to.be.closeTo(0.3, 0.01);
-			});
+			}, 1);
+			expect(buffer.getTimeOfLastSound()).to.be.closeTo(0.3, 0.01);
 		});
 
-		it("can trigger another attack right after the release has ended", () => {
+		it("can trigger another attack right after the release has ended", async () => {
 			// compute the end time
-			return Offline(() => {
+			const buffer = await Offline(() => {
 				const synth = new PolySynth(Synth, {
 					envelope: {
 						release: 0.1,
@@ -256,15 +250,14 @@ describe("PolySynth", () => {
 				return atTime(0.41, () => {
 					expect(synth.activeVoices).to.equal(0);
 				});
-			}, 1).then((buffer) => {
-				expect(buffer.getTimeOfLastSound()).to.be.closeTo(0.4, 0.01);
-			});
+			}, 1);
+			expect(buffer.getTimeOfLastSound()).to.be.closeTo(0.4, 0.01);
 		});
 	});
 
 	context("Transport sync", () => {
-		it("can be synced to the transport", () => {
-			return Offline(({ transport }) => {
+		it("can be synced to the transport", async () => {
+			const buffer = await Offline(({ transport }) => {
 				const polySynth = new PolySynth(Synth, {
 					envelope: {
 						release: 0.1,
@@ -274,24 +267,22 @@ describe("PolySynth", () => {
 				polySynth.triggerAttackRelease("C4", 0.1, 0.1);
 				polySynth.triggerAttackRelease("E4", 0.1, 0.3);
 				transport.start(0.1);
-			}, 0.8).then((buffer) => {
-				expect(buffer.getTimeOfFirstSound()).to.be.closeTo(0.2, 0.01);
-				expect(buffer.getTimeOfLastSound()).to.be.closeTo(0.6, 0.01);
-			});
+			}, 0.8);
+			expect(buffer.getTimeOfFirstSound()).to.be.closeTo(0.2, 0.01);
+			expect(buffer.getTimeOfLastSound()).to.be.closeTo(0.6, 0.01);
 		});
 
-		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 PolySynth(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 PolySynth(Synth, {
 					envelope: {
 						release: 0,
@@ -301,13 +292,12 @@ describe("PolySynth", () => {
 					.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 PolySynth(Synth, {
 					envelope: {
 						release: 0,
@@ -319,16 +309,15 @@ describe("PolySynth", () => {
 				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 PolySynth(Synth, {
 					envelope: {
 						sustain: 1,
@@ -340,12 +329,11 @@ describe("PolySynth", () => {
 					.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);
 		});
 	});