tone 15.5.20 → 15.5.22

package/Tone/core/Global.test.ts

@@ -0,0 +1,19 @@
+import { expect } from "chai";
+
+import { Context } from "./context/Context.js";
+import { getContext, setContext } from "./Global.js";
+
+describe("Global", () => {
+	it("can setContext with disposeOld = true", () => {
+		const origContext = getContext();
+		const toneContext = new Context();
+
+		setContext(toneContext);
+		expect(getContext()).to.equal(toneContext);
+
+		setContext(origContext, true);
+
+		expect(getContext()).to.equal(origContext);
+		expect(toneContext.disposed).to.be.true;
+	});
+});

package/Tone/core/Global.ts

@@ -1,39 +1,18 @@
 import { version } from "../version.js";
-import {
-	AnyAudioContext,
-	hasAudioContext,
-	theWindow,
-} from "./context/AudioContext.js";
+import { AnyAudioContext, theWindow } from "./context/AudioContext.js";
 import { BaseContext } from "./context/BaseContext.js";
 import { Context } from "./context/Context.js";
-import { DummyContext } from "./context/DummyContext.js";
+import {
+	getContext,
+	setContext as _setContext,
+} from "./context/GlobalContext.js";
 import { OfflineContext } from "./context/OfflineContext.js";
 import {
 	isAudioContext,
 	isOfflineAudioContext,
 } from "./util/AdvancedTypeCheck.js";
 
-/**
- * This dummy context is used to avoid throwing immediate errors when importing in Node.js
- */
-const dummyContext = new DummyContext();
-
-/**
- * The global audio context which is getable and assignable through
- * getContext and setContext
- */
-let globalContext: BaseContext = dummyContext;
-
-/**
- * Returns the default system-wide {@link Context}
- * @category Core
- */
-export function getContext(): BaseContext {
-	if (globalContext === dummyContext && hasAudioContext) {
-		setContext(new Context());
-	}
-	return globalContext;
-}
+export { getContext };
 
 /**
  * Set the default audio context
@@ -46,15 +25,15 @@ export function setContext(
 	disposeOld = false
 ): void {
 	if (disposeOld) {
-		globalContext.dispose();
+		getContext().dispose();
 	}
 
 	if (isAudioContext(context)) {
-		globalContext = new Context(context);
+		_setContext(new Context(context));
 	} else if (isOfflineAudioContext(context)) {
-		globalContext = new OfflineContext(context);
+		_setContext(new OfflineContext(context));
 	} else {
-		globalContext = context;
+		_setContext(context);
 	}
 }
 
@@ -72,7 +51,7 @@ export function setContext(
  * @category Core
  */
 export function start(): Promise<void> {
-	return globalContext.resume();
+	return getContext().resume();
 }
 
 /**

package/Tone/core/clock/TickSource.ts

@@ -444,7 +444,7 @@ export class TickSource<
 						Math.round(this.getTicksAtTime(nextTickTime))
 					);
 				} catch (e) {
-					error = e;
+					error = e as Error;
 					break;
 				}
 				nextTickTime += this.frequency.getDurationOfTicks(

package/Tone/core/clock/Transport.ts

@@ -236,7 +236,7 @@ export class TransportInstance
 	 * called on every tick
 	 * @param  tickTime clock relative tick time
 	 */
-	private _processTick(tickTime: Seconds, ticks: Ticks): void {
+	private _processTick(tickTime: Seconds, ticks: Ticks = 0): void {
 		// do the loop test
 		if (this._loop.get(tickTime)) {
 			if (ticks >= this._loopEnd) {

package/Tone/core/context/GlobalContext.ts

@@ -0,0 +1,34 @@
+import { hasAudioContext } from "./AudioContext.js";
+import { BaseContext } from "./BaseContext.js";
+import { Context } from "./Context.js";
+import { DummyContext } from "./DummyContext.js";
+
+/**
+ * This dummy context is used to avoid throwing immediate errors when importing in Node.js
+ */
+export const dummyContext: BaseContext = new DummyContext();
+
+/**
+ * The global audio context which is getable and assignable through
+ * getContext and setContext
+ */
+let globalContext: BaseContext = dummyContext;
+
+/**
+ * Returns the default system-wide {@link Context}.
+ * Auto-initializes a real Context in browser environments.
+ */
+export function getContext(): BaseContext {
+	if (globalContext === dummyContext && hasAudioContext) {
+		globalContext = new Context();
+	}
+	return globalContext;
+}
+
+/**
+ * Set the global context directly. Unlike the richer `setContext` in Global.ts,
+ * this only accepts a {@link BaseContext} — no native AudioContext wrapping.
+ */
+export function setContext(context: BaseContext): void {
+	globalContext = context;
+}

package/Tone/core/context/OfflineContext.ts

@@ -1,8 +1,8 @@
 import { createOfflineAudioContext } from "../context/AudioContext.js";
 import { Context } from "../context/Context.js";
-import { getContext, setContext } from "../Global.js";
 import { Seconds } from "../type/Units.js";
 import { isOfflineAudioContext } from "../util/AdvancedTypeCheck.js";
+import { getContext, setContext } from "./GlobalContext.js";
 import { ToneAudioBuffer } from "./ToneAudioBuffer.js";
 
 /**

package/Tone/core/context/ToneAudioBuffer.ts

@@ -1,10 +1,10 @@
-import { getContext } from "../Global.js";
 import { Tone } from "../Tone.js";
 import { Samples, Seconds } from "../type/Units.js";
 import { assert } from "../util/Debug.js";
 import { optionsFromArguments } from "../util/Defaults.js";
 import { noOp } from "../util/Interface.js";
 import { isArray, isNumber, isString } from "../util/TypeCheck.js";
+import { getContext } from "./GlobalContext.js";
 
 interface ToneAudioBufferOptions {
 	url?: string | AudioBuffer | ToneAudioBuffer;

package/Tone/core/type/Frequency.test.ts

@@ -128,9 +128,17 @@ describe("FrequencyClass", () => {
 		});
 
 		it("evaluates transport time", () => {
-			expect(Frequency("1:0").valueOf()).to.equal(0.5);
-			expect(Frequency("1:4:0").valueOf()).to.equal(0.25);
-			// expect(Frequency("2:1:0").valueOf()).to.equal(0.25);
+			return Offline(({ transport }) => {
+				transport.bpm.value = 120;
+				transport.timeSignature = 4;
+				expect(Frequency("1:0").valueOf()).to.equal(0.5);
+				expect(Frequency("2:0:0").valueOf()).to.equal(0.25);
+				expect(Frequency("1:1").valueOf()).to.be.closeTo(0.4, 0.0001);
+				expect(Frequency("1:0:2").valueOf()).to.be.closeTo(
+					120 / (60 * 4.5),
+					0.0001
+				);
+			});
 		});
 
 		it("evaluates midi", () => {

package/Tone/core/type/Frequency.ts

@@ -2,7 +2,12 @@ import { getContext } from "../Global.js";
 import { intervalToFrequencyRatio, mtof } from "./Conversions.js";
 import { ftom, getA4, setA4 } from "./Conversions.js";
 import { TimeClass } from "./Time.js";
-import { TimeBaseUnit, TimeExpression, TimeValue } from "./TimeBase.js";
+import {
+	TimeBaseClass,
+	TimeBaseUnit,
+	TimeExpression,
+	TimeValue,
+} from "./TimeBase.js";
 import {
 	Frequency,
 	Hertz,
@@ -51,17 +56,22 @@ export class FrequencyClass<Type extends number = Hertz> extends TimeClass<
 		return Object.assign({}, super._getExpressions(), {
 			midi: {
 				regexp: /^(\d+(?:\.\d+)?midi)/,
-				method(value): number {
+				method(this: TimeBaseClass<any, any>, value: string): number {
+					const numericValue = parseFloat(value);
 					if (this.defaultUnits === "midi") {
-						return value;
+						return numericValue;
 					} else {
-						return FrequencyClass.mtof(value);
+						return FrequencyClass.mtof(numericValue as MidiNote);
 					}
 				},
 			},
 			note: {
 				regexp: /^([a-g]{1}(?:b|#|##|x|bb|###|#x|x#|bbb)?)(-?[0-9]+)/i,
-				method(pitch, octave): number {
+				method(
+					this: TimeBaseClass<any, any>,
+					pitch: string,
+					octave: string
+				): number {
 					const index = noteToScaleIndex[pitch.toLowerCase()];
 					const noteNumber = index + (parseInt(octave, 10) + 1) * 12;
 					if (this.defaultUnits === "midi") {
@@ -73,20 +83,24 @@ export class FrequencyClass<Type extends number = Hertz> extends TimeClass<
 			},
 			tr: {
 				regexp: /^(\d+(?:\.\d+)?):(\d+(?:\.\d+)?):?(\d+(?:\.\d+)?)?/,
-				method(m, q, s): number {
-					let total = 1;
+				method(
+					this: TimeBaseClass<any, any>,
+					m: string,
+					q: string,
+					s: string
+				): number {
+					const self = this as FrequencyClass<any>;
+					let totalBeats = 0;
 					if (m && m !== "0") {
-						total *= this._beatsToUnits(
-							this._getTimeSignature() * parseFloat(m)
-						);
+						totalBeats += self._getTimeSignature() * parseFloat(m);
 					}
 					if (q && q !== "0") {
-						total *= this._beatsToUnits(parseFloat(q));
+						totalBeats += parseFloat(q);
 					}
 					if (s && s !== "0") {
-						total *= this._beatsToUnits(parseFloat(s) / 4);
+						totalBeats += parseFloat(s) / 4;
 					}
-					return total;
+					return self._beatsToUnits(totalBeats);
 				},
 			},
 		});

package/Tone/core/type/Midi.test.ts

@@ -68,6 +68,7 @@ describe("MidiClass", () => {
 
 		it("can convert from Midi", () => {
 			expect(Midi(Midi(2)).valueOf()).to.equal(2);
+			expect(Midi(60, "midi").valueOf()).to.equal(60);
 			expect(Midi(Midi("64n")).valueOf()).to.equal(24);
 			expect(Midi(Midi(64, "n")).valueOf()).to.equal(24);
 		});

package/Tone/core/type/TimeBase.ts

@@ -30,13 +30,21 @@ export type TimeBaseUnit =
 
 export interface TypeFunction {
 	regexp: RegExp;
-	method: (value: string, ...args: string[]) => number;
+	method: (
+		this: TimeBaseClass<any, any>,
+		value: string,
+		...args: string[]
+	) => number;
 }
 
 export interface TimeExpression<Type extends number> {
 	[key: string]: {
 		regexp: RegExp;
-		method: (value: string, ...args: string[]) => Type;
+		method: (
+			this: TimeBaseClass<any, any>,
+			value: string,
+			...args: string[]
+		) => Type;
 	};
 }
 
@@ -110,7 +118,7 @@ export abstract class TimeBaseClass<
 				regexp: /^(\d+)m$/i,
 			},
 			n: {
-				method: (value, dot) => {
+				method: (value: string, dot: string) => {
 					const numericValue = parseInt(value, 10);
 					const scalar = dot === "." ? 1.5 : 1;
 					if (numericValue === 1) {
@@ -155,7 +163,7 @@ export abstract class TimeBaseClass<
 				regexp: /^(\d+)t$/i,
 			},
 			tr: {
-				method: (m, q, s) => {
+				method: (m: string, q: string, s: string) => {
 					let total = 0;
 					if (m && m !== "0") {
 						total += this._beatsToUnits(
@@ -213,9 +221,12 @@ export abstract class TimeBaseClass<
 			const expr = this._expressions[this._units];
 			const matching = this._val.toString().trim().match(expr.regexp);
 			if (matching) {
-				return expr.method.apply(this, matching.slice(1));
+				return expr.method.apply(
+					this,
+					matching.slice(1) as [string, ...string[]]
+				);
 			} else {
-				return expr.method.call(this, this._val);
+				return expr.method.call(this, String(this._val));
 			}
 		} else if (isString(this._val)) {
 			return parseFloat(this._val) as Type;

package/Tone/core/worklet/ToneAudioWorklet.ts

@@ -6,8 +6,8 @@ import { noOp } from "../util/Interface.js";
 import { getWorkletGlobalScope } from "./WorkletGlobalScope.js";
 
 export interface ToneAudioWorkletOptions extends ToneAudioNodeOptions {
-	workletOptions?: Partial<AudioWorkletNodeOptions>
-};
+	workletOptions?: Partial<AudioWorkletNodeOptions>;
+}
 export abstract class ToneAudioWorklet<
 	Options extends ToneAudioWorkletOptions,
 > extends ToneAudioNode<Options> {
@@ -65,7 +65,8 @@ export abstract class ToneAudioWorklet<
 		);
 
 		if (options.workletOptions) {
-			this.workletOptions = Object.assign({},
+			this.workletOptions = Object.assign(
+				{},
 				this.workletOptions,
 				options.workletOptions
 			);
@@ -84,8 +85,8 @@ export abstract class ToneAudioWorklet<
 					name,
 					this.workletOptions
 				);
-				this._worklet.onprocessorerror =
-					this.onprocessorerror.bind(this);
+				this._worklet.onprocessorerror = (e) =>
+					this.onprocessorerror((e as ErrorEvent).message);
 				this.onReady(this._worklet);
 			}
 		});

package/Tone/signal/SyncedSignal.ts

@@ -43,7 +43,7 @@ export class SyncedSignal<
 	/**
 	 * Remember the callback value
 	 */
-	private _syncedCallback: () => void;
+	private _syncedCallback: (time: Seconds) => void;
 
 	/**
 	 * @param value Initial value of the signal

package/Tone/source/OneShotSource.ts

@@ -217,7 +217,7 @@ export abstract class OneShotSource<
 	/**
 	 * Get the playback state at the given time
 	 */
-	getStateAtTime = function (time: Time): BasicPlaybackState {
+	getStateAtTime = (time: Time): BasicPlaybackState => {
 		const computedTime = this.toSeconds(time);
 		if (
 			this._startTime !== -1 &&

package/Tone/source/buffer/Player.ts

@@ -8,6 +8,7 @@ import { noOp } from "../../core/util/Interface.js";
 import { Timeline } from "../../core/util/Timeline.js";
 import { isUndef } from "../../core/util/TypeCheck.js";
 import { ToneConstantSource } from "../../signal/ToneConstantSource.js";
+import { OneShotSource } from "../OneShotSource.js";
 import { Source, SourceOptions } from "../Source.js";
 import { ToneBufferSource } from "./ToneBufferSource.js";
 
@@ -231,12 +232,12 @@ export class Player extends Source<PlayerOptions> {
 	/**
 	 * Internal callback when the buffer is done playing.
 	 */
-	private _onSourceEnd(source: ToneBufferSource): void {
+	private _onSourceEnd(source: OneShotSource<any>): void {
 		// invoke the onstop function
 		this.onstop(this);
 
 		// delete the source from the active sources
-		this._activeSources.delete(source);
+		this._activeSources.delete(source as ToneBufferSource);
 		if (
 			this._activeSources.size === 0 &&
 			!this._synced &&

package/Tone/version.ts

@@ -1 +1 @@
-export const version: string = "15.5.20";
+export const version: string = "15.5.22";