tone 15.2.0 → 15.2.2

package/Tone/event/Pattern.test.ts

@@ -84,9 +84,9 @@ describe("Pattern", () => {
 	});
 
 	context("Callback", () => {
-		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 values = ["a", "b", "c"];
 				let index = 0;
 				const pattern = new Pattern(() => {
@@ -96,14 +96,13 @@ describe("Pattern", () => {
 					index++;
 				}, values).start(0);
 				transport.start();
-			}, 0.2).then(() => {
-				expect(invoked).to.be.true;
-			});
+			}, 0.2);
+			expect(invoked).to.be.true;
 		});
 
-		it("passes in the scheduled time and pattern note to the callback", () => {
+		it("passes in the scheduled time and pattern note to the callback", async () => {
 			let invoked = false;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				const startTime = 0.05;
 				const pattern = new Pattern(
 					(time, note) => {
@@ -119,14 +118,13 @@ describe("Pattern", () => {
 				);
 				transport.start(startTime);
 				pattern.start(0.3);
-			}, 0.4).then(() => {
-				expect(invoked).to.be.true;
-			});
+			}, 0.4);
+			expect(invoked).to.be.true;
 		});
 
-		it("passes in the next note of the pattern", () => {
+		it("passes in the next note of the pattern", async () => {
 			let counter = 0;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				const values = ["a", "b", "c"];
 				const pattern = new Pattern(
 					(time, note) => {
@@ -140,14 +138,13 @@ describe("Pattern", () => {
 				).start(0);
 				pattern.interval = "16n";
 				transport.start(0);
-			}, 0.7).then(() => {
-				expect(counter).to.equal(6);
-			});
+			}, 0.7);
+			expect(counter).to.equal(6);
 		});
 
-		it("can modify the pattern type and values", () => {
+		it("can modify the pattern type and values", async () => {
 			let counter = 0;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				const values = ["a", "b", "c"];
 				const pattern = new Pattern(
 					(time, note) => {
@@ -163,9 +160,8 @@ describe("Pattern", () => {
 				pattern.pattern = "up";
 				pattern.values = values;
 				transport.start(0);
-			}, 0.7).then(() => {
-				expect(counter).to.equal(6);
-			});
+			}, 0.7);
+			expect(counter).to.equal(6);
 		});
 	});
 });

package/Tone/event/Sequence.test.ts

@@ -9,8 +9,8 @@ describe("Sequence", () => {
 	BasicTests(Sequence);
 
 	context("Constructor", () => {
-		it("takes a callback and a sequence of values", () => {
-			return Offline(() => {
+		it("takes a callback and a sequence of values", async () => {
+			await Offline(() => {
 				const callback = noOp;
 				const seq = new Sequence(callback, [0, 1, 2]);
 				expect(seq.callback).to.equal(callback);
@@ -19,8 +19,8 @@ describe("Sequence", () => {
 			});
 		});
 
-		it("takes a callback and a sequence of values and a subdivision", () => {
-			return Offline(() => {
+		it("takes a callback and a sequence of values and a subdivision", async () => {
+			await Offline(() => {
 				const callback = noOp;
 				const seq = new Sequence(callback, [0, 1, 2], "2n");
 				expect(seq.callback).to.equal(callback);
@@ -30,16 +30,16 @@ describe("Sequence", () => {
 			});
 		});
 
-		it("can be constructed with no arguments", () => {
-			return Offline(() => {
+		it("can be constructed with no arguments", async () => {
+			await Offline(() => {
 				const seq = new Sequence();
 				expect(seq.length).to.equal(0);
 				seq.dispose();
 			});
 		});
 
-		it("can pass in arguments in options object", () => {
-			return Offline(() => {
+		it("can pass in arguments in options object", async () => {
+			await Offline(() => {
 				const callback = noOp;
 				const seq = new Sequence({
 					callback,
@@ -59,8 +59,8 @@ describe("Sequence", () => {
 			});
 		});
 
-		it("loops by default with the loopEnd as the duration of the loop", () => {
-			return Offline(() => {
+		it("loops by default with the loopEnd as the duration of the loop", async () => {
+			await Offline(() => {
 				const seq = new Sequence(noOp, [0, 1, 2, 3], "8n");
 				expect(seq.loop).to.be.true;
 				expect(seq.length).to.equal(4);
@@ -71,8 +71,8 @@ describe("Sequence", () => {
 	});
 
 	context("Adding / Removing / Getting Events", () => {
-		it("can add an event using the index", () => {
-			return Offline(() => {
+		it("can add an event using the index", async () => {
+			await Offline(() => {
 				const seq = new Sequence();
 				seq.events[0] = 0;
 				expect(seq.length).to.equal(1);
@@ -82,8 +82,8 @@ describe("Sequence", () => {
 			});
 		});
 
-		it("can add a subsequence", () => {
-			return Offline(() => {
+		it("can add a subsequence", async () => {
+			await Offline(() => {
 				const seq = new Sequence();
 				seq.events = [[0, 1, 2]];
 				expect(seq.length).to.equal(3);
@@ -91,8 +91,8 @@ describe("Sequence", () => {
 			});
 		});
 
-		it("can retrieve an event using the index", () => {
-			return Offline(() => {
+		it("can retrieve an event using the index", async () => {
+			await Offline(() => {
 				const seq = new Sequence(noOp, [0, 1, 2]);
 				expect(seq.length).to.equal(3);
 				expect(seq.events[0]).to.equal(0);
@@ -103,8 +103,8 @@ describe("Sequence", () => {
 			});
 		});
 
-		it("can set the value of an existing event with an index", () => {
-			return Offline(() => {
+		it("can set the value of an existing event with an index", async () => {
+			await Offline(() => {
 				const seq = new Sequence(noOp, [0, 1, 2]);
 				expect(seq.length).to.equal(3);
 				expect(seq.events[0]).to.equal(0);
@@ -114,8 +114,8 @@ describe("Sequence", () => {
 			});
 		});
 
-		it("can remove an event by index", () => {
-			return Offline(() => {
+		it("can remove an event by index", async () => {
+			await Offline(() => {
 				const seq = new Sequence(noOp, [0, 1, 2]);
 				expect(seq.length).to.equal(3);
 				seq.events.splice(0, 1);
@@ -124,8 +124,8 @@ describe("Sequence", () => {
 			});
 		});
 
-		it("can add a subsequence and remove the entire subsequence", () => {
-			return Offline(() => {
+		it("can add a subsequence and remove the entire subsequence", async () => {
+			await Offline(() => {
 				const seq = new Sequence(noOp, [0, 1, 2]);
 				expect(seq.length).to.equal(3);
 				seq.events.shift();
@@ -142,8 +142,8 @@ describe("Sequence", () => {
 			});
 		});
 
-		it("can remove all of the events", () => {
-			return Offline(() => {
+		it("can remove all of the events", async () => {
+			await Offline(() => {
 				const seq = new Sequence(noOp, [0, 1, 2, 3, 4, 5]);
 				expect(seq.length).to.equal(6);
 				seq.clear();
@@ -153,22 +153,21 @@ describe("Sequence", () => {
 		});
 	});
 	context("Sequence callback", () => {
-		it("invokes the callback after it's started", () => {
+		it("invokes the callback after it's started", async () => {
 			let invoked = false;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				const seq = new Sequence(() => {
 					seq.dispose();
 					invoked = true;
 				}, [0, 1]).start(0);
 				transport.start();
-			}, 0.1).then(() => {
-				expect(invoked).to.be.true;
-			});
+			}, 0.1);
+			expect(invoked).to.be.true;
 		});
 
-		it("can be scheduled to stop", () => {
+		it("can be scheduled to stop", async () => {
 			let invoked = 0;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				const seq = new Sequence(
 					() => {
 						invoked++;
@@ -179,14 +178,13 @@ describe("Sequence", () => {
 					.start(0)
 					.stop(0.5);
 				transport.start();
-			}, 1).then(() => {
-				expect(invoked).to.equal(6);
-			});
+			}, 1);
+			expect(invoked).to.equal(6);
 		});
 
-		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 seq = new Sequence(
 					(time) => {
@@ -199,14 +197,13 @@ describe("Sequence", () => {
 				);
 				seq.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 seq = new Sequence(
 					(time, thing) => {
 						expect(time).to.be.a("number");
@@ -217,14 +214,13 @@ describe("Sequence", () => {
 					["thing"]
 				).start();
 				transport.start();
-			}, 0.1).then(() => {
-				expect(invoked).to.be.true;
-			});
+			}, 0.1);
+			expect(invoked).to.be.true;
 		});
 
-		it("invokes the scheduled events in the right order", () => {
+		it("invokes the scheduled events in the right order", async () => {
 			let count = 0;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				const seq = new Sequence(
 					(time, value) => {
 						expect(value).to.equal(count);
@@ -235,14 +231,13 @@ describe("Sequence", () => {
 				).start();
 				seq.loop = false;
 				transport.start(0);
-			}, 0.5).then(() => {
-				expect(count).to.equal(5);
-			});
+			}, 0.5);
+			expect(count).to.equal(5);
 		});
 
-		it("invokes the scheduled events at the correct times", () => {
+		it("invokes the scheduled events at the correct times", async () => {
 			let count = 0;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				const eighth = transport.toSeconds("8n");
 				const times = [
 					0,
@@ -262,14 +257,13 @@ describe("Sequence", () => {
 				).start(0);
 				seq.loop = false;
 				transport.start(0);
-			}, 0.8).then(() => {
-				expect(count).to.equal(6);
-			});
+			}, 0.8);
+			expect(count).to.equal(6);
 		});
 
-		it("can schedule rests using 'null'", () => {
+		it("can schedule rests using 'null'", async () => {
 			let count = 0;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				const eighth = transport.toSeconds("8n");
 				const times = [0, eighth * 2.5];
 				const seq = new Sequence(
@@ -282,14 +276,13 @@ describe("Sequence", () => {
 				).start(0);
 				seq.loop = false;
 				transport.start(0);
-			}, 0.8).then(() => {
-				expect(count).to.equal(2);
-			});
+			}, 0.8);
+			expect(count).to.equal(2);
 		});
 
-		it("can schedule triple nested arrays", () => {
+		it("can schedule triple nested arrays", async () => {
 			let count = 0;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				const eighth = transport.toSeconds("8n");
 				const times = [0, eighth, eighth * 1.5, eighth * 1.75];
 				const seq = new Sequence(
@@ -302,14 +295,13 @@ describe("Sequence", () => {
 				).start(0);
 				seq.loop = false;
 				transport.start(0);
-			}, 0.7).then(() => {
-				expect(count).to.equal(4);
-			});
+			}, 0.7);
+			expect(count).to.equal(4);
 		});
 
-		it("starts an event added after the seq was started", () => {
+		it("starts an event added after the seq was started", async () => {
 			let invoked = false;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				const seq = new Sequence({
 					callback(time, value): void {
 						if (value === 1) {
@@ -324,13 +316,12 @@ describe("Sequence", () => {
 				return atTime(0.1, () => {
 					seq.events[1] = 1;
 				});
-			}, 0.5).then(() => {
-				expect(invoked).to.be.true;
-			});
+			}, 0.5);
+			expect(invoked).to.be.true;
 		});
 
-		it("can mute the callback", () => {
-			return Offline(({ transport }) => {
+		it("can mute the callback", async () => {
+			await Offline(({ transport }) => {
 				const seq = new Sequence(() => {
 					throw new Error("shouldn't call this callback");
 				}, [0, 0.1, 0.2, 0.3]).start();
@@ -342,9 +333,9 @@ describe("Sequence", () => {
 	});
 
 	context("Looping", () => {
-		it("can be set to loop", () => {
+		it("can be set to loop", async () => {
 			let callCount = 0;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				const seq = new Sequence({
 					events: [0, 1],
 					loop: true,
@@ -357,14 +348,13 @@ describe("Sequence", () => {
 					},
 				}).start(0);
 				transport.start();
-			}, 0.5).then(() => {
-				expect(callCount).to.equal(3);
-			});
+			}, 0.5);
+			expect(callCount).to.equal(3);
 		});
 
-		it("can loop between loopStart and loopEnd", () => {
+		it("can loop between loopStart and loopEnd", async () => {
 			let invokations = 0;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				const seq = new Sequence({
 					events: [0, [1, 2, 3], [4, 5]],
 					loopEnd: 2,
@@ -377,14 +367,13 @@ describe("Sequence", () => {
 					},
 				}).start(0);
 				transport.start();
-			}, 0.7).then(() => {
-				expect(invokations).to.equal(9);
-			});
+			}, 0.7);
+			expect(invokations).to.equal(9);
 		});
 
-		it("can set the loop points after starting", () => {
+		it("can set the loop points after starting", async () => {
 			let invoked = false;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				let switched = false;
 				const seq = new Sequence({
 					callback(time, value): void {
@@ -402,16 +391,15 @@ describe("Sequence", () => {
 					subdivision: "16n",
 				}).start(0);
 				transport.start();
-			}, 0.7).then(() => {
-				expect(invoked).to.be.true;
-			});
+			}, 0.7);
+			expect(invoked).to.be.true;
 		});
 	});
 
 	context("playbackRate", () => {
-		it("can adjust the playbackRate", () => {
+		it("can adjust the playbackRate", async () => {
 			let invoked = false;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				let lastCall;
 				new Sequence({
 					events: [0, 1],
@@ -426,14 +414,13 @@ describe("Sequence", () => {
 					},
 				}).start(0);
 				transport.start();
-			}, 0.7).then(() => {
-				expect(invoked).to.be.true;
-			});
+			}, 0.7);
+			expect(invoked).to.be.true;
 		});
 
-		it("adjusts speed of subsequences", () => {
+		it("adjusts speed of subsequences", async () => {
 			let invoked = false;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				let lastCall;
 				new Sequence({
 					events: [
@@ -451,14 +438,13 @@ describe("Sequence", () => {
 					},
 				}).start(0);
 				transport.start();
-			}, 0.7).then(() => {
-				expect(invoked).to.be.true;
-			});
+			}, 0.7);
+			expect(invoked).to.be.true;
 		});
 
-		it("can adjust the playbackRate after starting", () => {
+		it("can adjust the playbackRate after starting", async () => {
 			let invoked = false;
-			return Offline(({ transport }) => {
+			await Offline(({ transport }) => {
 				let lastCall;
 				const seq = new Sequence({
 					events: [0, 1],
@@ -475,9 +461,8 @@ describe("Sequence", () => {
 					},
 				}).start(0);
 				transport.start();
-			}, 2).then(() => {
-				expect(invoked).to.be.true;
-			});
+			}, 2);
+			expect(invoked).to.be.true;
 		});
 	});
 });