tone 15.5.43 → 15.5.45

package/Tone/core/type/TransportTime.ts

@@ -1,5 +1,6 @@
 import { getContext } from "../Global.js";
 import { Seconds, Ticks } from "../type/Units.js";
+import { isDefined } from "../util/TypeCheck.js";
 import { TimeClass } from "./Time.js";
 import { TimeBaseUnit, TimeExpression, TimeValue } from "./TimeBase.js";
 
@@ -22,6 +23,21 @@ export class TransportTimeClass<
 		return this.context.transport.seconds as Type;
 	}
 
+	/**
+	 * Return the time in ticks.
+	 */
+	toTicks(): Ticks {
+		if (isDefined(this._val)) {
+			return super.toTicks();
+		}
+		// read the transport's actual current tick instead of re-deriving it
+		// from elapsed seconds at the current bpm, which ignores tempo changes.
+		// round up to the next tick since the current one may already be
+		// in the middle of being processed by the clock.
+		const transport = this.context.transport;
+		return Math.ceil(transport.getTicksAtTime(transport.now()));
+	}
+
 	protected _getExpressions(): TimeExpression<Type> {
 		const expressions = super._getExpressions();
 		// Override the quantize ("@") handler so that it returns Transport time

package/Tone/event/Part.test.ts

@@ -928,5 +928,59 @@ describe("Part", () => {
 			}).to.throw(Error);
 			part.dispose();
 		});
+
+		it("`toTicks()` with no argument matches the transport's actual current tick after a bpm change (#693)", async () => {
+			let actualTicks = 0;
+			let noArgTicks = 0;
+			await Offline(({ transport }) => {
+				transport.bpm.value = 120;
+				transport.start(0);
+				return atTime(0.5, () => {
+					transport.bpm.value = 40;
+					actualTicks = transport.getTicksAtTime(transport.now());
+					noArgTicks = transport.toTicks();
+				});
+			}, 0.6);
+			expect(noArgTicks).to.be.closeTo(actualTicks, 1);
+		});
+
+		it("does not delay a part's note when it is (re)started with no time arg while the transport is running", async () => {
+			let callTime: number | undefined;
+			await Offline(({ transport }) => {
+				const part = new Part(
+					(time) => {
+						callTime = time;
+					},
+					[0]
+				);
+				transport.bpm.value = 120;
+				transport.start(0);
+				return atTime(0.5, () => {
+					part.start();
+				});
+			}, 1);
+			expect(callTime).to.be.closeTo(0.5, 0.02);
+		});
+
+		it("does not leave an orphaned repeat after stopping a phase-shifted note before its first occurrence", async () => {
+			// a note's own repeat is phase-shifted from the part's start tick;
+			// stopping before a phase-shifted note's first occurrence used to miss
+			// that boundary, leaving an orphaned repeat that could later collide
+			// with a subsequent restart (#864)
+			const calls: number[] = [];
+			await Offline(({ transport }) => {
+				const part = new Part((time) => calls.push(time), [0, 0.5]);
+				part.loop = true;
+				part.loopEnd = 1;
+				transport.bpm.value = 120;
+				transport.start(0);
+				part.start(0);
+				// stop before the note at 0.5s into the loop ever gets to fire
+				part.stop(0.1);
+				// restart partway through the next cycle
+				part.start(200 / 384);
+			}, 2);
+			expect(calls.length).to.equal(4);
+		});
 	});
 });

package/Tone/event/ToneEvent.test.ts

@@ -1,7 +1,7 @@
 import { expect } from "chai";
 
 import { BasicTests } from "../../test/helper/Basic.js";
-import { Offline, whenBetween } from "../../test/helper/Offline.js";
+import { atTime, Offline, whenBetween } from "../../test/helper/Offline.js";
 import { Time } from "../core/type/Time.js";
 import { noOp } from "../core/util/Interface.js";
 import { ToneEvent } from "./ToneEvent.js";
@@ -362,6 +362,30 @@ describe("ToneEvent", () => {
 			}, 2);
 		});
 
+		it("keeps a still-playing segment running until its own scheduled stop, even when a later restart is already queued (#864)", async () => {
+			const callTimes: number[] = [];
+			await Offline(({ transport }) => {
+				const note = new ToneEvent({
+					loop: true,
+					loopEnd: 0.1,
+					callback(time): void {
+						callTimes.push(time);
+					},
+				});
+				note.start(0);
+				transport.start(0);
+				return atTime(0.3, () => {
+					// queue a stop/restart ahead of the still-playing segment
+					note.stop(transport.seconds + 0.5);
+					note.start(transport.seconds + 0.8);
+				});
+			}, 1.5);
+			// the live segment should keep firing up to its own stop (~0.8),
+			// not be cut short by the later start() call scheduled at the same time
+			const notesBetween = callTimes.filter((t) => t > 0.35 && t < 0.75);
+			expect(notesBetween.length).to.be.greaterThan(2);
+		});
+
 		it("loops the correct amount of times when the event is started in the transport's past", async () => {
 			let callCount = 0;
 			await Offline(({ transport }) => {

package/Tone/event/ToneEvent.ts

@@ -16,6 +16,7 @@ import {
 } from "../core/type/Units.js";
 import { defaultArg, optionsFromArguments } from "../core/util/Defaults.js";
 import { noOp } from "../core/util/Interface.js";
+import { clamp } from "../core/util/Math.js";
 import {
 	BasicPlaybackState,
 	StateTimeline,
@@ -185,11 +186,15 @@ export class ToneEvent<ValueType = any> extends ToneWithContext<
 					if (isNumber(this._loop)) {
 						duration = this._loop * this._getLoopDuration();
 					}
-					const nextEvent = this._state.getAfter(startTick);
+					// look up the next boundary in the same (unshifted) frame as
+					// event.time; startOffset can push startTick past it entirely,
+					// in which case this segment shouldn't schedule anything
+					const nextEvent = this._state.getAfter(event.time);
 					if (nextEvent !== null) {
-						duration = Math.min(
-							duration,
-							nextEvent.time - startTick
+						duration = clamp(
+							nextEvent.time - startTick,
+							0,
+							duration
 						);
 					}
 					if (duration !== Infinity) {

package/Tone/source/Source.test.ts

@@ -395,5 +395,31 @@ describe("Source", () => {
 			expect(output.getValueAtTime(0.25)).to.be.closeTo(0.05, 0.01);
 			expect(output.getValueAtTime(0.3)).to.be.closeTo(0.1, 0.01);
 		});
+
+		it("does not replay a clip synced at time 0 after stopping and restarting at a later offset (#1417)", async () => {
+			let onStopCount = 0;
+			await Offline(({ transport }) => {
+				const source = new Player(rampBuffer).toDestination();
+				source.onstop = () => {
+					onStopCount++;
+				};
+				// rampBuffer duration is 1s. Sync at time 0 with duration 0.2s.
+				// This clip only spans [0, 0.2]. At transport time 0.4, it is over.
+				source.sync().start(0, 0, 0.2);
+				transport.start(0, 0);
+
+				return [
+					atTime(0.25, () => {
+						transport.stop();
+					}),
+					atTime(0.3, () => {
+						// restart past the clip duration at offset 0.4
+						transport.start(0.3, 0.4);
+					}),
+				];
+			}, 0.5);
+
+			expect(onStopCount).to.equal(1);
+		});
 	});
 });

package/Tone/source/Source.ts

@@ -348,6 +348,9 @@ export abstract class Source<
 							duration =
 								this.toSeconds(stateEvent.duration) -
 								startOffset;
+							if (duration <= 0) {
+								return;
+							}
 						}
 						this._start(
 							time,

package/Tone/version.ts

@@ -1 +1 @@
-export const version: string = "15.5.43";
+export const version: string = "15.5.45";