tone 15.5.47 → 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/TickParam.ts

@@ -217,7 +217,7 @@ export class TickParam<
 	getTimeOfTick(tick: Ticks): Seconds {
 		const before = this._events.get(tick, "ticks");
 		const after = this._events.getAfter(tick, "ticks");
-		if (before && before.ticks === tick) {
+		if (before?.ticks === tick) {
 			return before.time;
 		} else if (
 			before &&

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/clock/TickSource.ts

@@ -398,8 +398,7 @@ export class TickSource<
 		let lastStateEvent = this._state.get(startTime);
 		this._state.forEachBetween(startTime, endTime, (event) => {
 			if (
-				lastStateEvent &&
-				lastStateEvent.state === "started" &&
+				lastStateEvent?.state === "started" &&
 				event.state !== "started"
 			) {
 				this.forEachTickBetween(
@@ -413,7 +412,7 @@ export class TickSource<
 
 		let error: Error | null = null;
 
-		if (lastStateEvent && lastStateEvent.state === "started") {
+		if (lastStateEvent?.state === "started") {
 			const maxStartTime = Math.max(lastStateEvent.time, startTime);
 			// 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.

package/Tone/core/clock/Ticker.ts

@@ -123,8 +123,8 @@ export class Ticker {
 		if (this._timeout) {
 			clearTimeout(this._timeout);
 		}
+		this._worker?.terminate();
 		if (this._worker) {
-			this._worker.terminate();
 			this._worker.onmessage = null;
 		}
 	}

package/Tone/core/context/Param.ts

@@ -618,7 +618,7 @@ export class Param<TypeName extends UnitName = "number">
 		param.setValueAtTime(this.getValueAtTime(now) as number, now);
 		// if the previous event was a curve, then set the rest of it
 		const previousEvent = this._events.get(now);
-		if (previousEvent && previousEvent.type === "setTargetAtTime") {
+		if (previousEvent?.type === "setTargetAtTime") {
 			// approx it until the next event with linear ramps
 			const nextEvent = this._events.getAfter(previousEvent.time);
 			// or for 2 seconds if there is no event

package/Tone/core/context/ToneAudioBuffer.ts

@@ -87,11 +87,7 @@ export class ToneAudioBuffer extends Tone {
 	 * The sample rate of the AudioBuffer
 	 */
 	get sampleRate(): number {
-		if (this._buffer) {
-			return this._buffer.sampleRate;
-		} else {
-			return getContext().sampleRate;
-		}
+		return this._buffer?.sampleRate ?? getContext().sampleRate;
 	}
 
 	/**
@@ -233,11 +229,7 @@ export class ToneAudioBuffer extends Tone {
 	 * @return The audio as a TypedArray
 	 */
 	getChannelData(channel: number): Float32Array {
-		if (this._buffer) {
-			return this._buffer.getChannelData(channel);
-		} else {
-			return new Float32Array(0);
-		}
+		return this._buffer?.getChannelData(channel) ?? new Float32Array(0);
 	}
 
 	/**
@@ -292,33 +284,21 @@ export class ToneAudioBuffer extends Tone {
 	 * The duration of the buffer in seconds.
 	 */
 	get duration(): Seconds {
-		if (this._buffer) {
-			return this._buffer.duration;
-		} else {
-			return 0;
-		}
+		return this._buffer?.duration ?? 0;
 	}
 
 	/**
 	 * The length of the buffer in samples
 	 */
 	get length(): Samples {
-		if (this._buffer) {
-			return this._buffer.length;
-		} else {
-			return 0;
-		}
+		return this._buffer?.length ?? 0;
 	}
 
 	/**
 	 * The number of discrete audio channels. Returns 0 if no buffer is loaded.
 	 */
 	get numberOfChannels(): number {
-		if (this._buffer) {
-			return this._buffer.numberOfChannels;
-		} else {
-			return 0;
-		}
+		return this._buffer?.numberOfChannels ?? 0;
 	}
 
 	/**

package/Tone/core/util/StateTimeline.ts

@@ -38,11 +38,7 @@ export class StateTimeline<
 	 */
 	getValueAtTime(time: Seconds): PlaybackState {
 		const event = this.get(time);
-		if (event !== null) {
-			return event.state;
-		} else {
-			return this._initial;
-		}
+		return event?.state ?? this._initial;
 	}
 
 	/**

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/core/util/TimelineValue.ts

@@ -48,10 +48,6 @@ export class TimelineValue<Type> extends Tone {
 	 */
 	get(time: Seconds): Type {
 		const event = this._timeline.get(time);
-		if (event) {
-			return event.value;
-		} else {
-			return this._initialValue;
-		}
+		return event?.value ?? this._initialValue;
 	}
 }

package/Tone/core/worklet/SingleIOProcessor.worklet.ts

@@ -58,11 +58,11 @@ export const singleIOProcess = /* javascript */ `
 			const input = inputs[0];
 			const output = outputs[0];
 			// get the parameter values
-			const channelCount = Math.max(input && input.length || 0, output.length);
+			const channelCount = Math.max(input?.length || 0, output.length);
 			for (let sample = 0; sample < this.blockSize; sample++) {
 				this.updateParams(parameters, sample);
 				for (let channel = 0; channel < channelCount; channel++) {
-					const inputSample = input && input.length ? input[channel][sample] : 0;
+					const inputSample = input?.length ? input[channel][sample] : 0;
 					output[channel][sample] = this.generate(inputSample, channel, this.params);
 				}
 			}

package/Tone/core/worklet/ToneAudioWorklet.ts

@@ -97,10 +97,8 @@ export abstract class ToneAudioWorklet<
 	dispose(): this {
 		super.dispose();
 		this._dummyGain.disconnect();
-		if (this._worklet) {
-			this._worklet.port.postMessage("dispose");
-			this._worklet.disconnect();
-		}
+		this._worklet?.port.postMessage("dispose");
+		this._worklet?.disconnect();
 		return this;
 	}
 }

package/Tone/fromContext.ts

@@ -10,7 +10,7 @@ import { TimeClass } from "./core/type/Time.js";
 import { TransportTimeClass } from "./core/type/TransportTime.js";
 import { omitFromObject } from "./core/util/Defaults.js";
 import { DrawInstance } from "./core/util/Draw.js";
-import { isDefined, isFunction } from "./core/util/TypeCheck.js";
+import { isFunction } from "./core/util/TypeCheck.js";
 
 type ClassesWithoutSingletons = Omit<
 	typeof Classes,
@@ -48,7 +48,7 @@ export function fromContext(context: Context): ToneObject {
 		omitFromObject(Classes, ["Transport", "Destination", "Draw"])
 	).map((key) => {
 		const cls = Classes[key];
-		if (isDefined(cls) && isFunction(cls.getDefaults)) {
+		if (isFunction(cls?.getDefaults)) {
 			classesWithContext[key] = class ToneFromContextNode extends cls {
 				get defaultContext(): Context {
 					return context;

package/Tone/instrument/Sampler.ts

@@ -264,7 +264,7 @@ export class Sampler extends Instrument<SamplerOptions> {
 
 			// remove it when it's done
 			source.onended = () => {
-				if (this._activeSources && this._activeSources.has(midi)) {
+				if (this._activeSources?.has(midi)) {
 					const sources = this._activeSources.get(
 						midi
 					) as ToneBufferSource[];

package/Tone/source/Noise.test.ts

@@ -31,6 +31,12 @@ describe("Noise", () => {
 			noise.dispose();
 		});
 
+		it("can be disposed while started", () => {
+			const noise = new Noise().toDestination();
+			noise.start();
+			noise.dispose();
+		});
+
 		it("can set the playbackRate in the constructor", () => {
 			const noise = new Noise({
 				playbackRate: 2,

package/Tone/source/Noise.ts

@@ -192,9 +192,7 @@ export class Noise extends Source<NoiseOptions> {
 	 */
 	dispose(): this {
 		super.dispose();
-		if (this._source) {
-			this._source.disconnect();
-		}
+		this._source?.disconnect();
 		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/source/UserMedia.ts

@@ -201,7 +201,7 @@ export class UserMedia extends ToneAudioNode<UserMediaOptions> {
 	 * and "stopped" when the mic is closed.
 	 */
 	get state() {
-		return this._stream && this._stream.active ? "started" : "stopped";
+		return this._stream?.active ? "started" : "stopped";
 	}
 
 	/**
@@ -213,11 +213,7 @@ export class UserMedia extends ToneAudioNode<UserMediaOptions> {
 	 * device is not open.
 	 */
 	get deviceId(): string | undefined {
-		if (this._device) {
-			return this._device.deviceId;
-		} else {
-			return undefined;
-		}
+		return this._device?.deviceId;
 	}
 
 	/**
@@ -226,11 +222,7 @@ export class UserMedia extends ToneAudioNode<UserMediaOptions> {
 	 * Returns null  when the device is not open.
 	 */
 	get groupId(): string | undefined {
-		if (this._device) {
-			return this._device.groupId;
-		} else {
-			return undefined;
-		}
+		return this._device?.groupId;
 	}
 
 	/**
@@ -239,11 +231,7 @@ export class UserMedia extends ToneAudioNode<UserMediaOptions> {
 	 * because of permissions.
 	 */
 	get label(): string | undefined {
-		if (this._device) {
-			return this._device.label;
-		} else {
-			return undefined;
-		}
+		return this._device?.label;
 	}
 
 	/**

package/Tone/source/buffer/Player.ts

@@ -515,7 +515,7 @@ export class Player extends Source<PlayerOptions> {
 
 		// cancel the stop event since it's at a different time now
 		const stopEvent = this._state.getNextState("stopped", now);
-		if (stopEvent && stopEvent.implicitEnd) {
+		if (stopEvent?.implicitEnd) {
 			this._state.cancel(stopEvent.time);
 			this._activeSources.forEach((source) => source.cancelStop());
 

package/Tone/version.ts

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