tone 15.3.2 → 15.3.4

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

@@ -241,6 +241,33 @@ describe("Transport", () => {
 			});
 		});
 
+		it("can schedule the current seconds position", () => {
+			return Offline((context) => {
+				const transport = new TransportInstance({ context });
+				transport.start();
+
+				let scheduled = false;
+
+				return (time) => {
+					if (time > 0.5 && !scheduled) {
+						scheduled = true;
+						transport.setSecondsAtTime(3, 0.5);
+					}
+
+					whenBetween(time, 0, 0.5, () => {
+						expect(transport.seconds).to.be.closeTo(time, 0.01);
+					});
+
+					whenBetween(time, 0.5, 1, () => {
+						expect(transport.seconds).to.be.closeTo(
+							2.5 + time,
+							0.01
+						);
+					});
+				};
+			}, 1);
+		});
+
 		it("can set the current position in BarsBeatsSixteenths", () => {
 			return Offline((context) => {
 				const transport = new TransportInstance({ context });
@@ -330,14 +357,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);
@@ -420,6 +450,36 @@ describe("Transport", () => {
 			}, 2.5);
 			expect(invocations).to.equal(2);
 		});
+
+		it("can schedule the ticks", () => {
+			return Offline((context) => {
+				const transport = new TransportInstance({ context });
+				transport.start();
+
+				let scheduled = false;
+
+				return (time) => {
+					if (time > 0.5 && !scheduled) {
+						scheduled = true;
+						transport.setTicksAtTime(0, 0.5);
+					}
+
+					whenBetween(time, 0, 0.5, () => {
+						expect(transport.ticks).to.be.closeTo(
+							transport.toTicks(time),
+							1
+						);
+					});
+
+					whenBetween(time, 0.5, 1, () => {
+						expect(transport.ticks).to.be.closeTo(
+							transport.toTicks(time - 0.5),
+							1
+						);
+					});
+				};
+			}, 1);
+		});
 	});
 
 	context("schedule", () => {

package/Tone/core/clock/Transport.ts

@@ -27,6 +27,7 @@ import {
 	TransportTime,
 } from "../type/Units.js";
 import { enterScheduledCallback } from "../util/Debug.js";
+import { assertUsedScheduleTime } from "../util/Debug.js";
 import { optionsFromArguments } from "../util/Defaults.js";
 import { Emitter } from "../util/Emitter.js";
 import { readOnly, writable } from "../util/Interface.js";
@@ -623,6 +624,7 @@ export class TransportInstance
 		return this._clock.ticks;
 	}
 	set ticks(t: Ticks) {
+		assertUsedScheduleTime();
 		if (this._clock.ticks !== t) {
 			const now = this.now();
 			// stop everything synced to the transport
@@ -654,6 +656,16 @@ export class TransportInstance
 		return this._clock.getTicksAtTime(time);
 	}
 
+	/**
+	 * Set the Transport's {@link ticks} value at the given time
+	 * @param  ticks  The tick value to set
+	 * @param  time   The Context time at which to set the seconds value
+	 */
+	setTicksAtTime(ticks: Ticks, time: Time): this {
+		this._clock.setTicksAtTime(ticks, time);
+		return this;
+	}
+
 	/**
 	 * Return the elapsed seconds at the given time.
 	 * @param  time  When to get the elapsed seconds
@@ -663,6 +675,16 @@ export class TransportInstance
 		return this._clock.getSecondsAtTime(time);
 	}
 
+	/**
+	 * Set the Transport's {@link seconds} value at the given time.
+	 * @param seconds The seconds value to set
+	 * @param time The Context time at which to set the seconds value
+	 */
+	setSecondsAtTime(seconds: Seconds, time: Time): this {
+		this.setTicksAtTime(this.toTicks(seconds), time);
+		return this;
+	}
+
 	/**
 	 * Pulses Per Quarter note. This is the smallest resolution
 	 * the Transport timing supports. This should be set once

package/Tone/core/context/BaseContext.ts

@@ -25,6 +25,9 @@ export type BaseAudioContextSubset = Omit<
 
 export type ContextLatencyHint = AudioContextLatencyCategory;
 
+/**
+ * Shared class for both Offline and Online Audio Context's
+ */
 export abstract class BaseContext
 	extends Emitter<"statechange" | "tick">
 	implements BaseAudioContextSubset

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

@@ -60,7 +60,7 @@ export function assertUsedScheduleTime(time?: Time): void {
 	) {
 		printedScheduledWarning = true;
 		warn(
-			"Events scheduled inside of scheduled callbacks should use the passed in scheduling time. See https://github.com/Tonejs/Tone.js/wiki/Accurate-Timing"
+			"Schedulable methods should include the provided time argument to ensure accurate timing. See https://github.com/Tonejs/Tone.js/wiki/Accurate-Timing"
 		);
 	}
 }

package/Tone/core/util/Emitter.ts

@@ -10,7 +10,6 @@ export interface EmitterEventObject {
  * the ability to listen for and emit events.
  * Inspiration and reference from Jerome Etienne's [MicroEvent](https://github.com/jeromeetienne/microevent.js).
  * MIT (c) 2011 Jerome Etienne.
- * @category Core
  */
 export class Emitter<EventType extends string = string> extends Tone {
 	readonly name: string = "Emitter";

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);
+		});
+	});
 });