tone 15.2.1 → 15.2.3

package/Tone/core/clock/Transport.test.ts

@@ -60,23 +60,22 @@ describe("Transport", () => {
 			});
 		});
 
-		it("can loop events scheduled on the transport", () => {
+		it("can loop events scheduled on the transport", async () => {
 			let invocations = 0;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				transport.schedule((time) => {
 					invocations++;
 				}, 0);
 				transport.setLoopPoints(0, 0.1).start(0);
 				transport.loop = true;
-			}, 0.41).then(() => {
-				expect(invocations).to.equal(5);
-			});
+			}, 0.41);
+			expect(invocations).to.equal(5);
 		});
 
-		it("jumps to the loopStart after the loopEnd point", () => {
+		it("jumps to the loopStart after the loopEnd point", async () => {
 			let looped = false;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				transport.on("loop", () => {
 					looped = true;
@@ -85,9 +84,8 @@ describe("Transport", () => {
 				transport.loopEnd = 1;
 				transport.seconds = 2;
 				transport.start();
-			}, 0.4).then(() => {
-				expect(looped).to.equal(true);
-			});
+			}, 0.4);
+			expect(looped).to.equal(true);
 		});
 	});
 
@@ -99,8 +97,8 @@ describe("Transport", () => {
 			});
 		});
 
-		it("can get the next subdivision of the transport", () => {
-			return Offline((context) => {
+		it("can get the next subdivision of the transport", async () => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				transport.start(0);
 				return (time) => {
@@ -278,8 +276,8 @@ describe("Transport", () => {
 	});
 
 	context("state", () => {
-		it("can start, pause, and restart", () => {
-			return Offline(({ transport }) => {
+		it("can start, pause, and restart", async () => {
+			const buffer = await Offline(({ transport }) => {
 				transport.start(0).pause(0.2).start(0.4);
 
 				const pulse = new Signal(0).toDestination();
@@ -307,17 +305,16 @@ describe("Transport", () => {
 						expect(transport.state).to.equal("started");
 					});
 				};
-			}, 0.6).then((buffer) => {
-				buffer.forEach((sample, time) => {
-					whenBetween(time, 0, 0.01, () => {
-						expect(sample).to.equal(1);
-					});
-					whenBetween(time, 0.1, 0.11, () => {
-						expect(sample).to.equal(0);
-					});
-					whenBetween(time, 0.502, 0.51, () => {
-						expect(sample).to.equal(1);
-					});
+			}, 0.6);
+			buffer.forEach((sample, time) => {
+				whenBetween(time, 0, 0.01, () => {
+					expect(sample).to.equal(1);
+				});
+				whenBetween(time, 0.1, 0.11, () => {
+					expect(sample).to.equal(0);
+				});
+				whenBetween(time, 0.502, 0.51, () => {
+					expect(sample).to.equal(1);
 				});
 			});
 		});
@@ -372,8 +369,8 @@ describe("Transport", () => {
 			}, 0.1);
 		});
 
-		it("can toggle the state of the transport", () => {
-			return Offline((context) => {
+		it("can toggle the state of the transport", async () => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				transport.toggle(0);
 				transport.toggle(0.2);
@@ -390,8 +387,8 @@ describe("Transport", () => {
 			}, 0.1);
 		});
 
-		it("tracks ticks correctly with a different PPQ and BPM", () => {
-			return Offline((context) => {
+		it("tracks ticks correctly with a different PPQ and BPM", async () => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				transport.PPQ = 96;
 				transport.bpm.value = 90;
@@ -405,10 +402,10 @@ describe("Transport", () => {
 			}, 0.6);
 		});
 
-		it("can set the ticks while started", () => {
+		it("can set the ticks while started", async () => {
 			let invocations = 0;
 			const times = [0, 1.5];
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				transport.PPQ = 1;
 				transport.schedule((time) => {
 					expect(time).to.be.closeTo(times[invocations], 0.01);
@@ -418,9 +415,8 @@ describe("Transport", () => {
 				return atTime(1.1, () => {
 					transport.ticks = 0;
 				});
-			}, 2.5).then(() => {
-				expect(invocations).to.equal(2);
-			});
+			}, 2.5);
+			expect(invocations).to.equal(2);
 		});
 	});
 
@@ -433,9 +429,9 @@ describe("Transport", () => {
 			});
 		});
 
-		it("scheduled event gets invoked with the time of the event", () => {
+		it("scheduled event gets invoked with the time of the event", async () => {
 			let wasCalled = false;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				const startTime = 0.1;
 				transport.schedule((time) => {
@@ -443,14 +439,13 @@ describe("Transport", () => {
 					wasCalled = true;
 				}, 0);
 				transport.start(startTime);
-			}, 0.2).then(() => {
-				expect(wasCalled).to.equal(true);
-			});
+			}, 0.2);
+			expect(wasCalled).to.equal(true);
 		});
 
-		it("can schedule events with TransportTime", () => {
+		it("can schedule events with TransportTime", async () => {
 			let wasCalled = false;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				const startTime = 0.1;
 				const eighth = transport.toSeconds("8n");
@@ -459,9 +454,8 @@ describe("Transport", () => {
 					wasCalled = true;
 				}, TransportTime("8n"));
 				transport.start(startTime);
-			}, 0.5).then(() => {
-				expect(wasCalled).to.equal(true);
-			});
+			}, 0.5);
+			expect(wasCalled).to.be.true;
 		});
 
 		it("can clear a scheduled event", () => {
@@ -497,9 +491,9 @@ describe("Transport", () => {
 			});
 		});
 
-		it("scheduled event anywhere along the timeline", () => {
+		it("scheduled event anywhere along the timeline", async () => {
 			let wasCalled = false;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				const startTime = transport.now();
 				transport.schedule((time) => {
@@ -507,14 +501,13 @@ describe("Transport", () => {
 					wasCalled = true;
 				}, 0.5);
 				transport.start(startTime);
-			}, 0.6).then(() => {
-				expect(wasCalled).to.equal(true);
-			});
+			}, 0.6);
+			expect(wasCalled).to.equal(true);
 		});
 
-		it("can schedule multiple events and invoke them in the right order", () => {
+		it("can schedule multiple events and invoke them in the right order", async () => {
 			let wasCalled = false;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				let first = false;
 				transport.schedule(() => {
@@ -525,27 +518,25 @@ describe("Transport", () => {
 					wasCalled = true;
 				}, 0.11);
 				transport.start();
-			}, 0.2).then(() => {
-				expect(wasCalled).to.equal(true);
-			});
+			}, 0.2);
+			expect(wasCalled).to.equal(true);
 		});
 
-		it("invokes the event again if the timeline is restarted", () => {
+		it("invokes the event again if the timeline is restarted", async () => {
 			let iterations = 0;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				transport.schedule(() => {
 					iterations++;
 				}, 0.05);
 				transport.start(0).stop(0.1).start(0.2);
-			}, 0.3).then(() => {
-				expect(iterations).to.be.equal(2);
-			});
+			}, 0.3);
+			expect(iterations).to.be.equal(2);
 		});
 
-		it("can add an event after the Transport is started", () => {
+		it("can add an event after the Transport is started", async () => {
 			let wasCalled = false;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				transport.start(0);
 				let wasScheduled = false;
@@ -557,13 +548,12 @@ describe("Transport", () => {
 						}, 0.15);
 					}
 				};
-			}, 0.3).then(() => {
-				expect(wasCalled).to.equal(true);
-			});
+			}, 0.3);
+			expect(wasCalled).to.equal(true);
 		});
 
 		it("warns if the scheduled time was not used in the callback", async () => {
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				const synth = new Synth();
 				transport.schedule(() => {
 					warns(() => {
@@ -571,7 +561,7 @@ describe("Transport", () => {
 					});
 				}, 0);
 				transport.start(0);
-			}, 0.3).then(() => {});
+			}, 0.3);
 		});
 	});
 
@@ -584,9 +574,9 @@ describe("Transport", () => {
 			});
 		});
 
-		it("scheduled event gets invoked with the time of the event", () => {
+		it("scheduled event gets invoked with the time of the event", async () => {
 			let invoked = false;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				const startTime = 0.1;
 				const eventID = transport.scheduleRepeat(
@@ -599,9 +589,8 @@ describe("Transport", () => {
 					0
 				);
 				transport.start(startTime);
-			}, 0.3).then(() => {
-				expect(invoked).to.equal(true);
-			});
+			}, 0.3);
+			expect(invoked).to.equal(true);
 		});
 
 		it("can cancel the timeline of scheduleRepeat", () => {
@@ -619,9 +608,9 @@ describe("Transport", () => {
 			});
 		});
 
-		it("can schedule events with TransportTime", () => {
+		it("can schedule events with TransportTime", async () => {
 			let invoked = false;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				const startTime = 0.1;
 				const eighth = transport.toSeconds("8n");
@@ -634,9 +623,8 @@ describe("Transport", () => {
 					TransportTime("8n")
 				);
 				transport.start(startTime);
-			}, 0.4).then(() => {
-				expect(invoked).to.equal(true);
-			});
+			}, 0.4);
+			expect(invoked).to.equal(true);
 		});
 
 		it("can clear a scheduled event", () => {
@@ -654,9 +642,9 @@ describe("Transport", () => {
 			});
 		});
 
-		it("can be scheduled in the future", () => {
+		it("can be scheduled in the future", async () => {
 			let invoked = false;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				const startTime = 0.1;
 				const eventID = transport.scheduleRepeat(
@@ -669,14 +657,13 @@ describe("Transport", () => {
 					0.2
 				);
 				transport.start(startTime);
-			}, 0.5).then(() => {
-				expect(invoked).to.equal(true);
-			});
+			}, 0.5);
+			expect(invoked).to.equal(true);
 		});
 
-		it("repeats a repeat event", () => {
+		it("repeats a repeat event", async () => {
 			let invocations = 0;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				transport.scheduleRepeat(
 					() => {
@@ -686,14 +673,13 @@ describe("Transport", () => {
 					0
 				);
 				transport.start();
-			}, 0.51).then(() => {
-				expect(invocations).to.equal(6);
-			});
+			}, 0.51);
+			expect(invocations).to.equal(6);
 		});
 
-		it("repeats at the repeat interval", () => {
+		it("repeats at the repeat interval", async () => {
 			let wasCalled = false;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				let repeatTime = -1;
 				transport.scheduleRepeat(
@@ -708,15 +694,14 @@ describe("Transport", () => {
 					0
 				);
 				transport.start();
-			}, 0.5).then(() => {
-				expect(wasCalled).to.equal(true);
-			});
+			}, 0.5);
+			expect(wasCalled).to.equal(true);
 		});
 
-		it("can schedule multiple events and invoke them in the right order", () => {
+		it("can schedule multiple events and invoke them in the right order", async () => {
 			let first = false;
 			let second = false;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				const firstID = transport.scheduleRepeat(
 					() => {
@@ -736,15 +721,14 @@ describe("Transport", () => {
 					0.11
 				);
 				transport.start();
-			}, 0.3).then(() => {
-				expect(first);
-				expect(second);
-			});
+			}, 0.3);
+			expect(first);
+			expect(second);
 		});
 
-		it("repeats for the given interval", () => {
+		it("repeats for the given interval", async () => {
 			let repeatCount = 0;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				transport.scheduleRepeat(
 					(time) => {
@@ -755,14 +739,13 @@ describe("Transport", () => {
 					0.5
 				);
 				transport.start();
-			}, 0.61).then(() => {
-				expect(repeatCount).to.equal(5);
-			});
+			}, 0.61);
+			expect(repeatCount).to.equal(5);
 		});
 
-		it("can add an event after the Transport is started", () => {
+		it("can add an event after the Transport is started", async () => {
 			let invocations = 0;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				transport.start(0);
 				let wasScheduled = false;
@@ -783,14 +766,13 @@ describe("Transport", () => {
 						);
 					}
 				};
-			}, 0.31).then(() => {
-				expect(invocations).to.equal(2);
-			});
+			}, 0.31);
+			expect(invocations).to.equal(2);
 		});
 
-		it("can add an event to the past after the Transport is started", () => {
+		it("can add an event to the past after the Transport is started", async () => {
 			let invocations = 0;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				transport.start(0);
 				let wasScheduled = false;
@@ -811,9 +793,8 @@ describe("Transport", () => {
 						);
 					}
 				};
-			}, 0.3).then(() => {
-				expect(invocations).to.equal(2);
-			});
+			}, 0.3);
+			expect(invocations).to.equal(2);
 		});
 	});
 
@@ -826,9 +807,9 @@ describe("Transport", () => {
 			});
 		});
 
-		it("scheduled event gets invoked with the time of the event", () => {
+		it("scheduled event gets invoked with the time of the event", async () => {
 			let invoked = false;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				const startTime = 0.1;
 				const eventID = transport.scheduleOnce((time) => {
@@ -837,14 +818,13 @@ describe("Transport", () => {
 					expect(time).to.be.closeTo(startTime, 0.01);
 				}, 0);
 				transport.start(startTime);
-			}, 0.2).then(() => {
-				expect(invoked).to.equal(true);
-			});
+			}, 0.2);
+			expect(invoked).to.equal(true);
 		});
 
-		it("can schedule events with TransportTime", () => {
+		it("can schedule events with TransportTime", async () => {
 			let invoked = false;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				const startTime = 0.1;
 				const eighth = transport.toSeconds("8n");
@@ -853,9 +833,8 @@ describe("Transport", () => {
 					invoked = true;
 				}, TransportTime("8n"));
 				transport.start(startTime);
-			}, 0.5).then(() => {
-				expect(invoked).to.equal(true);
-			});
+			}, 0.5);
+			expect(invoked).to.equal(true);
 		});
 
 		it("can clear a scheduled event", () => {
@@ -869,9 +848,9 @@ describe("Transport", () => {
 			});
 		});
 
-		it("can be scheduled in the future", () => {
+		it("can be scheduled in the future", async () => {
 			let invoked = false;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				const startTime = transport.now() + 0.1;
 				const eventID = transport.scheduleOnce((time) => {
@@ -880,29 +859,27 @@ describe("Transport", () => {
 					invoked = true;
 				}, 0.3);
 				transport.start(startTime);
-			}, 0.5).then(() => {
-				expect(invoked).to.equal(true);
-			});
+			}, 0.5);
+			expect(invoked).to.equal(true);
 		});
 
-		it("the event is removed after is is invoked", () => {
+		it("the event is removed after is is invoked", async () => {
 			let iterations = 0;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				transport.scheduleOnce(() => {
 					iterations++;
 				}, 0);
 				transport.start().stop("+0.1").start("+0.2");
-			}, 0.5).then(() => {
-				expect(iterations).to.be.lessThan(2);
-			});
+			}, 0.5);
+			expect(iterations).to.be.lessThan(2);
 		});
 	});
 
 	context("events", () => {
-		it("invokes start/stop/pause events", () => {
+		it("invokes start/stop/pause events", async () => {
 			let invocations = 0;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				transport.on("start", () => {
 					invocations++;
@@ -914,14 +891,13 @@ describe("Transport", () => {
 					invocations++;
 				});
 				transport.start().stop(0.1).start(0.2);
-			}, 0.5).then(() => {
-				expect(invocations).to.equal(3);
-			});
+			}, 0.5);
+			expect(invocations).to.equal(3);
 		});
 
-		it("invokes start event with correct offset", () => {
+		it("invokes start event with correct offset", async () => {
 			let wasCalled = false;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				transport.on("start", (time, offset) => {
 					expect(time).to.be.closeTo(0.2, 0.01);
@@ -929,14 +905,13 @@ describe("Transport", () => {
 					wasCalled = true;
 				});
 				transport.start(0.2, "4n");
-			}, 0.3).then(() => {
-				expect(wasCalled).to.equal(true);
-			});
+			}, 0.3);
+			expect(wasCalled).to.equal(true);
 		});
 
-		it("invokes the event just before the scheduled time", () => {
+		it("invokes the event just before the scheduled time", async () => {
 			let invoked = false;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				transport.on("start", (time, offset) => {
 					expect(time - transport.context.currentTime).to.be.closeTo(
@@ -947,14 +922,13 @@ describe("Transport", () => {
 					invoked = true;
 				});
 				transport.start(0.2);
-			}, 0.3).then(() => {
-				expect(invoked).to.equal(true);
-			});
+			}, 0.3);
+			expect(invoked).to.equal(true);
 		});
 
-		it("passes in the time argument to the events", () => {
+		it("passes in the time argument to the events", async () => {
 			let invocations = 0;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				const now = transport.now();
 				transport.on("start", (time) => {
@@ -966,14 +940,13 @@ describe("Transport", () => {
 					expect(time).to.be.closeTo(now + 0.2, 0.01);
 				});
 				transport.start("+0.1").stop("+0.2");
-			}, 0.3).then(() => {
-				expect(invocations).to.equal(2);
-			});
+			}, 0.3);
+			expect(invocations).to.equal(2);
 		});
 
-		it("invokes the 'loop' method on loop", () => {
+		it("invokes the 'loop' method on loop", async () => {
 			let loops = 0;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				const sixteenth = transport.toSeconds("16n");
 				transport.setLoopPoints(0, sixteenth);
@@ -987,9 +960,8 @@ describe("Transport", () => {
 					lastLoop = time;
 				});
 				transport.start(0).stop(sixteenth * 5.1);
-			}, 0.7).then(() => {
-				expect(loops).to.equal(5);
-			});
+			}, 0.7);
+			expect(loops).to.equal(5);
 		});
 	});
 
@@ -1014,9 +986,9 @@ describe("Transport", () => {
 			});
 		});
 
-		it("can swing", () => {
+		it("can swing", async () => {
 			let invocations = 0;
-			return Offline((context) => {
+			await Offline((context) => {
 				const transport = new TransportClass({ context });
 				transport.swing = 1;
 				transport.swingSubdivision = "8n";
@@ -1042,9 +1014,8 @@ describe("Transport", () => {
 					expect(time).is.closeTo(eightNote * 2, 0.001);
 				}, "4n");
 				transport.start(0).stop(0.7);
-			}, 0.7).then(() => {
-				expect(invocations).to.equal(4);
-			});
+			}, 0.7);
+			expect(invocations).to.equal(4);
 		});
 	});
 });

package/Tone/core/clock/TransportEvent.test.ts

@@ -25,9 +25,9 @@ describe("TransportEvent", () => {
 		});
 	});
 
-	it("can invoke the callback", () => {
+	it("can invoke the callback", async () => {
 		let wasInvoked = false;
-		return Offline((context) => {
+		await Offline((context) => {
 			const transport = new TransportClass({ context });
 			const event = new TransportEvent(transport, {
 				callback: (time) => {
@@ -37,8 +37,7 @@ describe("TransportEvent", () => {
 				time: 0,
 			});
 			event.invoke(100);
-		}).then(() => {
-			expect(wasInvoked).to.equal(true);
 		});
+		expect(wasInvoked).to.equal(true);
 	});
 });