tone 15.5.21 → 15.5.23

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/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.21";
+export const version: string = "15.5.23";