tone 15.3.4 → 15.3.6

package/Tone/component/envelope/Envelope.test.ts

@@ -3,10 +3,12 @@ import { expect } from "chai";
 import { BasicTests } from "../../../test/helper/Basic.js";
 import { connectTo } from "../../../test/helper/Connect.js";
 import { Offline } from "../../../test/helper/Offline.js";
+import { SignalConnectAndDisconnect } from "../../../test/helper/SignalTests.js";
 import { Envelope, EnvelopeCurve } from "./Envelope.js";
 
 describe("Envelope", () => {
 	BasicTests(Envelope);
+	SignalConnectAndDisconnect(Envelope);
 
 	context("Envelope", () => {
 		it("has an output connections", () => {

package/Tone/component/envelope/Envelope.ts

@@ -9,7 +9,11 @@ import { assert } from "../../core/util/Debug.js";
 import { range, timeRange } from "../../core/util/Decorator.js";
 import { optionsFromArguments } from "../../core/util/Defaults.js";
 import { isArray, isObject, isString } from "../../core/util/TypeCheck.js";
-import { connectSignal, Signal } from "../../signal/Signal.js";
+import {
+	connectSignal,
+	disconnectSignal,
+	Signal,
+} from "../../signal/Signal.js";
 
 type BasicEnvelopeCurve = "linear" | "exponential";
 type InternalEnvelopeCurve = BasicEnvelopeCurve | number[];
@@ -505,6 +509,16 @@ export class Envelope extends ToneAudioNode<EnvelopeOptions> {
 		return this;
 	}
 
+	/** @inheritdoc */
+	disconnect(
+		destination?: InputNode,
+		outputNumber = 0,
+		inputNumber = 0
+	): this {
+		disconnectSignal(this, destination, outputNumber, inputNumber);
+		return this;
+	}
+
 	/**
 	 * Render the envelope curve to an array of the given length.
 	 * Good for visualizing the envelope curve. Rescales the duration of the

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

@@ -302,6 +302,36 @@ describe("Transport", () => {
 				});
 			}, 0.2);
 		});
+
+		it("invokes the first callback time when the scheduled time is a non-integer tick time", async () => {
+			let wasCalled = false;
+			await Offline(({ transport }) => {
+				// choose a value which is not cleanly representable as ticks
+				const problemValue = Time(100, "i").toSeconds() + 0.01;
+				transport.seconds = problemValue;
+				transport.schedule(() => {
+					wasCalled = true;
+				}, problemValue);
+				transport.start();
+			}, 0.2);
+			expect(wasCalled).to.be.true;
+		});
+
+		it("setting the same ticks value twice does not emit twice", async () => {
+			await Offline(({ transport }) => {
+				let callCount = 0;
+				transport.on("ticks", () => {
+					callCount++;
+				});
+				transport.ticks = 100;
+				expect(transport.ticks).to.equal(100);
+				expect(callCount).to.equal(1);
+
+				// set it to the same value again has no change
+				transport.ticks = 100;
+				expect(callCount).to.equal(1);
+			}, 0.1);
+		});
 	});
 
 	context("state", () => {

package/Tone/core/clock/Transport.ts

@@ -625,25 +625,30 @@ export class TransportInstance
 	}
 	set ticks(t: Ticks) {
 		assertUsedScheduleTime();
-		if (this._clock.ticks !== t) {
-			const now = this.now();
-			// stop everything synced to the transport
-			if (this.state === "started") {
-				const ticks = this._clock.getTicksAtTime(now);
-				// schedule to start on the next tick, #573
-				const remainingTick = this._clock.frequency.getDurationOfTicks(
-					Math.ceil(ticks) - ticks,
-					now
-				);
-				const time = now + remainingTick;
-				this.emit("stop", time);
-				this._clock.setTicksAtTime(t, time);
-				// restart it with the new time
-				this.emit("start", time, this._clock.getSecondsAtTime(time));
-			} else {
-				this.emit("ticks", now);
-				this._clock.setTicksAtTime(t, now);
-			}
+
+		// "floor" ensures that any events scheduled on this tick will be called.
+		t = Math.floor(t);
+
+		if (this._clock.ticks === t) {
+			return;
+		}
+		const now = this.now();
+		// stop everything synced to the transport
+		if (this.state === "started") {
+			const ticks = this._clock.getTicksAtTime(now);
+			// schedule to start on the next tick, #573
+			const remainingTick = this._clock.frequency.getDurationOfTicks(
+				Math.ceil(ticks) - ticks,
+				now
+			);
+			const time = now + remainingTick;
+			this.emit("stop", time);
+			this._clock.setTicksAtTime(t, time);
+			// restart it with the new time
+			this.emit("start", time, this._clock.getSecondsAtTime(time));
+		} else {
+			this.emit("ticks", now);
+			this._clock.setTicksAtTime(t, now);
 		}
 	}
 

package/Tone/core/context/ToneAudioNode.ts

@@ -374,7 +374,7 @@ export function disconnect(
 ): void {
 	// resolve the destination node
 	if (isDefined(dstNode)) {
-		while (dstNode instanceof ToneAudioNode) {
+		while (dstNode instanceof ToneAudioNode || dstNode instanceof Param) {
 			dstNode = dstNode.input;
 		}
 	}

package/Tone/signal/Signal.test.ts

@@ -3,11 +3,13 @@ import { expect } from "chai";
 import { BasicTests } from "../../test/helper/Basic.js";
 import { ConstantOutput } from "../../test/helper/ConstantOutput.js";
 import { Offline } from "../../test/helper/Offline.js";
+import { SignalConnectAndDisconnect } from "../../test/helper/SignalTests.js";
 import { Gain } from "../core/context/Gain.js";
 import { connectSignal, disconnectSignal, Signal } from "./Signal.js";
 
 describe("Signal", () => {
 	BasicTests(Signal);
+	SignalConnectAndDisconnect(Signal);
 
 	context("Signal Rate Value", () => {
 		it("has 1 input and 1 output", () => {
@@ -605,7 +607,7 @@ describe("Signal", () => {
 			}, 2);
 		});
 
-		it("can disconnect from all the connected notes", async () => {
+		it("can disconnect from all the connected nodes", async () => {
 			await ConstantOutput(async (context) => {
 				// initially destination is 2
 				const output0 = new Signal(1).toDestination();
@@ -621,15 +623,17 @@ describe("Signal", () => {
 
 		it("can disconnect from a specific node", async () => {
 			await ConstantOutput(() => {
-				// initially destination is 1
-				const output = new Signal(1).toDestination();
+				// initially destination is 3
+				const output0 = new Signal(1).toDestination();
+				const output1 = new Signal(2).toDestination();
 
-				// overwrites it with 0
-				const sig = new Signal(0).connect(output);
+				const sig = new Signal(3);
+				sig.connect(output0);
+				sig.connect(output1);
 
-				// disconnects the signal and goes back to 1
-				sig.disconnect(output);
-			}, 1);
+				// output0 goes back to 1 after disconnecting
+				sig.disconnect(output0);
+			}, 4); // 1 + 3
 		});
 
 		it("disconnects every input when no input is passed in", async () => {

package/Tone/signal/Signal.ts

@@ -85,7 +85,7 @@ export class Signal<TypeName extends UnitName = "number">
 		this._constantSource.start(0);
 		this.input = this._param = this._constantSource.offset;
 	}
-
+	/** @inheritdoc */
 	static getDefaults(): SignalOptions<any> {
 		return Object.assign(ToneAudioNode.getDefaults(), {
 			convert: true,
@@ -93,13 +93,13 @@ export class Signal<TypeName extends UnitName = "number">
 			value: 0,
 		});
 	}
-
+	/** @inheritdoc */
 	connect(destination: InputNode, outputNum = 0, inputNum = 0): this {
 		// start it only when connected to something
 		connectSignal(this, destination, outputNum, inputNum);
 		return this;
 	}
-
+	/** @inheritdoc */
 	disconnect(
 		destination?: InputNode,
 		outputNum?: number,
@@ -109,7 +109,7 @@ export class Signal<TypeName extends UnitName = "number">
 		disconnectSignal(this, destination, outputNum, inputNum);
 		return this;
 	}
-
+	/** @inheritdoc */
 	dispose(): this {
 		super.dispose();
 		this._param.dispose();
@@ -123,25 +123,31 @@ export class Signal<TypeName extends UnitName = "number">
 	// all docs are generated from AbstractParam.ts
 	//-------------------------------------
 
+	/** @inheritdoc */
 	setValueAtTime(value: UnitMap[TypeName], time: Time): this {
 		this._param.setValueAtTime(value, time);
 		return this;
 	}
+	/** @inheritdoc */
 	getValueAtTime(time: Time): UnitMap[TypeName] {
 		return this._param.getValueAtTime(time);
 	}
+	/** @inheritdoc */
 	setRampPoint(time: Time): this {
 		this._param.setRampPoint(time);
 		return this;
 	}
+	/** @inheritdoc */
 	linearRampToValueAtTime(value: UnitMap[TypeName], time: Time): this {
 		this._param.linearRampToValueAtTime(value, time);
 		return this;
 	}
+	/** @inheritdoc */
 	exponentialRampToValueAtTime(value: UnitMap[TypeName], time: Time): this {
 		this._param.exponentialRampToValueAtTime(value, time);
 		return this;
 	}
+	/** @inheritdoc */
 	exponentialRampTo(
 		value: UnitMap[TypeName],
 		rampTime: Time,
@@ -150,6 +156,7 @@ export class Signal<TypeName extends UnitName = "number">
 		this._param.exponentialRampTo(value, rampTime, startTime);
 		return this;
 	}
+	/** @inheritdoc */
 	linearRampTo(
 		value: UnitMap[TypeName],
 		rampTime: Time,
@@ -158,6 +165,7 @@ export class Signal<TypeName extends UnitName = "number">
 		this._param.linearRampTo(value, rampTime, startTime);
 		return this;
 	}
+	/** @inheritdoc */
 	targetRampTo(
 		value: UnitMap[TypeName],
 		rampTime: Time,
@@ -166,6 +174,7 @@ export class Signal<TypeName extends UnitName = "number">
 		this._param.targetRampTo(value, rampTime, startTime);
 		return this;
 	}
+	/** @inheritdoc */
 	exponentialApproachValueAtTime(
 		value: UnitMap[TypeName],
 		time: Time,
@@ -174,6 +183,7 @@ export class Signal<TypeName extends UnitName = "number">
 		this._param.exponentialApproachValueAtTime(value, time, rampTime);
 		return this;
 	}
+	/** @inheritdoc */
 	setTargetAtTime(
 		value: UnitMap[TypeName],
 		startTime: Time,
@@ -182,6 +192,7 @@ export class Signal<TypeName extends UnitName = "number">
 		this._param.setTargetAtTime(value, startTime, timeConstant);
 		return this;
 	}
+	/** @inheritdoc */
 	setValueCurveAtTime(
 		values: UnitMap[TypeName][],
 		startTime: Time,
@@ -191,44 +202,47 @@ export class Signal<TypeName extends UnitName = "number">
 		this._param.setValueCurveAtTime(values, startTime, duration, scaling);
 		return this;
 	}
+	/** @inheritdoc */
 	cancelScheduledValues(time: Time): this {
 		this._param.cancelScheduledValues(time);
 		return this;
 	}
+	/** @inheritdoc */
 	cancelAndHoldAtTime(time: Time): this {
 		this._param.cancelAndHoldAtTime(time);
 		return this;
 	}
+	/** @inheritdoc */
 	rampTo(value: UnitMap[TypeName], rampTime: Time, startTime?: Time): this {
 		this._param.rampTo(value, rampTime, startTime);
 		return this;
 	}
-
+	/** @inheritdoc */
 	get value(): UnitMap[TypeName] {
 		return this._param.value;
 	}
 	set value(value: UnitMap[TypeName]) {
 		this._param.value = value;
 	}
-
+	/** @inheritdoc */
 	get convert(): boolean {
 		return this._param.convert;
 	}
 	set convert(convert: boolean) {
 		this._param.convert = convert;
 	}
-
+	/** @inheritdoc */
 	get units(): UnitName {
 		return this._param.units;
 	}
-
+	/** @inheritdoc */
 	get overridden(): boolean {
 		return this._param.overridden;
 	}
 	set overridden(overridden: boolean) {
 		this._param.overridden = overridden;
 	}
-
+	/** @inheritdoc */
 	get maxValue(): number {
 		return this._param.maxValue;
 	}
@@ -288,7 +302,7 @@ export function connectSignal(
 		// reset the value
 		destination.setValueAtTime(0, 0);
 		// mark the value as overridden
-		if (destination instanceof Signal) {
+		if (destination instanceof Signal || destination instanceof Param) {
 			destination.overridden = true;
 		}
 		// store the connection
@@ -344,7 +358,10 @@ export function disconnectSignal(
 
 			// restore the value
 			connections.forEach((connection) => {
-				if (connection.destination instanceof Signal) {
+				if (
+					connection.destination instanceof Signal ||
+					connection.destination instanceof Param
+				) {
 					connection.destination.overridden = false;
 				}
 				connection.destination.setValueAtTime(

package/Tone/signal/SignalOperator.test.ts

@@ -0,0 +1,23 @@
+import { BasicTests } from "../../test/helper/Basic.js";
+import { SignalConnectAndDisconnect } from "../../test/helper/SignalTests.js";
+import { Signal } from "./Signal.js";
+import { SignalOperator, SignalOperatorOptions } from "./SignalOperator.js";
+
+describe("SignalOperator", () => {
+	class TestSignalOperator extends SignalOperator<SignalOperatorOptions> {
+		name = "TestSignalOperator";
+
+		input: Signal;
+		output: Signal;
+
+		constructor(options: SignalOperatorOptions) {
+			super(options);
+			this.input = this.output = new Signal({
+				context: this.context,
+			});
+		}
+	}
+
+	BasicTests(TestSignalOperator);
+	SignalConnectAndDisconnect(TestSignalOperator);
+});

package/Tone/signal/SignalOperator.ts

@@ -4,7 +4,7 @@ import {
 	ToneAudioNodeOptions,
 } from "../core/context/ToneAudioNode.js";
 import { optionsFromArguments } from "../core/util/Defaults.js";
-import { connectSignal } from "./Signal.js";
+import { connectSignal, disconnectSignal } from "./Signal.js";
 
 export type SignalOperatorOptions = ToneAudioNodeOptions;
 
@@ -23,8 +23,15 @@ export abstract class SignalOperator<
 		);
 	}
 
+	/** @inheritdoc */
 	connect(destination: InputNode, outputNum = 0, inputNum = 0): this {
 		connectSignal(this, destination, outputNum, inputNum);
 		return this;
 	}
+
+	/** @inheritdoc */
+	disconnect(destination: InputNode, outputNum = 0, inputNum = 0): this {
+		disconnectSignal(this, destination, outputNum, inputNum);
+		return this;
+	}
 }

package/Tone/source/oscillator/LFO.test.ts

@@ -3,11 +3,13 @@ import { expect } from "chai";
 import { BasicTests } from "../../../test/helper/Basic.js";
 import { Offline } from "../../../test/helper/Offline.js";
 import { OutputAudio } from "../../../test/helper/OutputAudio.js";
+import { SignalConnectAndDisconnect } from "../../../test/helper/SignalTests.js";
 import { Signal } from "../../signal/Signal.js";
 import { LFO, LFOOptions } from "./LFO.js";
 
 describe("LFO", () => {
 	BasicTests(LFO);
+	SignalConnectAndDisconnect(LFO);
 
 	context("API", () => {
 		it("can get the current state", () => {

package/Tone/source/oscillator/LFO.ts

@@ -17,7 +17,11 @@ import { readOnly } from "../../core/util/Interface.js";
 import { BasicPlaybackState } from "../../core/util/StateTimeline.js";
 import { AudioToGain } from "../../signal/AudioToGain.js";
 import { Scale } from "../../signal/Scale.js";
-import { connectSignal, Signal } from "../../signal/Signal.js";
+import {
+	connectSignal,
+	disconnectSignal,
+	Signal,
+} from "../../signal/Signal.js";
 import { Zero } from "../../signal/Zero.js";
 import { Oscillator, ToneOscillatorType } from "./Oscillator.js";
 import {
@@ -325,6 +329,14 @@ export class LFO extends ToneAudioNode<LFOOptions> {
 		return this;
 	}
 
+	/**
+	 * Disconnect the LFO.
+	 */
+	disconnect(destination?: InputNode, outputNum = 0, inputNum = 0): this {
+		disconnectSignal(this, destination, outputNum, inputNum);
+		return this;
+	}
+
 	/**
 	 * Private methods borrowed from Param
 	 */

package/Tone/version.ts

@@ -1 +1 @@
-export const version: string = "15.3.4";
+export const version: string = "15.3.6";