tone 15.5.2 → 15.5.4

package/Tone/core/util/TypeCheck.ts

@@ -3,7 +3,7 @@ import { Note } from "../type/Units.js";
 /**
  * Test if the arg is undefined
  */
-export function isUndef(arg: any): arg is undefined {
+export function isUndef(arg: unknown): arg is undefined {
 	return arg === undefined;
 }
 
@@ -17,45 +17,45 @@ export function isDefined<T>(arg: T | undefined): arg is T {
 /**
  * Test if the arg is a function
  */
-export function isFunction(arg: any): arg is (a: any) => any {
+export function isFunction(arg: unknown): arg is (a: any) => any {
 	return typeof arg === "function";
 }
 
 /**
  * Test if the argument is a number.
  */
-export function isNumber(arg: any): arg is number {
+export function isNumber(arg: unknown): arg is number {
 	return typeof arg === "number";
 }
 
 /**
  * Test if the given argument is an object literal (i.e. `{}`);
  */
-export function isObject(arg: any): arg is object {
+export function isObject(arg: unknown): arg is object {
 	return (
 		Object.prototype.toString.call(arg) === "[object Object]" &&
-		arg.constructor === Object
+		(arg as object).constructor === Object
 	);
 }
 
 /**
  * Test if the argument is a boolean.
  */
-export function isBoolean(arg: any): arg is boolean {
+export function isBoolean(arg: unknown): arg is boolean {
 	return typeof arg === "boolean";
 }
 
 /**
  * Test if the argument is an Array
  */
-export function isArray(arg: any): arg is any[] {
+export function isArray(arg: unknown): arg is any[] {
 	return Array.isArray(arg);
 }
 
 /**
  * Test if the argument is a string.
  */
-export function isString(arg: any): arg is string {
+export function isString(arg: unknown): arg is string {
 	return typeof arg === "string";
 }
 
@@ -63,6 +63,6 @@ export function isString(arg: any): arg is string {
  * Test if the argument is in the form of a note in scientific pitch notation.
  * e.g. "C4"
  */
-export function isNote(arg: any): arg is Note {
+export function isNote(arg: unknown): arg is Note {
 	return isString(arg) && /^([a-g]{1}(?:b|#|x|bb)?)(-?[0-9]+)/i.test(arg);
 }

package/Tone/source/UserMedia.test.ts

@@ -1,7 +1,11 @@
-import { expect } from "chai";
+import { expect, use } from "chai";
+import sinon from "sinon";
+import sinonChai from "sinon-chai";
+use(sinonChai);
 
 import { BasicTests } from "../../test/helper/Basic.js";
-import { OfflineContext } from "../core/index.js";
+import { Context } from "../core/context/Context.js";
+import { OfflineContext } from "../core/context/OfflineContext.js";
 import { UserMedia } from "./UserMedia.js";
 
 describe("UserMedia", () => {
@@ -37,139 +41,154 @@ describe("UserMedia", () => {
 		});
 	});
 
-	context("Opening and closing", function () {
-		// long timeout to give testers time to allow the microphone
-		this.timeout(100000);
-
-		let HAS_USER_MEDIA_INPUTS = false;
-
-		before(() => {
-			return UserMedia.enumerateDevices().then((devices) => {
-				HAS_USER_MEDIA_INPUTS = devices.length > 0;
-			});
+	context("Opening and closing", () => {
+		beforeEach(() => {
+			const mockTrack = { stop: sinon.stub() };
+			const mockStream = {
+				active: true,
+				getAudioTracks: () => [mockTrack],
+			} as unknown as MediaStream;
+			const mockMediaStreamSource = {
+				connect: sinon.stub(),
+				disconnect: sinon.stub(),
+				numberOfOutputs: 1,
+			} as unknown as MediaStreamAudioSourceNode;
+			sinon.stub(UserMedia, "enumerateDevices").resolves([
+				{
+					deviceId: "default",
+					groupId: "default",
+					label: "Default Device",
+				},
+				{
+					deviceId: "other",
+					groupId: "default",
+					label: "Other Device",
+				},
+			] as MediaDeviceInfo[]);
+			sinon
+				.stub(navigator.mediaDevices, "getUserMedia")
+				.resolves(mockStream);
+			sinon
+				.stub(Context.prototype, "createMediaStreamSource")
+				.returns(mockMediaStreamSource);
+		});
+
+		afterEach(() => {
+			sinon.restore();
+		});
+
+		it("open returns a promise", async () => {
+			const extIn = new UserMedia();
+			const promise = extIn.open();
+			expect(promise).to.be.instanceOf(Promise);
+			await promise;
+			extIn.dispose();
 		});
 
-		it("open returns a promise", () => {
-			if (HAS_USER_MEDIA_INPUTS) {
-				const extIn = new UserMedia();
-				const promise = extIn.open();
-				expect(promise).to.have.property("then");
-				return promise.then(() => {
-					extIn.dispose();
-				});
-			}
+		it("can open an input", async () => {
+			const extIn = new UserMedia();
+			await extIn.open();
+			extIn.dispose();
 		});
 
-		it("can open an input", () => {
-			if (HAS_USER_MEDIA_INPUTS) {
-				const extIn = new UserMedia();
-				return extIn.open().then(() => {
-					extIn.dispose();
-				});
-			}
+		it("can open an input by name", async () => {
+			const extIn = new UserMedia();
+			const devices = await UserMedia.enumerateDevices();
+			const name = devices[0].deviceId;
+
+			await extIn.open(name);
+
+			expect(extIn.deviceId).to.equal(name);
+			expect(navigator.mediaDevices.getUserMedia).to.have.been.calledWith(
+				sinon.match.hasNested("audio.deviceId", name)
+			);
+			extIn.dispose();
 		});
 
-		it("can open an input by name", () => {
-			if (HAS_USER_MEDIA_INPUTS) {
-				const extIn = new UserMedia();
-				let name: string;
-				return UserMedia.enumerateDevices()
-					.then((devices) => {
-						name = devices[0].deviceId;
-						return extIn.open(name);
-					})
-					.then(() => {
-						expect(extIn.deviceId).to.equal(name);
-						extIn.dispose();
-					});
-			}
+		it("can open an input by index", async () => {
+			const extIn = new UserMedia();
+
+			await extIn.open(0);
+
+			expect(navigator.mediaDevices.getUserMedia).to.have.been.calledWith(
+				sinon.match.hasNested("audio.deviceId", "default")
+			);
+			extIn.dispose();
 		});
 
-		it("can open an input by index", () => {
-			if (HAS_USER_MEDIA_INPUTS) {
-				const extIn = new UserMedia();
-				return extIn.open(0).then(() => {
-					extIn.dispose();
-				});
-			}
+		it("can pass in additional constraints", async () => {
+			const extIn = new UserMedia();
+			await extIn.open({
+				preferCurrentTab: true,
+			});
+			expect(navigator.mediaDevices.getUserMedia).to.have.been.calledWith(
+				sinon.match.hasNested("preferCurrentTab", true)
+			);
+			extIn.dispose();
 		});
 
-		it("throws an error if it cant find the device name", () => {
-			if (HAS_USER_MEDIA_INPUTS) {
-				const extIn = new UserMedia();
-				return extIn
-					.open("doesn't exist")
-					.then(() => {
-						throw new Error("shouldn't call 'then'");
-					})
-					.catch(() => {
-						extIn.dispose();
-					});
+		it("throws an error if it cant find the device name", async () => {
+			const extIn = new UserMedia();
+			try {
+				await extIn.open("doesn't exist");
+				throw new Error("shouldn't reach here");
+			} catch {
+				extIn.dispose();
 			}
 		});
 
-		it("is 'started' after media is open and 'stopped' otherwise", () => {
-			if (HAS_USER_MEDIA_INPUTS) {
-				const extIn = new UserMedia();
-				expect(extIn.state).to.equal("stopped");
-				return extIn.open().then(() => {
-					expect(extIn.state).to.equal("started");
-					extIn.dispose();
-				});
-			}
+		it("is 'started' after media is open and 'stopped' otherwise", async () => {
+			const extIn = new UserMedia();
+			expect(extIn.state).to.equal("stopped");
+
+			await extIn.open();
+
+			expect(extIn.state).to.equal("started");
+			extIn.dispose();
 		});
 
-		it("has a label, group and device id when open", () => {
-			if (HAS_USER_MEDIA_INPUTS) {
-				const extIn = new UserMedia();
-				return extIn.open().then(() => {
-					expect(extIn.deviceId).to.be.a("string");
-					expect(extIn.groupId).to.be.a("string");
-					expect(extIn.label).to.be.a("string");
-					extIn.dispose();
-				});
-			}
+		it("has a label, group and device id when open", async () => {
+			const extIn = new UserMedia();
+			expect(extIn.deviceId).to.be.undefined;
+			expect(extIn.groupId).to.be.undefined;
+			expect(extIn.label).to.be.undefined;
+
+			await extIn.open();
+
+			expect(extIn.deviceId).to.be.a("string");
+			expect(extIn.groupId).to.be.a("string");
+			expect(extIn.label).to.be.a("string");
+			extIn.dispose();
 		});
 
-		it("can reopen an input", () => {
-			if (HAS_USER_MEDIA_INPUTS) {
-				const extIn = new UserMedia();
-				return extIn
-					.open()
-					.then(() => {
-						return extIn.open();
-					})
-					.then(() => {
-						extIn.dispose();
-					});
-			}
+		it("can reopen an input", async () => {
+			const extIn = new UserMedia();
+			await extIn.open();
+			extIn.close();
+			await extIn.open();
+			extIn.dispose();
 		});
 
-		it("can close an input", () => {
-			if (HAS_USER_MEDIA_INPUTS) {
-				const extIn = new UserMedia();
-				return extIn.open().then(() => {
-					extIn.close();
-					extIn.dispose();
-				});
-			}
+		it("can close an input", async () => {
+			const extIn = new UserMedia();
+			await extIn.open();
+			extIn.close();
+			extIn.dispose();
 		});
 
-		it("can enumerate devices", () => {
-			return UserMedia.enumerateDevices().then((devices) => {
-				expect(devices).to.be.instanceOf(Array);
-			});
+		it("can enumerate devices", async () => {
+			const devices = await UserMedia.enumerateDevices();
+			expect(devices).to.be.instanceOf(Array);
 		});
 
-		it("doesn't work in OfflineContext", (done) => {
-			if (HAS_USER_MEDIA_INPUTS) {
-				const context = new OfflineContext(2, 2, 44100);
-				const extIn = new UserMedia({ context });
-				extIn.open().catch(() => {
-					done();
-				});
-			} else {
-				done();
+		it("doesn't work in OfflineContext", async () => {
+			const context = new OfflineContext(2, 2, 44100);
+			const extIn = new UserMedia({ context });
+			try {
+				await extIn.open();
+				throw new Error("shouldn't reach here");
+			} catch {
+				// expected to throw in OfflineContext
 			}
 		});
 	});

package/Tone/source/UserMedia.ts

@@ -8,9 +8,9 @@ import {
 } from "../core/context/ToneAudioNode.js";
 import { Decibels } from "../core/type/Units.js";
 import { assert } from "../core/util/Debug.js";
-import { optionsFromArguments } from "../core/util/Defaults.js";
+import { deepMerge, optionsFromArguments } from "../core/util/Defaults.js";
 import { readOnly } from "../core/util/Interface.js";
-import { isDefined, isNumber } from "../core/util/TypeCheck.js";
+import { isDefined, isNumber, isObject } from "../core/util/TypeCheck.js";
 
 export interface UserMediaOptions extends ToneAudioNodeOptions {
 	volume: Decibels;
@@ -100,43 +100,54 @@ export class UserMedia extends ToneAudioNode<UserMediaOptions> {
 	 * Open the media stream. If a string is passed in, it is assumed
 	 * to be the label or id of the stream, if a number is passed in,
 	 * it is the input number of the stream.
-	 * @param  labelOrId The label or id of the audio input media device.
-	 *                   With no argument, the default stream is opened.
+	 * @param  labelOrIdOrConstraints The label or id of the audio input media device, or a getUserMedia constraints object.
+	 *                   			  With no argument, the default stream is opened.
 	 * @return The promise is resolved when the stream is open.
 	 */
-	async open(labelOrId?: string | number): Promise<this> {
+	async open(
+		labelOrIdOrConstraints?: string | number | MediaStreamConstraints
+	): Promise<this> {
 		assert(UserMedia.supported, "UserMedia is not supported");
 		// close the previous stream
 		if (this.state === "started") {
 			this.close();
 		}
-		const devices = await UserMedia.enumerateDevices();
-		if (isNumber(labelOrId)) {
-			this._device = devices[labelOrId];
-		} else {
-			this._device = devices.find((device) => {
-				return (
-					device.label === labelOrId || device.deviceId === labelOrId
-				);
-			});
-			// didn't find a matching device
-			if (!this._device && devices.length > 0) {
-				this._device = devices[0];
-			}
-			assert(isDefined(this._device), `No matching device ${labelOrId}`);
-		}
-		// do getUserMedia
-		const constraints = {
+		let constraints: MediaStreamConstraints = {
 			audio: {
 				echoCancellation: false,
 				sampleRate: this.context.sampleRate,
 				noiseSuppression: false,
-				mozNoiseSuppression: false,
 			},
 		};
-		if (this._device) {
-			// @ts-ignore
-			constraints.audio.deviceId = this._device.deviceId;
+		if (isObject(labelOrIdOrConstraints)) {
+			// if the user passed in a constraints object
+			constraints = deepMerge(constraints, labelOrIdOrConstraints);
+		} else {
+			// if the user passed in a label or id
+			const devices = await UserMedia.enumerateDevices();
+			if (isNumber(labelOrIdOrConstraints)) {
+				this._device = devices[labelOrIdOrConstraints];
+			} else {
+				this._device = devices.find((device) => {
+					return (
+						device.label === labelOrIdOrConstraints ||
+						device.deviceId === labelOrIdOrConstraints
+					);
+				});
+				// didn't find a matching device
+				if (!this._device && devices.length > 0) {
+					this._device = devices[0];
+				}
+				assert(
+					isDefined(this._device),
+					`No matching device ${labelOrIdOrConstraints}`
+				);
+			}
+			// if there is a device, set the deviceId
+			if (this._device) {
+				// @ts-ignore
+				constraints.audio.deviceId = this._device.deviceId;
+			}
 		}
 		const stream = await navigator.mediaDevices.getUserMedia(constraints);
 		// start a new source only if the previous one is closed

package/Tone/source/oscillator/Oscillator.test.ts

@@ -19,9 +19,8 @@ describe("Oscillator", () => {
 	SourceTests(Oscillator);
 	OscillatorTests(Oscillator);
 
-	const sandbox = sinon.createSandbox();
 	afterEach(() => {
-		sandbox.restore();
+		sinon.restore();
 	});
 
 	it("matches a file", () => {
@@ -38,8 +37,8 @@ describe("Oscillator", () => {
 
 	it("cleans up connections after stopping", async () => {
 		const SignalPrototype = Signal.prototype;
-		const connectSpy = sandbox.spy(SignalPrototype, "connect");
-		const disconnectSpy = sandbox.spy(SignalPrototype, "disconnect");
+		const connectSpy = sinon.spy(SignalPrototype, "connect");
+		const disconnectSpy = sinon.spy(SignalPrototype, "disconnect");
 		await new Promise<void>((done) => {
 			const osc = new Oscillator({
 				onstop: () => done(),

package/Tone/version.ts

@@ -1 +1 @@
-export const version: string = "15.5.2";
+export const version: string = "15.5.4";