tone 14.8.27

package/Tone/core/context/BaseContext.ts

@@ -0,0 +1,162 @@
+import { Seconds } from "../type/Units";
+import { Emitter } from "../util/Emitter";
+import { AnyAudioContext } from "./AudioContext";
+
+type Draw = import("../util/Draw").Draw;
+type Destination = import("./Destination").Destination;
+type Transport = import("../clock/Transport").Transport;
+type Listener = import("./Listener").Listener;
+
+// these are either not used in Tone.js or deprecated and not implemented.
+export type ExcludedFromBaseAudioContext =
+	| "onstatechange"
+	| "addEventListener"
+	| "removeEventListener"
+	| "listener"
+	| "dispatchEvent"
+	| "audioWorklet"
+	| "destination"
+	| "createScriptProcessor";
+
+// the subset of the BaseAudioContext which Tone.Context implements.
+export type BaseAudioContextSubset = Omit<
+BaseAudioContext,
+ExcludedFromBaseAudioContext
+>;
+
+export type ContextLatencyHint = AudioContextLatencyCategory;
+
+export abstract class BaseContext
+	extends Emitter<"statechange" | "tick">
+	implements BaseAudioContextSubset {
+	//---------------------------
+	// BASE AUDIO CONTEXT METHODS
+	//---------------------------
+	abstract createAnalyser(): AnalyserNode;
+
+	abstract createOscillator(): OscillatorNode;
+
+	abstract createBufferSource(): AudioBufferSourceNode;
+
+	abstract createBiquadFilter(): BiquadFilterNode;
+
+	abstract createBuffer(
+		_numberOfChannels: number,
+		_length: number,
+		_sampleRate: number
+	): AudioBuffer;
+
+	abstract createChannelMerger(
+		_numberOfInputs?: number | undefined
+	): ChannelMergerNode;
+
+	abstract createChannelSplitter(
+		_numberOfOutputs?: number | undefined
+	): ChannelSplitterNode;
+
+	abstract createConstantSource(): ConstantSourceNode;
+
+	abstract createConvolver(): ConvolverNode;
+
+	abstract createDelay(_maxDelayTime?: number | undefined): DelayNode;
+
+	abstract createDynamicsCompressor(): DynamicsCompressorNode;
+
+	abstract createGain(): GainNode;
+
+	abstract createIIRFilter(
+		_feedForward: number[] | Float32Array,
+		_feedback: number[] | Float32Array
+	): IIRFilterNode;
+
+	abstract createPanner(): PannerNode;
+
+	abstract createPeriodicWave(
+		_real: number[] | Float32Array,
+		_imag: number[] | Float32Array,
+		_constraints?: PeriodicWaveConstraints | undefined
+	): PeriodicWave;
+
+	abstract createStereoPanner(): StereoPannerNode;
+
+	abstract createWaveShaper(): WaveShaperNode;
+
+	abstract createMediaStreamSource(
+		_stream: MediaStream
+	): MediaStreamAudioSourceNode;
+
+	abstract createMediaElementSource(
+		_element: HTMLMediaElement
+	): MediaElementAudioSourceNode;
+
+	abstract createMediaStreamDestination(): MediaStreamAudioDestinationNode;
+
+	abstract decodeAudioData(_audioData: ArrayBuffer): Promise<AudioBuffer>;
+
+	//---------------------------
+	// TONE AUDIO CONTEXT METHODS
+	//---------------------------
+
+	abstract createAudioWorkletNode(
+		_name: string,
+		_options?: Partial<AudioWorkletNodeOptions>
+	): AudioWorkletNode;
+
+	abstract get rawContext(): AnyAudioContext;
+
+	abstract async addAudioWorkletModule(
+		_url: string,
+		_name: string
+	): Promise<void>;
+
+	abstract lookAhead: number;
+
+	abstract latencyHint: ContextLatencyHint | Seconds;
+
+	abstract resume(): Promise<void>;
+
+	abstract setTimeout(
+		_fn: (...args: any[]) => void,
+		_timeout: Seconds
+	): number;
+
+	abstract clearTimeout(_id: number): this;
+
+	abstract setInterval(
+		_fn: (...args: any[]) => void,
+		_interval: Seconds
+	): number;
+
+	abstract clearInterval(_id: number): this;
+
+	abstract getConstant(_val: number): AudioBufferSourceNode;
+
+	abstract get currentTime(): Seconds;
+
+	abstract get state(): AudioContextState;
+
+	abstract get sampleRate(): number;
+
+	abstract get listener(): Listener;
+
+	abstract get transport(): Transport;
+
+	abstract get draw(): Draw;
+
+	abstract get destination(): Destination;
+
+	abstract now(): Seconds;
+
+	abstract immediate(): Seconds;
+
+	/*
+	 * This is a placeholder so that JSON.stringify does not throw an error
+	 * This matches what JSON.stringify(audioContext) returns on a native
+	 * audioContext instance.
+	 */
+	toJSON(): Record<string, any> {
+		return {};
+	}
+
+	readonly isOffline: boolean = false;
+}

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

@@ -0,0 +1,358 @@
+import { expect } from "chai";
+import { ConstantOutput } from "test/helper/ConstantOutput";
+import { Offline } from "test/helper/Offline";
+import { ONLINE_TESTING } from "test/helper/Supports";
+import { Transport } from "../clock/Transport";
+import { getContext } from "../Global";
+import { createAudioContext } from "./AudioContext";
+import { Context } from "./Context";
+import { Destination } from "./Destination";
+import { Listener } from "./Listener";
+import { Draw } from "../util/Draw";
+import { connect } from "./ToneAudioNode";
+
+describe("Context", () => {
+	it("creates and disposes the classes attached to the context", async () => {
+		const ac = createAudioContext();
+		const context = new Context(ac);
+		const ctxDest = context.destination;
+		const ctxDraw = context.draw;
+		const ctxTransport = context.transport;
+		const ctxListener = context.listener;
+		expect(context.destination).is.instanceOf(Destination);
+		expect(context.draw).is.instanceOf(Draw);
+		expect(context.listener).is.instanceOf(Listener);
+		await context.close();
+		expect(ctxDest.disposed).to.be.true;
+		expect(ctxDraw.disposed).to.be.true;
+		expect(ctxTransport.disposed).to.be.true;
+		expect(ctxListener.disposed).to.be.true;
+		context.dispose();
+	});
+
+	context("AudioContext", () => {
+		it("extends the AudioContext methods", () => {
+			const ctx = new Context(createAudioContext());
+			expect(ctx).to.have.property("createGain");
+			expect(ctx.createGain()).to.have.property("gain");
+			expect(ctx).to.have.property("createOscillator");
+			expect(ctx.createOscillator()).to.be.have.property("frequency");
+			expect(ctx).to.have.property("createDelay");
+			expect(ctx.createDelay()).to.be.have.property("delayTime");
+			expect(ctx).to.have.property("createConstantSource");
+			ctx.dispose();
+			return ctx.close();
+		});
+
+		it("can be stringified", () => {
+			const ctx = new Context(createAudioContext());
+			expect(JSON.stringify(ctx)).to.equal("{}");
+			ctx.dispose();
+			return ctx.close();
+		});
+
+		if (ONLINE_TESTING) {
+			it("clock is running", (done) => {
+				const interval = setInterval(() => {
+					if (getContext().currentTime > 0.5) {
+						clearInterval(interval);
+						done();
+					}
+				}, 20);
+			});
+		}
+
+		it("has a rawContext", () => {
+			const ctx = new Context(createAudioContext());
+			expect(ctx.rawContext).has.property("destination");
+			expect(ctx.rawContext).has.property("sampleRate");
+			ctx.dispose();
+			return ctx.close();
+		});
+
+		it("can be constructed with an options object", () => {
+			const ctx = new Context({
+				clockSource: "timeout",
+				latencyHint: "playback",
+				lookAhead: 0.2,
+			});
+			expect(ctx.lookAhead).to.equal(0.2);
+			expect(ctx.latencyHint).to.equal("playback");
+			expect(ctx.clockSource).to.equal("timeout");
+			ctx.dispose();
+			return ctx.close();
+		});
+
+		it("returns 'now' and 'immediate' time", () => {
+			const ctx = new Context();
+			expect(ctx.now()).to.be.a("number");
+			expect(ctx.immediate()).to.be.a("number");
+			ctx.dispose();
+			return ctx.close();
+		});
+	});
+
+	context("state", () => {
+		it("can suspend and resume the state", async () => {
+			const ac = createAudioContext();
+			const context = new Context(ac);
+			expect(context.rawContext).to.equal(ac);
+			await ac.suspend();
+			expect(context.state).to.equal("suspended");
+			await context.resume();
+			expect(context.state).to.equal("running");
+			context.dispose();
+			return context.close();
+		});
+
+		it("invokes the statechange event", async () => {
+			const ac = createAudioContext();
+			const context = new Context(ac);
+			let triggerChange = false;
+			context.on("statechange", (state) => {
+				if (!triggerChange) {
+					triggerChange = true;
+					expect(state).to.equal("running");
+				}
+			});
+			await context.resume();
+			await new Promise((done) => setTimeout(() => done(), 10));
+			expect(triggerChange).to.equal(true);
+			context.dispose();
+			return ac.close();
+		});
+	});
+
+	if (ONLINE_TESTING) {
+		context("clockSource", () => {
+			let ctx;
+			beforeEach(() => {
+				ctx = new Context();
+				return ctx.resume();
+			});
+
+			afterEach(() => {
+				ctx.dispose();
+				return ctx.close();
+			});
+
+			it("defaults to 'worker'", () => {
+				expect(ctx.clockSource).to.equal("worker");
+			});
+
+			it("provides callback", (done) => {
+				expect(ctx.clockSource).to.equal("worker");
+				ctx.setTimeout(() => {
+					done();
+				}, 0.1);
+			});
+
+			it("can be set to 'timeout'", (done) => {
+				ctx.clockSource = "timeout";
+				expect(ctx.clockSource).to.equal("timeout");
+				ctx.setTimeout(() => {
+					done();
+				}, 0.1);
+			});
+
+			it("can be set to 'offline'", (done) => {
+				ctx.clockSource = "offline";
+				expect(ctx.clockSource).to.equal("offline");
+				// provides no callback
+				ctx.setTimeout(() => {
+					throw new Error("shouldn't be called");
+				}, 0.1);
+				setTimeout(() => {
+					done();
+				}, 200);
+			});
+		});
+	}
+	context("setTimeout", () => {
+		if (ONLINE_TESTING) {
+			let ctx;
+			beforeEach(() => {
+				ctx = new Context();
+				return ctx.resume();
+			});
+
+			afterEach(() => {
+				ctx.dispose();
+				return ctx.close();
+			});
+
+			it("can set a timeout", (done) => {
+				ctx.setTimeout(() => {
+					done();
+				}, 0.1);
+			});
+
+			it("returns an id", () => {
+				expect(ctx.setTimeout(() => {}, 0.1)).to.be.a("number");
+				// try clearing a random ID, shouldn't cause any errors
+				ctx.clearTimeout(-2);
+			});
+
+			it("timeout is not invoked when cancelled", (done) => {
+				const id = ctx.setTimeout(() => {
+					throw new Error("shouldn't be invoked");
+				}, 0.01);
+				ctx.clearTimeout(id);
+				ctx.setTimeout(() => {
+					done();
+				}, 0.02);
+			});
+
+			it("order is maintained", (done) => {
+				let wasInvoked = false;
+				ctx.setTimeout(() => {
+					expect(wasInvoked).to.equal(true);
+					done();
+				}, 0.02);
+				ctx.setTimeout(() => {
+					wasInvoked = true;
+				}, 0.01);
+			});
+		}
+
+		it("is invoked in the offline context", () => {
+			return Offline((context) => {
+				const transport = new Transport({ context });
+				transport.context.setTimeout(() => {
+					expect(transport.now()).to.be.closeTo(0.01, 0.005);
+				}, 0.01);
+			}, 0.05);
+		});
+	});
+
+	context("setInterval", () => {
+		if (ONLINE_TESTING) {
+			let ctx;
+			beforeEach(() => {
+				ctx = new Context();
+				return ctx.resume();
+			});
+
+			afterEach(() => {
+				ctx.dispose();
+				return ctx.close();
+			});
+
+			it("can set an interval", (done) => {
+				ctx.setInterval(() => {
+					done();
+				}, 0.1);
+			});
+
+			it("returns an id", () => {
+				expect(ctx.setInterval(() => {}, 0.1)).to.be.a("number");
+				// try clearing a random ID, shouldn't cause any errors
+				ctx.clearInterval(-2);
+			});
+
+			it("timeout is not invoked when cancelled", (done) => {
+				const id = ctx.setInterval(() => {
+					throw new Error("shouldn't be invoked");
+				}, 0.01);
+				ctx.clearInterval(id);
+				ctx.setInterval(() => {
+					done();
+				}, 0.02);
+			});
+
+			it("order is maintained", (done) => {
+				let wasInvoked = false;
+				ctx.setInterval(() => {
+					expect(wasInvoked).to.equal(true);
+					done();
+				}, 0.02);
+				ctx.setInterval(() => {
+					wasInvoked = true;
+				}, 0.01);
+			});
+		}
+
+		it("is invoked in the offline context", () => {
+			let invocationCount = 0;
+			return Offline((context) => {
+				context.setInterval(() => {
+					invocationCount++;
+				}, 0.01);
+			}, 0.051).then(() => {
+				expect(invocationCount).to.equal(4);
+			});
+		});
+
+		it("is invoked in with the right interval", () => {
+			let numberOfInvocations = 0;
+			return Offline((context) => {
+				let intervalTime = context.now();
+				context.setInterval(() => {
+					expect(context.now() - intervalTime).to.be.closeTo(
+						0.01,
+						0.005
+					);
+					intervalTime = context.now();
+					numberOfInvocations++;
+				}, 0.01);
+			}, 0.051).then(() => {
+				expect(numberOfInvocations).to.equal(4);
+			});
+		});
+	});
+
+	context("get/set", () => {
+		let ctx;
+		beforeEach(() => {
+			ctx = new Context();
+			return ctx.resume();
+		});
+
+		afterEach(() => {
+			ctx.dispose();
+			return ctx.close();
+		});
+
+		it("can set the lookAhead", () => {
+			ctx.lookAhead = 0.05;
+			expect(ctx.lookAhead).to.equal(0.05);
+		});
+
+		it("can set the updateInterval", () => {
+			ctx.updateInterval = 0.05;
+			expect(ctx.updateInterval).to.equal(0.05);
+		});
+
+		it("gets a constant signal", () => {
+			return ConstantOutput((context) => {
+				const bufferSrc = context.getConstant(1);
+				connect(bufferSrc, context.destination);
+			}, 1);
+		});
+
+		it("multiple calls return the same buffer source", () => {
+			const bufferA = ctx.getConstant(2);
+			const bufferB = ctx.getConstant(2);
+			expect(bufferA).to.equal(bufferB);
+		});
+	});
+
+	context("Methods", () => {
+		let ctx;
+		beforeEach(() => {
+			ctx = new Context();
+			return ctx.resume();
+		});
+
+		afterEach(() => {
+			ctx.dispose();
+			return ctx.close();
+		});
+
+		it("can create a MediaElementAudioSourceNode", () => {
+			const audioNode = document.createElement("audio");
+			const node = ctx.createMediaElementSource(audioNode);
+			expect(node).is.not.undefined;
+		});
+	});
+});