tone 14.8.27

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

@@ -0,0 +1,105 @@
+import { expect } from "chai";
+import { BasicTests } from "test/helper/Basic";
+import { connectFrom, connectTo } from "test/helper/Connect";
+import { PassAudio } from "test/helper/PassAudio";
+import { connect } from "../context/ToneAudioNode";
+import { Delay } from "./Delay";
+
+describe("Delay", () => {
+
+	BasicTests(Delay);
+
+	it("can be created and disposed", () => {
+		const delay = new Delay();
+		delay.dispose();
+	});
+
+	it("handles input and output connections", () => {
+		const delay = new Delay();
+		delay.connect(connectTo());
+		connectFrom().connect(delay);
+		connectFrom().connect(delay.delayTime);
+		delay.dispose();
+	});
+
+	it("can be constructed with an options object", () => {
+		const delay = new Delay({
+			delayTime: 0.3,
+			maxDelay: 2,
+		});
+		expect(delay.delayTime.value).to.be.closeTo(0.3, 0.001);
+		expect(delay.maxDelay).to.equal(2);
+		delay.dispose();
+	});
+
+	it("if the constructor delay time is greater than maxDelay, use that as the maxDelay time", () => {
+		const delay = new Delay(3);
+		expect(delay.delayTime.value).to.be.closeTo(3, 0.001);
+		delay.dispose();
+	});
+
+	it("clamps the delayTime range between 0 and maxDelay", () => {
+		const delay = new Delay({
+			maxDelay: 1
+		});
+		expect(() => {
+			delay.delayTime.value = 2;
+		}).to.throw(RangeError);
+		expect(() => {
+			delay.delayTime.value = -1;
+		}).to.throw(RangeError);
+		expect(delay.delayTime.value).to.be.closeTo(0, 0.001);
+		delay.dispose();
+	});
+
+	it("can set the delayTime value", () => {
+		const delay = new Delay();
+		expect(delay.delayTime.value).to.be.closeTo(0, 0.001);
+		delay.delayTime.value = 0.2;
+		expect(delay.delayTime.value).to.be.closeTo(0.2, 0.001);
+		delay.dispose();
+	});
+
+	it("can be constructed with options object", () => {
+		const delay = new Delay({
+			delayTime: 0.4,
+		});
+		expect(delay.delayTime.value).to.be.closeTo(0.4, 0.001);
+		delay.dispose();
+	});
+
+	it("can be constructed with an initial value", () => {
+		const delay = new Delay(0.3);
+		expect(delay.delayTime.value).to.be.closeTo(0.3, 0.001);
+		delay.dispose();
+	});
+
+	it("can set the units", () => {
+		const delay = new Delay(0);
+		expect(delay.delayTime.value).to.be.closeTo(0, 0.001);
+		delay.dispose();
+	});
+
+	it("can get the value using 'get'", () => {
+		const delay = new Delay(2);
+		const value = delay.get();
+		expect(value.delayTime).to.be.closeTo(2, 0.001);
+		delay.dispose();
+	});
+
+	it("can set the value using 'set'", () => {
+		const delay = new Delay(5);
+		delay.set({
+			delayTime: 4,
+		});
+		expect(delay.delayTime.value).to.be.closeTo(4, 0.001);
+		delay.dispose();
+	});
+
+	it("passes audio through", () => {
+		return PassAudio(input => {
+			const delay = new Delay().toDestination();
+			connect(input, delay);
+		});
+	});
+});

package/Tone/core/context/Delay.ts

@@ -0,0 +1,103 @@
+import { Param } from "../context/Param";
+import { Seconds, Time } from "../type/Units";
+import { optionsFromArguments } from "../util/Defaults";
+import { readOnly } from "../util/Interface";
+import { ToneAudioNode, ToneAudioNodeOptions } from "./ToneAudioNode";
+
+export interface DelayOptions extends ToneAudioNodeOptions {
+	delayTime: Time;
+	maxDelay: Time;
+}
+
+/**
+ * Wrapper around Web Audio's native [DelayNode](http://webaudio.github.io/web-audio-api/#the-delaynode-interface).
+ * @category Core
+ * @example
+ * return Tone.Offline(() => {
+ * 	const delay = new Tone.Delay(0.1).toDestination();
+ * 	// connect the signal to both the delay and the destination
+ * 	const pulse = new Tone.PulseOscillator().connect(delay).toDestination();
+ * 	// start and stop the pulse
+ * 	pulse.start(0).stop(0.01);
+ * }, 0.5, 1);
+ */
+export class Delay extends ToneAudioNode<DelayOptions> {
+
+	readonly name: string = "Delay";
+
+	/**
+	 * Private holder of the max delay time
+	 */
+	private _maxDelay: Seconds;
+
+	/**
+	 * The amount of time the incoming signal is delayed.
+	 * @example
+	 * const delay = new Tone.Delay().toDestination();
+	 * // modulate the delayTime between 0.1 and 1 seconds
+	 * const delayLFO = new Tone.LFO(0.5, 0.1, 1).start().connect(delay.delayTime);
+	 * const pulse = new Tone.PulseOscillator().connect(delay).start();
+	 * // the change in delayTime causes the pitch to go up and down
+	 */
+	readonly delayTime: Param<"time">;
+
+	/**
+	 * Private reference to the internal DelayNode
+	 */
+	private _delayNode: DelayNode;
+	readonly input: DelayNode;
+	readonly output: DelayNode;
+
+	/**
+	 * @param delayTime The delay applied to the incoming signal.
+	 * @param maxDelay The maximum delay time.
+	 */
+	constructor(delayTime?: Time, maxDelay?: Time);
+	constructor(options?: Partial<DelayOptions>);
+	constructor() {
+		super(optionsFromArguments(Delay.getDefaults(), arguments, ["delayTime", "maxDelay"]));
+
+		const options = optionsFromArguments(Delay.getDefaults(), arguments, ["delayTime", "maxDelay"]);
+
+		const maxDelayInSeconds = this.toSeconds(options.maxDelay);
+		this._maxDelay = Math.max(maxDelayInSeconds, this.toSeconds(options.delayTime));
+
+		this._delayNode = this.input = this.output = this.context.createDelay(maxDelayInSeconds);
+
+		this.delayTime = new Param({
+			context: this.context,
+			param: this._delayNode.delayTime,
+			units: "time",
+			value: options.delayTime,
+			minValue: 0,
+			maxValue: this.maxDelay,
+		});
+
+		readOnly(this, "delayTime");
+	}
+
+	static getDefaults(): DelayOptions {
+		return Object.assign(ToneAudioNode.getDefaults(), {
+			delayTime: 0,
+			maxDelay: 1,
+		});
+	}
+
+	/**
+	 * The maximum delay time. This cannot be changed after
+	 * the value is passed into the constructor.
+	 */
+	get maxDelay(): Seconds {
+		return this._maxDelay;
+	}
+
+	/**
+	 * Clean up.
+	 */
+	dispose(): this {
+		super.dispose();
+		this._delayNode.disconnect();
+		this.delayTime.dispose();
+		return this;
+	}
+}

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

@@ -0,0 +1,76 @@
+import { expect } from "chai";
+import { warns } from "test/helper/Basic";
+import { Offline } from "test/helper/Offline";
+import { PassAudio } from "test/helper/PassAudio";
+import { Oscillator } from "Tone/source/oscillator/Oscillator";
+import { getContext } from "../Global";
+import { Destination } from "./Destination";
+
+describe("Destination", () => {
+
+	it("creates itself on the context", () => {
+		expect(getContext().destination).instanceOf(Destination);
+	});
+
+	it("can be muted and unmuted", () => {
+		return Offline(context => {
+			context.destination.mute = false;
+			expect(context.destination.mute).to.equal(false);
+			context.destination.mute = true;
+			expect(context.destination.mute).to.equal(true);
+		});
+	});
+
+	it("passes audio through", () => {
+		return PassAudio(input => {
+			input.toDestination();
+		});
+	});
+
+	it("passes no audio when muted", () => {
+		return Offline((context) => {
+			new Oscillator().toDestination().start(0);
+			context.destination.mute = true;
+		}).then(buffer => {
+			expect(buffer.isSilent()).to.equal(true);
+		});
+	});
+
+	it("has a master volume control", () => {
+		return Offline((context) => {
+			context.destination.volume.value = -20;
+			expect(context.destination.volume.value).to.be.closeTo(-20, 0.1);
+		});
+	});
+
+	it("warns when toMaster is called", () => {
+		warns(() => {
+			const osc = new Oscillator().toMaster();
+			osc.dispose();
+		});
+	});
+
+	it("can get the maxChannelCount", () => {
+		return Offline((context) => {
+			expect(context.destination.maxChannelCount).to.equal(4);
+		}, 0.1, 4);
+	});
+
+	it("can set the audio channel configuration", () => {
+		return Offline((context) => {
+			expect(context.destination.channelCount).to.equal(4);
+			context.destination.channelCountMode = "explicit";
+			context.destination.channelInterpretation = "discrete";
+			expect(context.destination.channelCountMode).to.equal("explicit");
+			expect(context.destination.channelInterpretation).to.equal("discrete");
+		}, 0.1, 4);
+	});
+
+	it("can pass audio through chained nodes", () => {
+		return PassAudio(input => {
+			const gain = input.context.createGain();
+			input.connect(gain);
+			input.context.destination.chain(gain);
+		});
+	});
+});

package/Tone/core/context/Destination.ts

@@ -0,0 +1,128 @@
+import { Volume } from "../../component/channel/Volume";
+import { Decibels } from "../type/Units";
+import { optionsFromArguments } from "../util/Defaults";
+import { onContextClose, onContextInit } from "./ContextInitialization";
+import { Gain } from "./Gain";
+import { Param } from "./Param";
+import { connectSeries, ToneAudioNode, ToneAudioNodeOptions } from "./ToneAudioNode";
+
+interface DestinationOptions extends ToneAudioNodeOptions {
+	volume: Decibels;
+	mute: boolean;
+}
+
+/**
+ * A single master output which is connected to the
+ * AudioDestinationNode (aka your speakers).
+ * It provides useful conveniences such as the ability
+ * to set the volume and mute the entire application.
+ * It also gives you the ability to apply master effects to your application.
+ *
+ * @example
+ * const oscillator = new Tone.Oscillator().start();
+ * // the audio will go from the oscillator to the speakers
+ * oscillator.connect(Tone.getDestination());
+ * // a convenience for connecting to the master output is also provided:
+ * oscillator.toDestination();
+ * @category Core
+ */
+export class Destination extends ToneAudioNode<DestinationOptions> {
+
+	readonly name: string = "Destination";
+
+	input: Volume = new Volume({ context: this.context });
+	output: Gain = new Gain({ context: this.context });
+
+	/**
+	 * The volume of the master output in decibels. -Infinity is silent, and 0 is no change. 
+	 * @example
+	 * const osc = new Tone.Oscillator().toDestination();
+	 * osc.start();
+	 * // ramp the volume down to silent over 10 seconds
+	 * Tone.getDestination().volume.rampTo(-Infinity, 10);
+	 */
+	volume: Param<"decibels"> = this.input.volume;
+
+	constructor(options: Partial<DestinationOptions>);
+	constructor() {
+
+		super(optionsFromArguments(Destination.getDefaults(), arguments));
+		const options = optionsFromArguments(Destination.getDefaults(), arguments);
+
+		connectSeries(this.input, this.output, this.context.rawContext.destination);
+
+		this.mute = options.mute;
+		this._internalChannels = [this.input, this.context.rawContext.destination, this.output];
+	}
+
+	static getDefaults(): DestinationOptions {
+		return Object.assign(ToneAudioNode.getDefaults(), {
+			mute: false,
+			volume: 0,
+		});
+	}
+
+	/**
+	 * Mute the output.
+	 * @example
+	 * const oscillator = new Tone.Oscillator().start().toDestination();
+	 * setTimeout(() => {
+	 * 	// mute the output
+	 * 	Tone.Destination.mute = true;
+	 * }, 1000);
+	 */
+	get mute(): boolean {
+		return this.input.mute;
+	}
+	set mute(mute: boolean) {
+		this.input.mute = mute;
+	}
+
+	/**
+	 * Add a master effects chain. NOTE: this will disconnect any nodes which were previously
+	 * chained in the master effects chain.
+	 * @param args All arguments will be connected in a row and the Master will be routed through it.
+	 * @example
+	 * // route all audio through a filter and compressor
+	 * const lowpass = new Tone.Filter(800, "lowpass");
+	 * const compressor = new Tone.Compressor(-18);
+	 * Tone.Destination.chain(lowpass, compressor);
+	 */
+	chain(...args: Array<AudioNode | ToneAudioNode>): this {
+		this.input.disconnect();
+		args.unshift(this.input);
+		args.push(this.output);
+		connectSeries(...args);
+		return this;
+	}
+
+	/**
+	 * The maximum number of channels the system can output
+	 * @example
+	 * console.log(Tone.Destination.maxChannelCount);
+	 */
+	get maxChannelCount(): number {
+		return this.context.rawContext.destination.maxChannelCount;
+	}
+
+	/**
+	 * Clean up
+	 */
+	dispose(): this {
+		super.dispose();
+		this.volume.dispose();
+		return this;
+	}
+}
+
+//-------------------------------------
+// 	INITIALIZATION
+//-------------------------------------
+
+onContextInit(context => {
+	context.destination = new Destination({ context });
+});
+
+onContextClose(context => {
+	context.destination.dispose();
+});

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

@@ -0,0 +1,47 @@
+import { DummyContext } from "./DummyContext";
+
+describe("DummyContext", () => {
+	it("has all the methods and members", () => {
+		const context = new DummyContext();
+		context.createAnalyser();
+		context.createOscillator();
+		context.createBufferSource();
+		context.createBiquadFilter();
+		context.createBuffer(2, 1024, 44100);
+		context.createChannelMerger();
+		context.createChannelSplitter();
+		context.createConstantSource();
+		context.createConvolver();
+		context.createDelay();
+		context.createDynamicsCompressor();
+		context.createGain();
+		context.createIIRFilter([1, 1, 1], [1, 1, 1]);
+		context.createPanner();
+		context.createPeriodicWave([1, 1, 1], [1, 1, 1]);
+		context.createStereoPanner();
+		context.createWaveShaper();
+		// @ts-ignore
+		context.createMediaStreamSource();
+		context.decodeAudioData(new Float32Array(100));
+		context.createAudioWorkletNode("test.js");
+		context.rawContext;
+		context.addAudioWorkletModule("test.js", "test");
+		context.resume();
+		context.setTimeout(() => {}, 1);
+		context.clearTimeout(1);
+		context.setInterval(() => {}, 1);
+		context.clearInterval(1);
+		context.getConstant(1);
+		context.currentTime;
+		context.state;
+		context.sampleRate;
+		context.listener;
+		context.transport;
+		context.draw;
+		context.draw;
+		context.destination;
+		context.now();
+		context.immediate();
+	});
+});
+

package/Tone/core/context/DummyContext.ts

@@ -0,0 +1,201 @@
+import { BaseContext } from "./BaseContext";
+import { Seconds } from "../type/Units";
+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;
+
+export class DummyContext extends BaseContext {
+	//---------------------------
+	// BASE AUDIO CONTEXT METHODS
+	//---------------------------
+	createAnalyser(): AnalyserNode {
+		return {} as AnalyserNode;
+	}
+
+	createOscillator(): OscillatorNode {
+		return {} as OscillatorNode;
+	}
+
+	createBufferSource() {
+		return {} as AudioBufferSourceNode;
+	}
+
+	createBiquadFilter(): BiquadFilterNode {
+		return {} as BiquadFilterNode;
+	}
+
+	createBuffer(
+		_numberOfChannels: number,
+		_length: number,
+		_sampleRate: number
+	): AudioBuffer {
+		return {} as AudioBuffer;
+	}
+
+	createChannelMerger(
+		_numberOfInputs?: number | undefined
+	): ChannelMergerNode {
+		return {} as ChannelMergerNode;
+	}
+
+	createChannelSplitter(
+		_numberOfOutputs?: number | undefined
+	): ChannelSplitterNode {
+		return {} as ChannelSplitterNode;
+	}
+
+	createConstantSource(): ConstantSourceNode {
+		return {} as ConstantSourceNode;
+	}
+
+	createConvolver(): ConvolverNode {
+		return {} as ConvolverNode;
+	}
+
+	createDelay(_maxDelayTime?: number | undefined): DelayNode {
+		return {} as DelayNode;
+	}
+
+	createDynamicsCompressor(): DynamicsCompressorNode {
+		return {} as DynamicsCompressorNode;
+	}
+
+	createGain(): GainNode {
+		return {} as GainNode;
+	}
+
+	createIIRFilter(
+		_feedForward: number[] | Float32Array,
+		_feedback: number[] | Float32Array
+	): IIRFilterNode {
+		return {} as IIRFilterNode;
+	}
+
+	createPanner(): PannerNode {
+		return {} as PannerNode;
+	}
+
+	createPeriodicWave(
+		_real: number[] | Float32Array,
+		_imag: number[] | Float32Array,
+		_constraints?: PeriodicWaveConstraints | undefined
+	): PeriodicWave {
+		return {} as PeriodicWave;
+	}
+
+	createStereoPanner(): StereoPannerNode {
+		return {} as StereoPannerNode;
+	}
+
+	createWaveShaper(): WaveShaperNode {
+		return {} as WaveShaperNode;
+	}
+
+	createMediaStreamSource(_stream: MediaStream): MediaStreamAudioSourceNode {
+		return {} as MediaStreamAudioSourceNode;
+	}
+
+	createMediaElementSource(
+		_element: HTMLMediaElement
+	): MediaElementAudioSourceNode {
+		return {} as MediaElementAudioSourceNode;
+	}
+
+	createMediaStreamDestination(): MediaStreamAudioDestinationNode {
+		return {} as MediaStreamAudioDestinationNode;
+	}
+
+	decodeAudioData(_audioData: ArrayBuffer): Promise<AudioBuffer> {
+		return Promise.resolve({} as AudioBuffer);
+	}
+
+	//---------------------------
+	// TONE AUDIO CONTEXT METHODS
+	//---------------------------
+
+	createAudioWorkletNode(
+		_name: string,
+		_options?: Partial<AudioWorkletNodeOptions>
+	): AudioWorkletNode {
+		return {} as AudioWorkletNode;
+	}
+
+	get rawContext(): AnyAudioContext {
+		return {} as AnyAudioContext;
+	}
+
+	async addAudioWorkletModule(_url: string, _name: string): Promise<void> {
+		return Promise.resolve();
+	}
+
+	lookAhead = 0;
+
+	latencyHint = 0;
+
+	resume(): Promise<void> {
+		return Promise.resolve();
+	}
+
+	setTimeout(_fn: (...args: any[]) => void, _timeout: Seconds): number {
+		return 0;
+	}
+
+	clearTimeout(_id: number): this {
+		return this;
+	}
+
+	setInterval(_fn: (...args: any[]) => void, _interval: Seconds): number {
+		return 0;
+	}
+
+	clearInterval(_id: number): this {
+		return this;
+	}
+
+	getConstant(_val: number): AudioBufferSourceNode {
+		return {} as AudioBufferSourceNode;
+	}
+
+	get currentTime(): Seconds {
+		return 0;
+	}
+
+	get state(): AudioContextState {
+		return {} as AudioContextState;
+	}
+
+	get sampleRate(): number {
+		return 0;
+	}
+
+	get listener(): Listener {
+		return {} as Listener;
+	}
+
+	get transport(): Transport {
+		return {} as Transport;
+	}
+
+	get draw(): Draw {
+		return {} as Draw;
+	}
+	set draw(_d) {}
+
+	get destination(): Destination {
+		return {} as Destination;
+	}
+	set destination(_d: Destination) {}
+
+	now() {
+		return 0;
+	}
+
+	immediate() {
+		return 0;
+	}
+
+	readonly isOffline: boolean = false;
+}