tone 15.3.3 → 15.3.5

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

@@ -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 });
@@ -423,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/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/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/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/Source.ts

@@ -217,7 +217,6 @@ export abstract class Source<
 			this.log("restart", computedTime);
 			this.restart(computedTime, offset, duration);
 		} else {
-			this.log("start", computedTime);
 			this._state.setStateAtTime("started", computedTime);
 			if (this._synced) {
 				// add the offset time to the event

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.3";
+export const version: string = "15.3.5";