tone 15.3.2 → 15.3.3

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

@@ -330,14 +330,17 @@ describe("Transport", () => {
 				expect(transport.getTicksAtTime(0)).to.be.equal(
 					Math.floor(transport.PPQ * 0)
 				);
-				expect(transport.getTicksAtTime(0.05)).to.be.equal(
-					Math.floor(transport.PPQ * 0.1)
+				expect(transport.getTicksAtTime(0.05)).to.be.closeTo(
+					Math.floor(transport.PPQ * 0.1),
+					0.5
 				);
-				expect(transport.getTicksAtTime(0.1)).to.be.equal(
-					Math.floor(transport.PPQ * 0.2)
+				expect(transport.getTicksAtTime(0.1)).to.be.closeTo(
+					Math.floor(transport.PPQ * 0.2),
+					0.5
 				);
-				expect(transport.getTicksAtTime(0.15)).to.be.equal(
-					Math.floor(transport.PPQ * 0.2)
+				expect(transport.getTicksAtTime(0.15)).to.be.closeTo(
+					Math.floor(transport.PPQ * 0.2),
+					0.5
 				);
 				expect(transport.getTicksAtTime(0.2)).to.be.equal(0);
 			}, 0.3);

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

@@ -59,7 +59,7 @@ describe("Destination", () => {
 		);
 	});
 
-	it("can set the audio channel configuration", () => {
+	it.skip("can set the audio channel configuration", () => {
 		return Offline(
 			(context) => {
 				expect(context.destination.channelCount).to.equal(4);

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

@@ -5,9 +5,8 @@ import { Plot } from "../../../test/helper/compare/index.js";
 import { atTime, Offline } from "../../../test/helper/Offline.js";
 import { Signal } from "../../signal/Signal.js";
 import { getContext } from "../Global.js";
-import {
-	UnitName,
-} from "../type/Units.js";
+import { UnitName } from "../type/Units.js";
+import { Gain } from "./Gain.js";
 import { Param } from "./Param.js";
 import { connect } from "./ToneAudioNode.js";
 
@@ -120,7 +119,6 @@ describe("Param", () => {
 				1,
 				sampleRate
 			);
-			// document.body.appendChild(await Plot.signal(testBuffer));
 			matchesOutputCurve(param, testBuffer);
 		});
 
@@ -155,7 +153,6 @@ describe("Param", () => {
 				1,
 				sampleRate
 			);
-			// document.body.appendChild(await Plot.signal(testBuffer));
 			matchesOutputCurve(param, testBuffer);
 		});
 
@@ -199,30 +196,7 @@ describe("Param", () => {
 				sampleRate
 			);
 			matchesOutputCurve(param, testBuffer);
-			// document.body.appendChild(await Plot.signal(testBuffer));
 		});
-
-		// 	it ("matches known values", async () => {
-		// 		await Compare.toFile(context => {
-		// 			const source = context.createConstantSource();
-		// 			source.connect(context.rawContext.destination);
-		// 			source.start(0);
-		// 			const param = new Param({
-		// 				context,
-		// 				param: source.offset,
-		// 				value: 0.1,
-		// 			});
-		// 			param.setValueAtTime(0, 0);
-		// 			param.setValueAtTime(1, 0.2);
-		// 			param.cancelAndHoldAtTime(0.1);
-		// 			param.linearRampToValueAtTime(1, 0.3);
-		// 			param.cancelAndHoldAtTime(0.2);
-		// 			param.exponentialRampToValueAtTime(0, 0.4);
-		// 			param.cancelAndHoldAtTime(0.25);
-		// 			param.setTargetAtTime(1, 0.3, 0.1);
-		// 			param.cancelAndHoldAtTime(0.4);
-		// 		}, "/base/test/audio/param/curve_0.wav", 0.01, 0.5, 1, 11025);
-		// 	});
 	});
 
 	context("Units", () => {
@@ -453,7 +427,6 @@ describe("Param", () => {
 		testUnitConversion("frequency", 0.1, 0.1, 0.1);
 		testUnitConversion("normalRange", 0, 0, 0);
 		testUnitConversion("normalRange", 0.5, 0.5, 0.5);
-		testUnitConversion("normalRange", 1.5, 1, 1);
 		testUnitConversion("audioRange", -1, -1, -1);
 		testUnitConversion("audioRange", 0.5, 0.5, 0.5);
 		testUnitConversion("audioRange", 1, 1, 1);
@@ -533,9 +506,9 @@ describe("Param", () => {
 	context("setValueAtTime", () => {
 		function testSetValueAtTime(
 			units: UnitName,
-			value0,
-			value1,
-			value2
+			value0: number,
+			value1: number,
+			value2: number
 		): void {
 			it(`can schedule value with units ${units}`, async () => {
 				const testBuffer = await Offline(
@@ -601,6 +574,20 @@ describe("Param", () => {
 				testSetValueAtTime(unit, 0, 1, 0.5);
 			}
 		});
+
+		it("asserts a value range", async () => {
+			let errored = false;
+			try {
+				const source = new Gain();
+				const param = new Param({
+					param: source.gain,
+					units: "normalRange",
+				});
+				param.setValueAtTime(2, 0);
+			} catch (e) {
+				errored = true;
+			}
+		});
 	});
 
 	["linearRampToValueAtTime", "exponentialRampToValueAtTime"].forEach(
@@ -608,9 +595,9 @@ describe("Param", () => {
 			context(method, () => {
 				function testRampToValueAtTime(
 					units: UnitName,
-					value0,
-					value1,
-					value2
+					value0: number,
+					value1: number,
+					value2: number
 				): void {
 					it(`can schedule value with units ${units}`, async () => {
 						const testBuffer = await Offline(
@@ -689,9 +676,9 @@ describe("Param", () => {
 			context(method, () => {
 				function testRampToValueAtTime(
 					units: UnitName,
-					value0,
-					value1,
-					value2
+					value0: number,
+					value1: number,
+					value2: number
 				): void {
 					it(`can schedule value with units ${units}`, async () => {
 						const testBuffer = await Offline(

package/Tone/core/type/Time.test.ts

@@ -161,11 +161,14 @@ describe("TimeClass", () => {
 
 		it("converts time into ticks", () => {
 			return Offline(({ transport }) => {
-				expect(Time("2n").toTicks()).to.equal(2 * transport.PPQ);
+				expect(Time("2n").toTicks()).to.closeTo(2 * transport.PPQ, 0.1);
 				// floating point checks
 				const bpmOrig = transport.bpm.value;
 				transport.bpm.value = 100;
-				expect(Time("0:1:3").toTicks()).to.equal(1.75 * transport.PPQ);
+				expect(Time("0:1:3").toTicks()).to.closeTo(
+					1.75 * transport.PPQ,
+					0.1
+				);
 				transport.bpm.value = bpmOrig;
 			});
 		});

package/Tone/event/Sequence.test.ts

@@ -61,13 +61,20 @@ describe("Sequence", () => {
 		});
 
 		it("loops by default with the loopEnd as the duration of the loop", async () => {
-			await Offline(() => {
-				const seq = new Sequence(noOp, [0, 1, 2, 3], "8n");
+			const values: number[] = [];
+			await Offline(({ transport }) => {
+				const seq = new Sequence(
+					(_, value) => {
+						values.push(value);
+					},
+					[0, 1, 2, 3],
+					"8n"
+				).start(0);
 				expect(seq.loop).to.be.true;
 				expect(seq.length).to.equal(4);
-				expect(seq.loopEnd).to.equal(4);
-				seq.dispose();
-			});
+				transport.start(0);
+			}, 2);
+			expect(values).to.deep.equal([0, 1, 2, 3, 0, 1, 2, 3]);
 		});
 	});
 

package/Tone/instrument/MetalSynth.test.ts

@@ -9,7 +9,7 @@ import { MetalSynth } from "./MetalSynth.js";
 describe("MetalSynth", () => {
 	BasicTests(MetalSynth);
 
-	InstrumentTest(MetalSynth, "C2");
+	InstrumentTest(MetalSynth, "C2", undefined, undefined, true);
 	MonophonicTest(MetalSynth, "C4");
 
 	it("matches a file", () => {

package/Tone/signal/Signal.test.ts

@@ -4,7 +4,7 @@ import { BasicTests } from "../../test/helper/Basic.js";
 import { ConstantOutput } from "../../test/helper/ConstantOutput.js";
 import { Offline } from "../../test/helper/Offline.js";
 import { Gain } from "../core/context/Gain.js";
-import { Signal } from "./Signal.js";
+import { connectSignal, disconnectSignal, Signal } from "./Signal.js";
 
 describe("Signal", () => {
 	BasicTests(Signal);
@@ -142,32 +142,8 @@ describe("Signal", () => {
 			expect(buffer.getValueAtTime(1)).to.be.closeTo(0, 0.001);
 		});
 
-		it("can disconnect from all the connected notes", async () => {
-			await ConstantOutput(async (context) => {
-				const output0 = new Signal(1).toDestination();
-				const output1 = new Signal(1).toDestination();
-				const sig = new Signal(0).connect(output0);
-				sig.connect(output1);
-				sig.disconnect();
-				sig.setValueAtTime(0, 0);
-				sig.linearRampToValueAtTime(0.5, 0.5);
-				sig.linearRampToValueAtTime(0, 1);
-			}, 0);
-		});
-
-		it("can disconnect from a specific node", async () => {
-			await ConstantOutput(async (context) => {
-				const output = new Signal(1).toDestination();
-				const sig = new Signal(0).connect(output);
-				sig.disconnect(output);
-				sig.setValueAtTime(0, 0);
-				sig.linearRampToValueAtTime(0.5, 0.5);
-				sig.linearRampToValueAtTime(0, 1);
-			}, 0);
-		});
-
 		it("can schedule multiple automations from a connected signal through a multiple nodes", async () => {
-			const buffer = await Offline(async () => {
+			const buffer = await Offline(() => {
 				const output = new Signal(0).toDestination();
 				const proxy = new Signal(0).connect(output);
 				const gain = new Gain(1).connect(proxy);
@@ -427,6 +403,8 @@ describe("Signal", () => {
 			}).to.throw(RangeError);
 			const signal = new Signal(1, "normalRange");
 			expect(signal.value).to.be.closeTo(1, 0.01);
+			expect(signal.minValue).to.be.equal(0);
+			expect(signal.maxValue).to.be.equal(1);
 			signal.dispose();
 		});
 
@@ -436,6 +414,8 @@ describe("Signal", () => {
 			}).to.throw(RangeError);
 			const signal = new Signal(-1, "audioRange");
 			expect(signal.value).to.be.closeTo(-1, 0.01);
+			expect(signal.minValue).to.be.equal(-1);
+			expect(signal.maxValue).to.be.equal(1);
 			signal.dispose();
 		});
 
@@ -445,6 +425,7 @@ describe("Signal", () => {
 			}).to.throw(RangeError);
 			const signal = new Signal(100, "positive");
 			expect(signal.value).to.be.closeTo(100, 0.01);
+			expect(signal.minValue).to.be.equal(0);
 			signal.dispose();
 		});
 	});
@@ -510,4 +491,229 @@ describe("Signal", () => {
 			}, 5);
 		});
 	});
+
+	context("connectSignal/disconnectSignal", () => {
+		it("can connect a Signal to an AudioNode", () => {
+			return ConstantOutput((context) => {
+				const sig = new Signal({
+					value: 3,
+					context,
+				});
+				const gain = new Gain({
+					gain: 0.5,
+					context,
+				}).toDestination();
+				connectSignal(sig, gain);
+			}, 1.5);
+		});
+
+		it("can connect a Signal to a Param", () => {
+			return ConstantOutput((context) => {
+				const sig = new Signal({
+					value: 3,
+					context,
+				});
+				const scalar = new Signal({
+					value: 2,
+					context,
+				});
+				const gain = new Gain({
+					gain: 0.5,
+					context,
+				}).toDestination();
+				connectSignal(sig, gain);
+				connectSignal(scalar, gain.gain);
+				// gain of 0.5 is overridden
+				expect(gain.gain.value).to.equal(0);
+			}, 6);
+		});
+
+		it("can connect a Signal to a Signal", () => {
+			return ConstantOutput((context) => {
+				const sig = new Signal({
+					value: 3,
+					context,
+				});
+				const output = new Signal({
+					value: 0.5,
+					context,
+				}).toDestination();
+
+				connectSignal(sig, output);
+				expect(output.overridden).to.be.true;
+			}, 3);
+		});
+
+		it("can disconnect a Signal from an AudioNode", () => {
+			return ConstantOutput((context) => {
+				const sig = new Signal({
+					value: 3,
+					context,
+				});
+				const gain = new Gain({
+					gain: 0.5,
+					context,
+				}).toDestination();
+				connectSignal(sig, gain);
+				disconnectSignal(sig, gain);
+			}, 0);
+		});
+
+		it("can disconnect a Signal from a Param", () => {
+			return ConstantOutput((context) => {
+				const sig = new Signal({
+					value: 3,
+					context,
+				});
+				const scalar = new Signal({
+					value: 2,
+					context,
+				});
+				const gain = new Gain({
+					gain: 0.5,
+					context,
+				}).toDestination();
+				connectSignal(sig, gain);
+				connectSignal(scalar, gain.gain);
+				// gain of 0.5 is overridden
+				expect(gain.gain.value).to.equal(0);
+
+				disconnectSignal(scalar, gain.gain);
+				// the original value is restored
+				expect(gain.gain.value).to.equal(0.5);
+			}, 1.5);
+		});
+
+		it("can disconnect a Signal from a Signal", () => {
+			return ConstantOutput((context) => {
+				const sig = new Signal({
+					value: 3,
+					context,
+				});
+				const output = new Signal({
+					value: 2,
+					context,
+				}).toDestination();
+
+				connectSignal(sig, output);
+				expect(output.overridden).to.be.true;
+				expect(output.value).to.equal(0);
+
+				disconnectSignal(sig, output);
+				expect(output.value).to.equal(2);
+				expect(output.overridden).to.be.false;
+			}, 2);
+		});
+
+		it("can disconnect from all the connected notes", async () => {
+			await ConstantOutput(async (context) => {
+				// initially destination is 2
+				const output0 = new Signal(1).toDestination();
+				const output1 = new Signal(1).toDestination();
+
+				// both should now equal 0
+				const sig = new Signal(0).connect(output0).connect(output1);
+
+				// disconnect from both
+				sig.disconnect();
+			}, 2);
+		});
+
+		it("can disconnect from a specific node", async () => {
+			await ConstantOutput(() => {
+				// initially destination is 1
+				const output = new Signal(1).toDestination();
+
+				// overwrites it with 0
+				const sig = new Signal(0).connect(output);
+
+				// disconnects the signal and goes back to 1
+				sig.disconnect(output);
+			}, 1);
+		});
+
+		it("disconnects every input when no input is passed in", async () => {
+			await ConstantOutput(() => {
+				// initially destination is 1
+				const output = new Signal(1).toDestination();
+
+				// overwrites it with 0
+				const sig = new Signal(0).connect(output, 0);
+
+				// disconnects the signal and goes back to 1
+				sig.disconnect(output);
+			}, 1);
+		});
+
+		it("disconnects every output when no output is passed in", async () => {
+			await ConstantOutput(() => {
+				// initially destination is 1
+				const output = new Signal(1).toDestination();
+
+				// overwrites it with 0
+				const sig = new Signal(0).connect(output, undefined, 0);
+
+				// disconnects the signal and goes back to 1
+				sig.disconnect(output);
+			}, 1);
+		});
+
+		it("disconnects everything if no destination is passed in", () => {
+			return ConstantOutput((context) => {
+				const sig = new Signal({
+					value: 3,
+					context,
+				});
+				const output = new Signal({
+					value: 2,
+					context,
+				}).toDestination();
+
+				// overridden with value of 3
+				connectSignal(sig, output);
+				expect(output.overridden).to.be.true;
+
+				// disconnect goes back to 2
+				sig.disconnect();
+				expect(output.overridden).to.be.false;
+			}, 2);
+		});
+
+		it("can connect multiple times with no affect", () => {
+			return ConstantOutput((context) => {
+				const sig = new Signal({
+					value: 3,
+					context,
+				});
+				const output = new Signal({
+					value: 2,
+					context,
+				}).toDestination();
+
+				connectSignal(sig, output);
+				expect(output.overridden).to.be.true;
+
+				// no affect when called again
+				connectSignal(sig, output);
+			}, 3);
+		});
+
+		it("disconnecting multiple times throws an error", () => {
+			return ConstantOutput((context) => {
+				const sig = new Signal({
+					value: 3,
+					context,
+				});
+				const output = new Signal({
+					value: 2,
+					context,
+				}).toDestination();
+
+				connectSignal(sig, output);
+
+				disconnectSignal(sig, output);
+				expect(() => disconnectSignal(sig, output)).to.throw(Error);
+			}, 2);
+		});
+	});
 });

package/Tone/signal/Signal.ts

@@ -1,6 +1,7 @@
 import { AbstractParam } from "../core/context/AbstractParam.js";
 import { Param } from "../core/context/Param.js";
 import {
+	disconnect,
 	InputNode,
 	OutputNode,
 	ToneAudioNode,
@@ -10,6 +11,7 @@ import { connect } from "../core/context/ToneAudioNode.js";
 import { Time, UnitMap, UnitName } from "../core/type/Units.js";
 import { isAudioParam } from "../core/util/AdvancedTypeCheck.js";
 import { optionsFromArguments } from "../core/util/Defaults.js";
+import { isUndef } from "../core/util/TypeCheck.js";
 import { ToneConstantSource } from "./ToneConstantSource.js";
 
 export interface SignalOptions<TypeName extends UnitName>
@@ -98,6 +100,16 @@ export class Signal<TypeName extends UnitName = "number">
 		return this;
 	}
 
+	disconnect(
+		destination?: InputNode,
+		outputNum?: number,
+		inputNum?: number
+	): this {
+		// disconnect the signal
+		disconnectSignal(this, destination, outputNum, inputNum);
+		return this;
+	}
+
 	dispose(): this {
 		super.dispose();
 		this._param.dispose();
@@ -233,6 +245,22 @@ export class Signal<TypeName extends UnitName = "number">
 	}
 }
 
+/**
+ * Keep track of connected signals so they can be disconnected and restored to their previous value
+ */
+const connectedSignals = new WeakMap<
+	OutputNode,
+	Array<{
+		destination: Param | AudioParam | Signal;
+		outputNum: number;
+		inputNum: number;
+		/**
+		 * The value before overriding
+		 */
+		previousValue: number;
+	}>
+>();
+
 /**
  * When connecting from a signal, it's necessary to zero out the node destination
  * node if that node is also a signal. If the destination is not 0, then the values
@@ -254,6 +282,7 @@ export function connectSignal(
 		isAudioParam(destination) ||
 		(destination instanceof Signal && destination.override)
 	) {
+		const previousValue = destination.value;
 		// cancel changes
 		destination.cancelScheduledValues(0);
 		// reset the value
@@ -262,6 +291,75 @@ export function connectSignal(
 		if (destination instanceof Signal) {
 			destination.overridden = true;
 		}
+		// store the connection
+		if (!connectedSignals.has(signal)) {
+			connectedSignals.set(signal, []);
+		}
+		connectedSignals.get(signal)?.push({
+			destination,
+			outputNum: outputNum || 0,
+			inputNum: inputNum || 0,
+			previousValue,
+		});
 	}
 	connect(signal, destination, outputNum, inputNum);
 }
+
+/**
+ * Disconnect a signal connection and restore the value of the destination if
+ * it was a signal that was overridden by the connection.
+ * @param signal
+ * @param destination
+ * @param outputNum
+ * @param inputNum
+ */
+export function disconnectSignal(
+	signal: OutputNode,
+	destination?: InputNode,
+	outputNum?: number,
+	inputNum?: number
+): void {
+	if (
+		destination instanceof Param ||
+		isAudioParam(destination) ||
+		(destination instanceof Signal && destination.override) ||
+		destination === undefined
+	) {
+		if (connectedSignals.has(signal)) {
+			let connections = connectedSignals.get(signal)!;
+
+			if (destination) {
+				connections = connections.filter((conn) => {
+					return (
+						conn.destination === destination &&
+						(isUndef(outputNum) || conn.outputNum === outputNum) &&
+						(isUndef(inputNum) || conn.inputNum === inputNum)
+					);
+				});
+			}
+
+			if (!connections.length) {
+				throw new Error("Not connected to destination node");
+			}
+
+			// restore the value
+			connections.forEach((connection) => {
+				if (connection.destination instanceof Signal) {
+					connection.destination.overridden = false;
+				}
+				connection.destination.setValueAtTime(
+					connection.previousValue,
+					0
+				);
+			});
+			// remove the connection from the stored array
+			connectedSignals.set(
+				signal,
+				connectedSignals
+					.get(signal)!
+					.filter((conn) => !connections.includes(conn))
+			);
+		}
+	}
+	disconnect(signal, destination, outputNum, inputNum);
+}

package/Tone/version.ts

@@ -1 +1 @@
-export const version: string = "15.3.2";
+export const version: string = "15.3.3";