tone 15.5.48 → 15.5.49

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

@@ -413,6 +413,35 @@ describe("Clock", () => {
 			// the post-restart ticks from offset 40
 			expect(observedTicks).to.deep.equal([0, 1, 2, 40, 41]);
 		});
+
+		it("emits the stop event when stop and the following start happen at the same time within the stale window", async () => {
+			const events: Array<[string, number]> = [];
+			let restartTime = 0;
+			await Offline(() => {
+				const clock = new Clock(noOp, 200);
+				const boundLoop = (
+					clock as unknown as { _boundLoop: () => void }
+				)._boundLoop;
+				clock.on("stop", (time) => events.push(["stop", time]));
+				clock.on("start", (time) => events.push(["start", time]));
+				clock.start(0);
+				// Same staleness simulation as above. stop() and start() are
+				// scheduled at the same instant, as happens when both default
+				// to now() within one task: `transport.stop(); transport.start()`
+				clock.context.off("tick", boundLoop);
+				return atTime(0.02, (time) => {
+					restartTime = time;
+					clock.stop(time);
+					clock.start(time, 40);
+					clock.context.on("tick", boundLoop);
+				});
+			}, 0.03);
+			expect(events).to.deep.equal([
+				["start", 0],
+				["stop", restartTime],
+				["start", restartTime],
+			]);
+		});
 	});
 
 	context("Events", () => {

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

@@ -76,6 +76,19 @@ describe("TickSource", () => {
 			}, 0.5);
 		});
 
+		it("reports the restart offset just after a stop and start at the same time", () => {
+			const source = new TickSource(3);
+			source.start(0);
+			source.stop(1);
+			source.start(1, 10);
+			expect(source.getTicksAtTime(1)).to.be.closeTo(10, 0.01);
+			// the first tick time of the restarted period is computed from the
+			// frequency integral and can land a rounding error after the start
+			expect(source.getTicksAtTime(1 + 1e-12)).to.be.closeTo(10, 0.01);
+			expect(source.getTicksAtTime(1.5)).to.be.closeTo(11.5, 0.01);
+			source.dispose();
+		});
+
 		it("ticks restart at 0 when started after stop", () => {
 			const source = new TickSource(3);
 			source.start(0).stop(1).start(2);

package/Tone/core/util/Timeline.test.ts

@@ -604,5 +604,61 @@ describe("Timeline", () => {
 			expect(count).to.equal(0);
 			sched.dispose();
 		});
+
+		it("includes every event at the start time and excludes every event at the end time", () => {
+			const sched = new Timeline<{ time: number; id: string }>();
+			sched.add({ time: 0.1, id: "a" });
+			sched.add({ time: 0.2, id: "b" });
+			sched.add({ time: 0.2, id: "c" });
+			sched.add({ time: 0.3, id: "d" });
+			sched.add({ time: 0.3, id: "e" });
+			const visited = (start: number, end: number): string[] => {
+				const ids: string[] = [];
+				sched.forEachBetween(start, end, (event) => ids.push(event.id));
+				return ids;
+			};
+			expect(visited(0.1, 0.2)).to.deep.equal(["a"]);
+			expect(visited(0.2, 0.3)).to.deep.equal(["b", "c"]);
+			expect(visited(0.3, 0.4)).to.deep.equal(["d", "e"]);
+			expect(visited(0.15, 0.25)).to.deep.equal(["b", "c"]);
+			sched.dispose();
+		});
+
+		it("visits an event added at the boundary after the previous range was iterated", () => {
+			// two consecutive ranges [0.1, 0.2) and [0.2, 0.4); an event at 0.2
+			// is added between the two iterations, after another event at 0.2
+			const sched = new Timeline<{ time: number; id: string }>();
+			sched.add({ time: 0.1, id: "a" });
+			sched.add({ time: 0.2, id: "b" });
+			const ids: string[] = [];
+			sched.forEachBetween(0.1, 0.2, (event) => ids.push(event.id));
+			sched.add({ time: 0.2, id: "c" });
+			sched.forEachBetween(0.2, 0.4, (event) => ids.push(event.id));
+			expect(ids).to.deep.equal(["a", "b", "c"]);
+			sched.dispose();
+		});
+
+		it("includes events within rounding error of the start time", () => {
+			// _search compares times with an epsilon; the range bounds must too
+			const sched = new Timeline<{ time: number; id: string }>();
+			sched.add({ time: 0.1, id: "a" });
+			sched.add({ time: 0.2, id: "b" });
+			sched.add({ time: 0.2 + 1e-12, id: "c" });
+			const ids: string[] = [];
+			sched.forEachBetween(0.2, 0.3, (event) => ids.push(event.id));
+			expect(ids).to.deep.equal(["b", "c"]);
+			sched.dispose();
+		});
+
+		it("excludes the end time when the start time is before the first event", () => {
+			const sched = new Timeline<{ time: number; id: string }>();
+			sched.add({ time: 0.1, id: "a" });
+			sched.add({ time: 0.2, id: "b" });
+			sched.add({ time: 0.2, id: "c" });
+			const ids: string[] = [];
+			sched.forEachBetween(0, 0.2, (event) => ids.push(event.id));
+			expect(ids).to.deep.equal(["a"]);
+			sched.dispose();
+		});
 	});
 });

package/Tone/core/util/Timeline.ts

@@ -387,20 +387,32 @@ export class Timeline<GenericEvent extends TimelineEvent> extends Tone {
 		endTime: number,
 		callback: (event: GenericEvent) => void
 	): this {
+		// _search compares times with an epsilon, so do the same here
 		let lowerBound = this._search(startTime);
 		let upperBound = this._search(endTime);
-		if (lowerBound !== -1 && upperBound !== -1) {
-			if (this._timeline[lowerBound].time !== startTime) {
-				lowerBound += 1;
+		if (lowerBound === -1) {
+			// every event is after the start time
+			lowerBound = 0;
+		} else if (EQ(this._timeline[lowerBound].time, startTime)) {
+			// _search returns the last event at the start time,
+			// include every event at the start time
+			while (
+				lowerBound > 0 &&
+				EQ(this._timeline[lowerBound - 1].time, startTime)
+			) {
+				lowerBound -= 1;
 			}
-			// exclusive of the end time
-			if (this._timeline[upperBound].time === endTime) {
-				upperBound -= 1;
-			}
-			this._iterate(callback, lowerBound, upperBound);
-		} else if (lowerBound === -1) {
-			this._iterate(callback, 0, upperBound);
+		} else {
+			lowerBound += 1;
+		}
+		// exclusive of the end time
+		while (
+			upperBound >= 0 &&
+			EQ(this._timeline[upperBound].time, endTime)
+		) {
+			upperBound -= 1;
 		}
+		this._iterate(callback, lowerBound, upperBound);
 		return this;
 	}
 

package/Tone/source/Source.test.ts

@@ -330,6 +330,37 @@ describe("Source", () => {
 			expect(output.getValueAtTime(0.5)).to.be.equal(0);
 		});
 
+		it("stops the playing source when the transport is stopped and restarted at the same time", async () => {
+			const output = await Offline(({ transport }) => {
+				const source = new Player(rampBuffer).toDestination();
+				source.sync().start(0);
+				const clock = (
+					transport as unknown as {
+						_clock: {
+							context: typeof transport.context;
+							_boundLoop: () => void;
+						};
+					}
+				)._clock;
+				transport.start(0);
+				// hold the clock loop back so that stop/start land ahead of
+				// _lastUpdate, as they do in a realtime context where both
+				// default to now() = currentTime + lookAhead
+				clock.context.off("tick", clock._boundLoop);
+				return atTime(0.2, (time) => {
+					transport.stop(time);
+					transport.start(time, 0.5);
+					clock.context.on("tick", clock._boundLoop);
+				});
+			}, 0.5);
+			// before the restart the ramp plays from 0
+			expect(output.getValueAtTime(0.1)).to.be.closeTo(0.1, 0.01);
+			// after the restart only the source started at offset 0.5 plays;
+			// if the first source were orphaned the two ramps would sum
+			expect(output.getValueAtTime(0.3)).to.be.closeTo(0.6, 0.01);
+			expect(output.getValueAtTime(0.4)).to.be.closeTo(0.7, 0.01);
+		});
+
 		it("gives the correct offset on time on start/stop events when started with an offset", async () => {
 			const output = await Offline(({ transport }) => {
 				const source = new Player(rampBuffer).toDestination();

package/Tone/version.ts

@@ -1 +1 @@
-export const version: string = "15.5.48";
+export const version: string = "15.5.49";