tone 15.5.58 → 15.5.60

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

@@ -428,6 +428,38 @@ describe("Clock", () => {
 				["start", restartTime],
 			]);
 		});
+
+		it("invokes pending ticks and state events in time order", async () => {
+			const events: Array<[string, number]> = [];
+			let pauseTime = 0;
+			await Offline(() => {
+				const clock = new Clock((time, ticks) => {
+					events.push(["tick " + ticks, time]);
+				}, 200);
+				clock.on("pause", (time) => events.push(["pause", time]));
+				clock.on("start", (time) => events.push(["start", time]));
+				clock.start(0);
+				// ticks 0-4 (every 0.005s) and the pause are all pending in
+				// the same clock update; the ticks before the pause must be
+				// invoked before the pause event, not after it
+				return atTime(
+					0.022,
+					holdClock(clock, (time) => {
+						pauseTime = time;
+						clock.pause(time);
+					})
+				);
+			}, 0.03);
+			expect(events).to.deep.equal([
+				["start", 0],
+				["tick 0", 0],
+				["tick 1", 0.005],
+				["tick 2", 0.01],
+				["tick 3", 0.015],
+				["tick 4", 0.02],
+				["pause", pauseTime],
+			]);
+		});
 	});
 
 	context("Events", () => {

package/Tone/core/clock/Clock.ts

@@ -7,7 +7,12 @@ import { assertContextRunning } from "../util/Debug.js";
 import { optionsFromArguments } from "../util/Defaults.js";
 import { Emitter } from "../util/Emitter.js";
 import { noOp, readOnly } from "../util/Interface.js";
-import { PlaybackState, StateTimeline } from "../util/StateTimeline.js";
+import { GT } from "../util/Math.js";
+import {
+	PlaybackState,
+	StateTimeline,
+	StateTimelineEvent,
+} from "../util/StateTimeline.js";
 import { TickSignal } from "./TickSignal.js";
 import { TickSource } from "./TickSource.js";
 
@@ -290,39 +295,62 @@ export class Clock<TypeName extends "bpm" | "hertz" = "hertz">
 
 	/**
 	 * Invoke the state-transition events (start/stop/pause) and tick
-	 * callbacks scheduled between startTime and endTime, and advance
-	 * _lastUpdate to endTime.
+	 * callbacks scheduled between startTime and endTime in time order,
+	 * and advance _lastUpdate to endTime.
 	 * @param startTime The beginning of the range to process.
 	 * @param endTime The end of the range to process.
 	 */
 	private _processRange(startTime: number, endTime: number): void {
 		this._lastUpdate = endTime;
 		if (startTime !== endTime) {
-			// the state change events
+			// the state change events, interleaved with the tick callbacks
+			// so that e.g. a tick just before a pause is delivered before
+			// the pause event, not after it
+			const stateEvents: StateTimelineEvent[] = [];
 			this._state.forEachBetween(startTime, endTime, (e) => {
-				switch (e.state) {
-					case "started":
-						const offset = this._tickSource.getTicksAtTime(e.time);
-						this.emit("start", e.time, offset);
-						break;
-					case "stopped":
-						if (e.time !== 0) {
-							this.emit("stop", e.time);
-						}
-						break;
-					case "paused":
-						this.emit("pause", e.time);
-						break;
-				}
+				stateEvents.push(e);
 			});
-			// the tick callbacks
+			let nextStateEvent = 0;
+			const emitStateEventsUpTo = (time: Seconds) => {
+				// a callback may have disposed the clock
+				while (
+					!this.disposed &&
+					nextStateEvent < stateEvents.length &&
+					!GT(stateEvents[nextStateEvent].time, time)
+				) {
+					this._emitStateEvent(stateEvents[nextStateEvent]);
+					nextStateEvent++;
+				}
+			};
 			this._tickSource.forEachTickBetween(
 				startTime,
 				endTime,
 				(time, ticks) => {
+					emitStateEventsUpTo(time);
 					this.callback(time, ticks);
 				}
 			);
+			emitStateEventsUpTo(endTime);
+		}
+	}
+
+	/**
+	 * Emit the event corresponding to a state change
+	 */
+	private _emitStateEvent(event: StateTimelineEvent): void {
+		switch (event.state) {
+			case "started":
+				const offset = this._tickSource.getTicksAtTime(event.time);
+				this.emit("start", event.time, offset);
+				break;
+			case "stopped":
+				if (event.time !== 0) {
+					this.emit("stop", event.time);
+				}
+				break;
+			case "paused":
+				this.emit("pause", event.time);
+				break;
 		}
 	}
 

package/Tone/source/Source.test.ts

@@ -3,6 +3,7 @@ import { expect } from "chai";
 import { atTime, holdClock, Offline } from "../../test/helper/Offline.js";
 import { ToneAudioBuffer } from "../core/context/ToneAudioBuffer.js";
 import { getContext } from "../core/Global.js";
+import { noOp } from "../core/util/Interface.js";
 import { Player } from "./buffer/Player.js";
 import { Oscillator } from "./oscillator/Oscillator.js";
 
@@ -351,6 +352,55 @@ describe("Source", () => {
 			expect(output.getValueAtTime(0.4)).to.be.closeTo(0.7, 0.01);
 		});
 
+		it("stops a source whose start was pending in the same clock update as a pause (#1289)", async () => {
+			const output = await Offline(({ transport }) => {
+				const source = new Player(rampBuffer).toDestination();
+				source.sync().start(0.5);
+				transport.start(0);
+				// the clip's start tick at 0.5 and the pause at ~0.52 are
+				// processed in the same clock update
+				return atTime(
+					0.52,
+					holdClock(transport, (time) => {
+						transport.pause(time);
+					})
+				);
+			}, 1);
+			expect(output.getValueAtTime(0.7)).to.equal(0);
+			expect(output.getValueAtTime(0.9)).to.equal(0);
+		});
+
+		it("stops a source whose start was pending in the same clock update as a stop (#1289)", async () => {
+			const output = await Offline(({ transport }) => {
+				const source = new Player(rampBuffer).toDestination();
+				source.sync().start(0.5);
+				transport.start(0);
+				return atTime(
+					0.52,
+					holdClock(transport, (time) => {
+						transport.stop(time);
+					})
+				);
+			}, 1);
+			expect(output.getValueAtTime(0.7)).to.equal(0);
+			expect(output.getValueAtTime(0.9)).to.equal(0);
+		});
+
+		it("stops a source whose start was pending in the same clock update as a stop scheduled ahead of time", async () => {
+			const output = await Offline(({ transport }) => {
+				const source = new Player(rampBuffer).toDestination();
+				source.sync().start(0.5);
+				transport.start(0);
+				// stop scheduled in advance; the start tick at 0.5 and the
+				// stop at 0.52 are both pending when the clock catches up
+				transport.stop(0.52);
+				return atTime(0.55, holdClock(transport, noOp));
+			}, 1);
+			expect(output.getValueAtTime(0.51)).to.be.closeTo(0.01, 0.005);
+			expect(output.getValueAtTime(0.7)).to.equal(0);
+			expect(output.getValueAtTime(0.9)).to.equal(0);
+		});
+
 		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.58";
+export const version: string = "15.5.60";