tone 14.8.36 → 14.8.39

package/Tone/component/analysis/Meter.test.ts

@@ -5,6 +5,8 @@ import { ONLINE_TESTING } from "test/helper/Supports";
 import { Signal } from "Tone/signal/Signal";
 import { Oscillator } from "Tone/source/oscillator/Oscillator";
 import { Meter } from "./Meter";
+import { Panner } from "Tone/component/channel/Panner";
+import { Merge } from "Tone/component/channel/Merge";
 
 describe("Meter", () => {
 
@@ -86,6 +88,29 @@ describe("Meter", () => {
 					done();
 				}, 400);
 			});
+
+			it("can get the rms levels for multiple channels", (done) => {
+				const meter = new Meter({
+					channelCount: 2,
+					smoothing: 0.5,
+				});
+				const merge = new Merge().connect(meter);
+				const osc0 = new Oscillator().connect(merge, 0, 0).start();
+				const osc1 = new Oscillator().connect(merge, 0, 1).start();
+				osc0.volume.value = -6;
+				osc1.volume.value = -18;
+				setTimeout(() => {
+					const values = meter.getValue();
+					expect(values).to.have.lengthOf(2);
+					expect(values[0]).to.be.closeTo(-9, 1);
+					expect(values[1]).to.be.closeTo(-21, 1);
+					meter.dispose();
+					merge.dispose();
+					osc0.dispose();
+					osc1.dispose();
+					done();
+				}, 400);
+			});
 		}
 	});
 });

package/Tone/component/analysis/Meter.ts

@@ -42,9 +42,9 @@ export class Meter extends MeterBase<MeterOptions> {
 	smoothing: number;
 
 	/**
-	 * The previous frame's value
+	 * The previous frame's value for each channel.
 	 */
-	private _rms = 0;
+	private _rms: number[];
 
 	/**
 	 * @param smoothing The amount of smoothing applied between frames.
@@ -64,6 +64,8 @@ export class Meter extends MeterBase<MeterOptions> {
 
 		this.smoothing = options.smoothing,
 		this.normalRange = options.normalRange;
+		this._rms = new Array(options.channelCount);
+		this._rms.fill(0);
 	}
 
 	static getDefaults(): MeterOptions {
@@ -93,13 +95,13 @@ export class Meter extends MeterBase<MeterOptions> {
 	getValue(): number | number[] {
 		const aValues = this._analyser.getValue();
 		const channelValues = this.channels === 1 ? [aValues as Float32Array] : aValues as Float32Array[];
-		const vals = channelValues.map(values => {
+		const vals = channelValues.map((values, index) => {
 			const totalSquared = values.reduce((total, current) => total + current * current, 0);
 			const rms = Math.sqrt(totalSquared / values.length);
 			// the rms can only fall at the rate of the smoothing
 			// but can jump up instantly
-			this._rms = Math.max(rms, this._rms * this.smoothing);
-			return this.normalRange ? this._rms : gainToDb(this._rms);
+			this._rms[index] = Math.max(rms, this._rms[index]  * this.smoothing);
+			return this.normalRange ? this._rms[index] : gainToDb(this._rms[index]);
 		});
 		if (this.channels === 1) {
 			return vals[0];

package/Tone/component/filter/FeedbackCombFilter.test.ts

@@ -1,5 +1,6 @@
 import { expect } from "chai";
 import { FeedbackCombFilter } from "./FeedbackCombFilter";
+import { BitCrusher } from "Tone/effect/BitCrusher";
 import { BasicTests } from "test/helper/Basic";
 import { PassAudio } from "test/helper/PassAudio";
 import { Offline } from "test/helper/Offline";
@@ -76,5 +77,20 @@ describe("FeedbackCombFilter", () => {
 			});
 		});
 	});
+
+	it("should be usable with the BitCrusher", (done) => {
+		new FeedbackCombFilter();
+		new BitCrusher(4);
+
+		const handle = setTimeout(() => {
+			window.onunhandledrejection = null;
+			done();
+		}, 100);
+
+		window.onunhandledrejection = (event) => {
+			done(event.reason);
+			clearTimeout(handle);
+		};
+	});
 });
 

package/Tone/core/clock/Ticker.ts

@@ -16,7 +16,12 @@ export class Ticker {
 	/**
 	 * The update interval of the worker
 	 */
-	private _updateInterval: Seconds;
+	private _updateInterval!: Seconds;
+
+	/**
+	 * The lowest allowable interval, preferably calculated from context sampleRate
+	 */
+	private _minimumUpdateInterval: Seconds;
 
 	/**
 	 * The callback to invoke at regular intervals
@@ -33,11 +38,12 @@ export class Ticker {
 	 */
 	private _worker!: Worker;
 
-	constructor(callback: () => void, type: TickerClockSource, updateInterval: Seconds) {
+	constructor(callback: () => void, type: TickerClockSource, updateInterval: Seconds, contextSampleRate?: number) {
 
 		this._callback = callback;
 		this._type = type;
-		this._updateInterval = updateInterval;
+		this._minimumUpdateInterval = Math.max( 128/(contextSampleRate || 44100), .001 );
+		this.updateInterval = updateInterval;
 
 		// create the clock source for the first time
 		this._createClock();
@@ -121,9 +127,9 @@ export class Ticker {
 		return this._updateInterval;
 	}
 	set updateInterval(interval: Seconds) {
-		this._updateInterval = Math.max(interval, 128 / 44100);
+		this._updateInterval = Math.max(interval, this._minimumUpdateInterval);
 		if (this._type === "worker") {
-			this._worker.postMessage(Math.max(interval * 1000, 1));
+			this._worker?.postMessage(this._updateInterval * 1000);
 		}
 	}
 

package/Tone/core/context/BaseContext.ts

@@ -105,8 +105,7 @@ export abstract class BaseContext
 	abstract get rawContext(): AnyAudioContext;
 
 	abstract addAudioWorkletModule(
-		_url: string,
-		_name: string
+		_url: string
 	): Promise<void>;
 
 	abstract lookAhead: number;

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

@@ -75,8 +75,10 @@ describe("Context", () => {
 				clockSource: "timeout",
 				latencyHint: "playback",
 				lookAhead: 0.2,
+				updateInterval: 0.1
 			});
 			expect(ctx.lookAhead).to.equal(0.2);
+			expect(ctx.updateInterval).to.equal(0.1);
 			expect(ctx.latencyHint).to.equal("playback");
 			expect(ctx.clockSource).to.equal("timeout");
 			ctx.dispose();

package/Tone/core/context/Context.ts

@@ -3,7 +3,7 @@ import { Seconds } from "../type/Units";
 import { isAudioContext } from "../util/AdvancedTypeCheck";
 import { optionsFromArguments } from "../util/Defaults";
 import { Timeline } from "../util/Timeline";
-import { isDefined, isString } from "../util/TypeCheck";
+import { isDefined } from "../util/TypeCheck";
 import {
 	AnyAudioContext,
 	createAudioContext,
@@ -39,13 +39,6 @@ export interface ContextTimeoutEvent {
 export class Context extends BaseContext {
 	readonly name: string = "Context";
 
-	/**
-	 * The amount of time into the future events are scheduled. Giving Web Audio
-	 * a short amount of time into the future to schedule events can reduce clicks and
-	 * improve performance. This value can be set to 0 to get the lowest latency.
-	 */
-	lookAhead: Seconds;
-
 	/**
 	 * private reference to the BaseAudioContext
 	 */
@@ -116,16 +109,20 @@ export class Context extends BaseContext {
 
 		if (options.context) {
 			this._context = options.context;
+			// custom context provided, latencyHint unknown (unless explicitly provided in options)
+			this._latencyHint = arguments[0]?.latencyHint || "";
 		} else {
 			this._context = createAudioContext({
 				latencyHint: options.latencyHint,
 			});
+			this._latencyHint = options.latencyHint;
 		}
 
 		this._ticker = new Ticker(
 			this.emit.bind(this, "tick"),
 			options.clockSource,
-			options.updateInterval
+			options.updateInterval,
+			this._context.sampleRate
 		);
 		this.on("tick", this._timeoutLoop.bind(this));
 
@@ -133,9 +130,9 @@ export class Context extends BaseContext {
 		this._context.onstatechange = () => {
 			this.emit("statechange", this.state);
 		};
-
-		this._setLatencyHint(options.latencyHint);
-		this.lookAhead = options.lookAhead;
+		
+		// if no custom updateInterval provided, updateInterval will be derived by lookAhead setter
+		this[arguments[0]?.hasOwnProperty("updateInterval") ? "_lookAhead" : "lookAhead"] = options.lookAhead;
 	}
 
 	static getDefaults(): ContextOptions {
@@ -343,7 +340,7 @@ export class Context extends BaseContext {
 	/**
 	 * Maps a module name to promise of the addModule method
 	 */
-	private _workletModules: Map<string, Promise<void>> = new Map();
+	private _workletPromise: null | Promise<void> = null;
 
 	/**
 	 * Create an audio worklet node from a name and options. The module
@@ -359,29 +356,23 @@ export class Context extends BaseContext {
 	/**
 	 * Add an AudioWorkletProcessor module
 	 * @param url The url of the module
-	 * @param name The name of the module
 	 */
-	async addAudioWorkletModule(url: string, name: string): Promise<void> {
+	async addAudioWorkletModule(url: string): Promise<void> {
 		assert(
 			isDefined(this.rawContext.audioWorklet),
 			"AudioWorkletNode is only available in a secure context (https or localhost)"
 		);
-		if (!this._workletModules.has(name)) {
-			this._workletModules.set(
-				name,
-				this.rawContext.audioWorklet.addModule(url)
-			);
+		if (!this._workletPromise) {
+			this._workletPromise = this.rawContext.audioWorklet.addModule(url);
 		}
-		await this._workletModules.get(name);
+		await this._workletPromise;
 	}
 
 	/**
 	 * Returns a promise which resolves when all of the worklets have been loaded on this context
 	 */
 	protected async workletsAreReady(): Promise<void> {
-		const promises: Promise<void>[] = [];
-		this._workletModules.forEach((promise) => promises.push(promise));
-		await Promise.all(promises);
+		await this._workletPromise ? this._workletPromise : Promise.resolve();
 	}
 
 	//---------------------------
@@ -391,8 +382,9 @@ export class Context extends BaseContext {
 	/**
 	 * How often the interval callback is invoked.
 	 * This number corresponds to how responsive the scheduling
-	 * can be. context.updateInterval + context.lookAhead gives you the
-	 * total latency between scheduling an event and hearing it.
+	 * can be. Setting to 0 will result in the lowest practial interval
+	 * based on context properties. context.updateInterval + context.lookAhead
+	 * gives you the total latency between scheduling an event and hearing it.
 	 */
 	get updateInterval(): Seconds {
 		return this._ticker.updateInterval;
@@ -412,6 +404,22 @@ export class Context extends BaseContext {
 		this._ticker.type = type;
 	}
 
+	/**
+	 * The amount of time into the future events are scheduled. Giving Web Audio
+	 * a short amount of time into the future to schedule events can reduce clicks and
+	 * improve performance. This value can be set to 0 to get the lowest latency.
+	 * Adjusting this value also affects the [[updateInterval]].
+	 */
+	get lookAhead(): Seconds {
+		return this._lookAhead;
+	}
+	set lookAhead(time: Seconds) {
+		this._lookAhead = time;
+		// if lookAhead is 0, default to .01 updateInterval
+		this.updateInterval = time ? (time / 2) : .01;
+	}	
+	private _lookAhead!: Seconds;
+
 	/**
 	 * The type of playback, which affects tradeoffs between audio
 	 * output latency and responsiveness.
@@ -431,29 +439,6 @@ export class Context extends BaseContext {
 		return this._latencyHint;
 	}
 
-	/**
-	 * Update the lookAhead and updateInterval based on the latencyHint
-	 */
-	private _setLatencyHint(hint: ContextLatencyHint | Seconds): void {
-		let lookAheadValue = 0;
-		this._latencyHint = hint;
-		if (isString(hint)) {
-			switch (hint) {
-				case "interactive":
-					lookAheadValue = 0.1;
-					break;
-				case "playback":
-					lookAheadValue = 0.5;
-					break;
-				case "balanced":
-					lookAheadValue = 0.25;
-					break;
-			}
-		}
-		this.lookAhead = lookAheadValue;
-		this.updateInterval = lookAheadValue / 2;
-	}
-
 	/**
 	 * The unwrapped AudioContext or OfflineAudioContext
 	 */
@@ -469,7 +454,7 @@ export class Context extends BaseContext {
 	 * }, 100);
 	 */
 	now(): Seconds {
-		return this._context.currentTime + this.lookAhead;
+		return this._context.currentTime + this._lookAhead;
 	}
 
 	/**

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

@@ -25,7 +25,7 @@ describe("DummyContext", () => {
 		context.decodeAudioData(new Float32Array(100));
 		context.createAudioWorkletNode("test.js");
 		context.rawContext;
-		context.addAudioWorkletModule("test.js", "test");
+		context.addAudioWorkletModule("test.js");
 		context.resume();
 		context.setTimeout(() => {}, 1);
 		context.clearTimeout(1);

package/Tone/core/context/DummyContext.ts

@@ -127,7 +127,7 @@ export class DummyContext extends BaseContext {
 		return {} as AnyAudioContext;
 	}
 
-	async addAudioWorkletModule(_url: string, _name: string): Promise<void> {
+	async addAudioWorkletModule(_url: string): Promise<void> {
 		return Promise.resolve();
 	}
 

package/Tone/core/context/ToneAudioBuffer.ts

@@ -1,7 +1,6 @@
 import { getContext } from "../Global";
 import { Tone } from "../Tone";
 import { Samples, Seconds } from "../type/Units";
-import { isAudioBuffer } from "../util/AdvancedTypeCheck";
 import { optionsFromArguments } from "../util/Defaults";
 import { noOp } from "../util/Interface";
 import { isArray, isNumber, isString } from "../util/TypeCheck";
@@ -25,7 +24,6 @@ interface ToneAudioBufferOptions {
  * @category Core
  */
 export class ToneAudioBuffer extends Tone {
-
 	readonly name: string = "ToneAudioBuffer";
 
 	/**
@@ -54,23 +52,26 @@ export class ToneAudioBuffer extends Tone {
 	constructor(
 		url?: string | ToneAudioBuffer | AudioBuffer,
 		onload?: (buffer: ToneAudioBuffer) => void,
-		onerror?: (error: Error) => void,
+		onerror?: (error: Error) => void
 	);
 	constructor(options?: Partial<ToneAudioBufferOptions>);
 	constructor() {
-
 		super();
 
-		const options = optionsFromArguments(ToneAudioBuffer.getDefaults(), arguments, ["url", "onload", "onerror"]);
+		const options = optionsFromArguments(
+			ToneAudioBuffer.getDefaults(),
+			arguments,
+			["url", "onload", "onerror"]
+		);
 
 		this.reverse = options.reverse;
 		this.onload = options.onload;
 
-		if (options.url && isAudioBuffer(options.url) || options.url instanceof ToneAudioBuffer) {
-			this.set(options.url);
-		} else if (isString(options.url)) {
+		if (isString(options.url)) {
 			// initiate the download
 			this.load(options.url).catch(options.onerror);
+		} else if (options.url) {
+			this.set(options.url);
 		}
 	}
 
@@ -132,11 +133,13 @@ export class ToneAudioBuffer extends Tone {
 	 * @returns A Promise which resolves with this ToneAudioBuffer
 	 */
 	async load(url: string): Promise<this> {
-		const doneLoading: Promise<void> = ToneAudioBuffer.load(url).then(audioBuffer => {
-			this.set(audioBuffer);
-			// invoke the onload method
-			this.onload(this);
-		});
+		const doneLoading: Promise<void> = ToneAudioBuffer.load(url).then(
+			(audioBuffer) => {
+				this.set(audioBuffer);
+				// invoke the onload method
+				this.onload(this);
+			}
+		);
 		ToneAudioBuffer.downloads.push(doneLoading);
 		try {
 			await doneLoading;
@@ -165,11 +168,15 @@ export class ToneAudioBuffer extends Tone {
 	fromArray(array: Float32Array | Float32Array[]): this {
 		const isMultidimensional = isArray(array) && array[0].length > 0;
 		const channels = isMultidimensional ? array.length : 1;
-		const len = isMultidimensional ? (array[0] as Float32Array).length : array.length;
+		const len = isMultidimensional
+			? (array[0] as Float32Array).length
+			: array.length;
 		const context = getContext();
 		const buffer = context.createBuffer(channels, len, context.sampleRate);
-		const multiChannelArray: Float32Array[] = !isMultidimensional && channels === 1 ?
-			[array as Float32Array] : array as Float32Array[];
+		const multiChannelArray: Float32Array[] =
+			!isMultidimensional && channels === 1
+				? [array as Float32Array]
+				: (array as Float32Array[]);
 
 		for (let c = 0; c < channels; c++) {
 			buffer.copyToChannel(multiChannelArray[c], c);
@@ -195,7 +202,7 @@ export class ToneAudioBuffer extends Tone {
 				}
 			}
 			// divide by the number of channels
-			outputArray = outputArray.map(sample => sample / numChannels);
+			outputArray = outputArray.map((sample) => sample / numChannels);
 			this.fromArray(outputArray);
 		}
 		return this;
@@ -243,11 +250,21 @@ export class ToneAudioBuffer extends Tone {
 		assert(this.loaded, "Buffer is not loaded");
 		const startSamples = Math.floor(start * this.sampleRate);
 		const endSamples = Math.floor(end * this.sampleRate);
-		assert(startSamples < endSamples, "The start time must be less than the end time");
+		assert(
+			startSamples < endSamples,
+			"The start time must be less than the end time"
+		);
 		const length = endSamples - startSamples;
-		const retBuffer = getContext().createBuffer(this.numberOfChannels, length, this.sampleRate);
+		const retBuffer = getContext().createBuffer(
+			this.numberOfChannels,
+			length,
+			this.sampleRate
+		);
 		for (let channel = 0; channel < this.numberOfChannels; channel++) {
-			retBuffer.copyToChannel(this.getChannelData(channel).subarray(startSamples, endSamples), channel);
+			retBuffer.copyToChannel(
+				this.getChannelData(channel).subarray(startSamples, endSamples),
+				channel
+			);
 		}
 		return new ToneAudioBuffer(retBuffer);
 	}
@@ -333,7 +350,7 @@ export class ToneAudioBuffer extends Tone {
 	 * @return A ToneAudioBuffer created from the array
 	 */
 	static fromArray(array: Float32Array | Float32Array[]): ToneAudioBuffer {
-		return (new ToneAudioBuffer()).fromArray(array);
+		return new ToneAudioBuffer().fromArray(array);
 	}
 
 	/**
@@ -355,7 +372,6 @@ export class ToneAudioBuffer extends Tone {
 	 * Loads a url using fetch and returns the AudioBuffer.
 	 */
 	static async load(url: string): Promise<AudioBuffer> {
-
 		// test if the url contains multiple extensions
 		const matches = url.match(/\[([^\]\[]+\|.+)\]$/);
 		if (matches) {
@@ -371,12 +387,19 @@ export class ToneAudioBuffer extends Tone {
 		}
 
 		// make sure there is a slash between the baseUrl and the url
-		const baseUrl = ToneAudioBuffer.baseUrl === "" || ToneAudioBuffer.baseUrl.endsWith("/") ? ToneAudioBuffer.baseUrl : ToneAudioBuffer.baseUrl + "/";
-		
+		const baseUrl =
+			ToneAudioBuffer.baseUrl === "" ||
+			ToneAudioBuffer.baseUrl.endsWith("/")
+				? ToneAudioBuffer.baseUrl
+				: ToneAudioBuffer.baseUrl + "/";
+
 		// encode special characters in file path
 		const location = document.createElement("a");
-		location.href = (baseUrl + url);
-		location.pathname = (location.pathname + location.hash).split("/").map(encodeURIComponent).join("/");
+		location.href = baseUrl + url;
+		location.pathname = (location.pathname + location.hash)
+			.split("/")
+			.map(encodeURIComponent)
+			.join("/");
 
 		const response = await fetch(location.href);
 		if (!response.ok) {
@@ -401,7 +424,9 @@ export class ToneAudioBuffer extends Tone {
 	static supportsType(url: string): boolean {
 		const extensions = url.split(".");
 		const extension = extensions[extensions.length - 1];
-		const response = document.createElement("audio").canPlayType("audio/" + extension);
+		const response = document
+			.createElement("audio")
+			.canPlayType("audio/" + extension);
 		return response !== "";
 	}
 

package/Tone/core/worklet/ToneAudioWorklet.ts

@@ -53,7 +53,7 @@ export abstract class ToneAudioWorklet<Options extends ToneAudioWorkletOptions>
 		this._dummyParam = this._dummyGain.gain;
 
 		// Register the processor
-		this.context.addAudioWorkletModule(blobUrl, name).then(() => {
+		this.context.addAudioWorkletModule(blobUrl).then(() => {
 			// create the worklet when it's read
 			if (!this.disposed) {
 				this._worklet = this.context.createAudioWorkletNode(name, this.workletOptions);

package/Tone/effect/BitCrusher.test.ts

@@ -1,4 +1,5 @@
 import { BitCrusher } from "./BitCrusher";
+import { FeedbackCombFilter } from "Tone/component/filter/FeedbackCombFilter";
 import { Oscillator } from "Tone/source/oscillator/Oscillator";
 import { BasicTests } from "test/helper/Basic";
 import { EffectTests } from "test/helper/EffectTests";
@@ -38,5 +39,20 @@ describe("BitCrusher", () => {
 			crusher.dispose();
 		});
 	});
+
+	it("should be usable with the FeedbackCombFilter", (done) => {
+		new BitCrusher(4);
+		new FeedbackCombFilter();
+
+		const handle = setTimeout(() => {
+			window.onunhandledrejection = null;
+			done();
+		}, 100);
+
+		window.onunhandledrejection = (event) => {
+			done(event.reason);
+			clearTimeout(handle);
+		};
+	});
 });
 

package/Tone/event/Pattern.test.ts

@@ -89,19 +89,21 @@ describe("Pattern", () => {
 		it("is invoked after it's started", () => {
 			let invoked = false;
 			return Offline(({ transport }) => {
+				const values = ["a", "b", "c"];
 				let index = 0;
 				const pattern = new Pattern((() => {
 					invoked = true;
-					expect(pattern.value).to.equal(index);
+					expect(pattern.value).to.equal(values[index]);
+					expect(pattern.index).to.equal(index);
 					index++;
-				}), [0, 1, 2]).start(0);
+				}), values).start(0);
 				transport.start();
 			}, 0.2).then(() => {
 				expect(invoked).to.be.true;
 			});
 		});
 
-		it("passes in the scheduled time and pattern index to the callback", () => {
+		it("passes in the scheduled time and pattern note to the callback", () => {
 			let invoked = false;
 			return Offline(({ transport }) => {
 				const startTime = 0.05;
@@ -109,6 +111,8 @@ describe("Pattern", () => {
 					expect(time).to.be.a("number");
 					expect(time - startTime).to.be.closeTo(0.3, 0.01);
 					expect(note).to.be.equal("a");
+					expect(pattern.value).to.equal("a");
+					expect(pattern.index).to.be.equal(0);
 					invoked = true;
 				}), ["a"], "up");
 				transport.start(startTime);
@@ -121,16 +125,38 @@ describe("Pattern", () => {
 		it("passes in the next note of the pattern", () => {
 			let counter = 0;
 			return Offline(({ transport }) => {
+				const values = ["a", "b", "c"];
 				const pattern = new Pattern(((time, note) => {
-					expect(note).to.equal(counter % 3);
+					expect(note).to.equal(values[counter % 3]);
+					expect(pattern.value).to.equal(values[counter % 3]);
+					expect(pattern.index).to.be.equal(counter % 3);
 					counter++;
-				}), [0, 1, 2], "up").start(0);
+				}), values, "up").start(0);
 				pattern.interval = "16n";
 				transport.start(0);
 			}, 0.7).then(() => {
 				expect(counter).to.equal(6);
 			});
 		});
+
+		it("can modify the pattern type and values", () => {
+			let counter = 0;
+			return Offline(({ transport }) => {
+				const values = ["a", "b", "c"];
+				const pattern = new Pattern(((time, note) => {
+					expect(note).to.equal(values[counter % 3]);
+					expect(pattern.value).to.equal(values[counter % 3]);
+					expect(pattern.index).to.be.equal(counter % 3);
+					counter++;
+				}), ["a"], "down").start(0);
+				pattern.interval = "16n";
+				pattern.pattern = "up";
+				pattern.values = values;
+				transport.start(0);
+			}, 0.7).then(() => {
+				expect(counter).to.equal(6);
+			});
+		});
 	});
 
 });