tone 15.5.18 → 15.5.20

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

@@ -544,6 +544,65 @@ describe("TickSource", () => {
 			});
 			source.dispose();
 		});
+
+		it("does not fire duplicate ticks across consecutive windows at a tick boundary", () => {
+			// Reproduces the double-trigger bug from issues #1080/#1098/#1175.
+			// At 400 ticks/sec (equivalent to BPM=125, PPQ=192), tick 7680 falls
+			// at exactly t=19.2s.
+			const source = new TickSource(400);
+			source.start(0);
+
+			const firedTicks: number[] = [];
+			// Window 1 ends just above the tick-7680 boundary
+			source.forEachTickBetween(
+				19.19709750566994,
+				19.20000000000101,
+				(_, tick) => firedTicks.push(tick)
+			);
+			// Window 2 starts at exactly that same boundary
+			source.forEachTickBetween(
+				19.20000000000101,
+				19.202902494332076,
+				(_, tick) => firedTicks.push(tick)
+			);
+
+			const occurrences = firedTicks.filter((t) => t === 7680).length;
+			expect(occurrences).to.equal(
+				1,
+				`tick 7680 should fire exactly once, but fired ${occurrences} times`
+			);
+			source.dispose();
+		});
+
+		it("fires every tick exactly once across many consecutive windows", () => {
+			// At 2 Hz, ticks fall at 0, 0.5, 1.0, 1.5, 2.0.
+			// Window boundaries are placed just above each tick time (tick + eps)
+			// so every tick lands right at the end of one window and the start of the next.
+			const source = new TickSource(2);
+			source.start(0);
+
+			const tickCount = new Map<number, number>();
+			const record = (_: number, tick: number) => {
+				tickCount.set(tick, (tickCount.get(tick) ?? 0) + 1);
+			};
+
+			// Non-overlapping consecutive windows whose boundaries sit just above
+			// the tick times (0, 0.5, 1.0, 1.5, 2.0).
+			const eps = 1e-10;
+			source.forEachTickBetween(0, 0.5 + eps, record); // tick 0 (at 0.0) and tick 1 (at 0.5)
+			source.forEachTickBetween(0.5 + eps, 1.0 + eps, record); // tick 2 (at 1.0)
+			source.forEachTickBetween(1.0 + eps, 1.5 + eps, record); // tick 3 (at 1.5)
+			source.forEachTickBetween(1.5 + eps, 2.0 + eps, record); // tick 4 (at 2.0)
+			source.forEachTickBetween(2.0 + eps, 2.5, record); // tick 5 (at 2.5, not included)
+
+			for (const [tick, count] of tickCount) {
+				expect(count).to.equal(
+					1,
+					`tick ${tick} fired ${count} times instead of once`
+				);
+			}
+			source.dispose();
+		});
 	});
 
 	context("Seconds", () => {

package/Tone/core/clock/TickSource.ts

@@ -415,18 +415,28 @@ export class TickSource<
 
 		if (lastStateEvent && lastStateEvent.state === "started") {
 			const maxStartTime = Math.max(lastStateEvent.time, startTime);
-			// figure out the difference between the frequency ticks and the
+			// Figure out how far past the last whole-tick boundary maxStartTime
+			// sits, so we can compute the time of the next tick at or after it.
 			const startTicks = this.frequency.getTicksAtTime(maxStartTime);
 			const ticksAtStart = this.frequency.getTicksAtTime(
 				lastStateEvent.time
 			);
 			const diff = startTicks - ticksAtStart;
-			let offset = Math.ceil(diff) - diff;
-			// guard against floating point issues
-			offset = EQ(offset, 1) ? 0 : offset;
-			let nextTickTime = this.frequency.getTimeOfTick(
-				startTicks + offset
-			);
+			const offset = Math.ceil(diff) - diff;
+			// Guard against floating-point issues: when startTicks is just barely
+			// above an integer tick boundary (offset ≈ 1), snap back to that integer
+			const firstTick = EQ(offset, 1)
+				? Math.floor(startTicks)
+				: startTicks + offset;
+			let nextTickTime = this.frequency.getTimeOfTick(firstTick);
+			// Advance past any ticks that land before the start of this window
+			// to avoid any tick that was already processed.
+			if (nextTickTime < maxStartTime) {
+				nextTickTime += this.frequency.getDurationOfTicks(
+					1,
+					nextTickTime
+				);
+			}
 			while (nextTickTime < endTime) {
 				try {
 					callback(

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

@@ -75,6 +75,20 @@ describe("Transport", () => {
 			expect(invocations).to.equal(5);
 		});
 
+		it("does not double-fire events when looping many times", async () => {
+			let invocations = 0;
+			await Offline((context) => {
+				const transport = new TransportInstance({ context });
+				transport.schedule(() => {
+					invocations++;
+				}, 0);
+				transport.setLoopPoints(0, 1).start(0);
+				transport.loop = true;
+			}, 120.1);
+			// Should fire exactly 121 times: at t=0,1,2,...,120
+			expect(invocations).to.equal(121);
+		});
+
 		it("jumps to the loopStart after the loopEnd point", async () => {
 			let looped = false;
 			await Offline((context) => {

package/Tone/core/context/Context.test.ts

@@ -221,6 +221,16 @@ describe("Context", () => {
 			}, 0.05);
 		});
 
+		it("can efficiently add and remove 10k timeouts", () => {
+			const ids: number[] = [];
+			for (let i = 0; i < 10_000; i++) {
+				ids.push(ctx.setTimeout(() => {}, i * 0.001));
+			}
+			for (const id of ids) {
+				ctx.clearTimeout(id);
+			}
+		}).timeout(100);
+
 		it("is robust against altering the timeline within the callback fn", (done) => {
 			let invokeCount = 0;
 			function checkDone(id: number) {

package/Tone/core/context/Context.ts

@@ -64,6 +64,11 @@ export class Context extends BaseContext {
 	 */
 	private _timeouts: Timeline<ContextTimeoutEvent> = new Timeline();
 
+	/**
+	 * A Map from timeout ID to event for O(1) lookup in clearTimeout.
+	 */
+	private _timeoutMap = new Map<number, ContextTimeoutEvent>();
+
 	/**
 	 * The timeout id counter
 	 */
@@ -554,6 +559,7 @@ export class Context extends BaseContext {
 		super.dispose();
 		this._ticker.dispose();
 		this._timeouts.dispose();
+		this._timeoutMap.clear();
 		Object.keys(this._constants).map((val) =>
 			this._constants[val].disconnect()
 		);
@@ -565,6 +571,26 @@ export class Context extends BaseContext {
 	// TIMEOUTS
 	//---------------------------
 
+	/**
+	 * Add a timeout event to the timeline and map.
+	 */
+	private _addTimeoutEvent(event: ContextTimeoutEvent): void {
+		this._timeouts.add(event);
+		this._timeoutMap.set(event.id, event);
+	}
+
+	/**
+	 * Remove a timeout event from the timeline and map.
+	 */
+	private _removeTimeoutEvent(event: ContextTimeoutEvent): void {
+		this._timeouts.remove(event);
+		// Skips the map deletion in setInterval case where the same id
+		// is reused for the next event.
+		if (this._timeoutMap.get(event.id) === event) {
+			this._timeoutMap.delete(event.id);
+		}
+	}
+
 	/**
 	 * The private loop which keeps track of the context scheduled timeouts
 	 * Is invoked from the clock source
@@ -575,7 +601,7 @@ export class Context extends BaseContext {
 			try {
 				event.callback();
 			} finally {
-				this._timeouts.remove(event);
+				this._removeTimeoutEvent(event);
 			}
 		});
 	}
@@ -592,7 +618,7 @@ export class Context extends BaseContext {
 	setTimeout(fn: (...args: any[]) => void, timeout: Seconds): number {
 		this._timeoutIds++;
 		const now = this.now();
-		this._timeouts.add({
+		this._addTimeoutEvent({
 			callback: fn,
 			id: this._timeoutIds,
 			time: now + timeout,
@@ -605,11 +631,10 @@ export class Context extends BaseContext {
 	 * @param id The ID returned from {@link setTimeout}.
 	 */
 	clearTimeout(id: number): this {
-		this._timeouts.forEach((event) => {
-			if (event.id === id) {
-				this._timeouts.remove(event);
-			}
-		});
+		const event = this._timeoutMap.get(id);
+		if (event) {
+			this._removeTimeoutEvent(event);
+		}
 		return this;
 	}
 
@@ -631,7 +656,7 @@ export class Context extends BaseContext {
 		const id = ++this._timeoutIds;
 		const intervalFn = () => {
 			const now = this.now();
-			this._timeouts.add({
+			this._addTimeoutEvent({
 				callback: () => {
 					// invoke the callback
 					fn();

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

@@ -93,6 +93,10 @@ describe("Timeline", () => {
 			sched.remove({ time: 4 });
 		});
 		expect(sched.length).to.equal(1);
+		sched.add({ time: 1 });
+		sched.add({ time: 3 });
+		sched.remove({ time: 2 });
+		expect(sched.length).to.equal(3);
 		sched.dispose();
 	});
 

package/Tone/core/util/Timeline.ts

@@ -115,7 +115,7 @@ export class Timeline<GenericEvent extends TimelineEvent> extends Tone {
 	 * @returns {Timeline} this
 	 */
 	remove(event: GenericEvent): this {
-		const index = this._timeline.indexOf(event);
+		const index = this._indexOf(event);
 		if (index !== -1) {
 			this._timeline.splice(index, 1);
 		}
@@ -240,7 +240,7 @@ export class Timeline<GenericEvent extends TimelineEvent> extends Tone {
 	 * @return The event right before the given event
 	 */
 	previousEvent(event: GenericEvent): GenericEvent | null {
-		const index = this._timeline.indexOf(event);
+		const index = this._indexOf(event);
 		if (index > 0) {
 			return this._timeline[index - 1];
 		} else {
@@ -248,6 +248,34 @@ export class Timeline<GenericEvent extends TimelineEvent> extends Tone {
 		}
 	}
 
+	/**
+	 * Return the index of the given event in the timeline. -1 if it is not found.
+	 */
+	private _indexOf(event: GenericEvent): number {
+		// Use _search since internally implemented with binary search.
+		const index = this._search(event.time);
+		if (index === -1) {
+			return -1;
+		}
+		// There may be multiple events with the same time, so find the exact event
+		// Search forward and backward for events with the same time
+		for (let i = index; i < this._timeline.length; i++) {
+			if (this._timeline[i] === event) {
+				return i;
+			} else if (this._timeline[i].time !== event.time) {
+				break;
+			}
+		}
+		for (let j = index - 1; j >= 0; j--) {
+			if (this._timeline[j] === event) {
+				return j;
+			} else if (this._timeline[j].time !== event.time) {
+				break;
+			}
+		}
+		return -1;
+	}
+
 	/**
 	 * Does a binary search on the timeline array and returns the
 	 * nearest event index whose time is after or equal to the given time.

package/Tone/version.ts

@@ -1 +1 @@
-export const version: string = "15.5.18";
+export const version: string = "15.5.20";