tone 14.8.29 → 14.8.33

package/Tone/instrument/NoiseSynth.ts

@@ -4,7 +4,10 @@ import { omitFromObject, optionsFromArguments } from "../core/util/Defaults";
 import { RecursivePartial } from "../core/util/Interface";
 import { Noise, NoiseOptions } from "../source/Noise";
 import { Instrument, InstrumentOptions } from "./Instrument";
-import { ToneAudioNode, ToneAudioNodeOptions } from "../core/context/ToneAudioNode";
+import {
+	ToneAudioNode,
+	ToneAudioNodeOptions,
+} from "../core/context/ToneAudioNode";
 import { Envelope, EnvelopeOptions } from "../component/envelope/Envelope";
 import { Source } from "../source/Source";
 
@@ -14,7 +17,7 @@ export interface NoiseSynthOptions extends InstrumentOptions {
 }
 
 /**
- * Tone.NoiseSynth is composed of [[Noise]] through an [[AmplitudeEnvelope]]. 
+ * Tone.NoiseSynth is composed of [[Noise]] through an [[AmplitudeEnvelope]].
  * ```
  * +-------+   +-------------------+
  * | Noise +>--> AmplitudeEnvelope +>--> Output
@@ -26,7 +29,6 @@ export interface NoiseSynthOptions extends InstrumentOptions {
  * @category Instrument
  */
 export class NoiseSynth extends Instrument<NoiseSynthOptions> {
-
 	readonly name = "NoiseSynth";
 
 	/**
@@ -39,17 +41,30 @@ export class NoiseSynth extends Instrument<NoiseSynthOptions> {
 	 */
 	readonly envelope: AmplitudeEnvelope;
 
-	constructor(options?: RecursivePartial<NoiseSynthOptions>)
+	constructor(options?: RecursivePartial<NoiseSynthOptions>);
 	constructor() {
 		super(optionsFromArguments(NoiseSynth.getDefaults(), arguments));
-		const options = optionsFromArguments(NoiseSynth.getDefaults(), arguments);
-		this.noise = new Noise(Object.assign({
-			context: this.context,
-		}, options.noise));
+		const options = optionsFromArguments(
+			NoiseSynth.getDefaults(),
+			arguments
+		);
+		this.noise = new Noise(
+			Object.assign(
+				{
+					context: this.context,
+				},
+				options.noise
+			)
+		);
 
-		this.envelope = new AmplitudeEnvelope(Object.assign({
-			context: this.context,
-		}, options.envelope));
+		this.envelope = new AmplitudeEnvelope(
+			Object.assign(
+				{
+					context: this.context,
+				},
+				options.envelope
+			)
+		);
 
 		// connect the noise to the output
 		this.noise.chain(this.envelope, this.output);
@@ -58,17 +73,23 @@ export class NoiseSynth extends Instrument<NoiseSynthOptions> {
 	static getDefaults(): NoiseSynthOptions {
 		return Object.assign(Instrument.getDefaults(), {
 			envelope: Object.assign(
-				omitFromObject(Envelope.getDefaults(), Object.keys(ToneAudioNode.getDefaults())),
+				omitFromObject(
+					Envelope.getDefaults(),
+					Object.keys(ToneAudioNode.getDefaults())
+				),
 				{
 					decay: 0.1,
 					sustain: 0.0,
-				},
+				}
 			),
 			noise: Object.assign(
-				omitFromObject(Noise.getDefaults(), Object.keys(Source.getDefaults())),
+				omitFromObject(
+					Noise.getDefaults(),
+					Object.keys(Source.getDefaults())
+				),
 				{
 					type: "white",
-				},
+				}
 			),
 		});
 	}
@@ -87,7 +108,11 @@ export class NoiseSynth extends Instrument<NoiseSynthOptions> {
 		// start the noise
 		this.noise.start(time);
 		if (this.envelope.sustain === 0) {
-			this.noise.stop(time + this.toSeconds(this.envelope.attack) + this.toSeconds(this.envelope.decay));
+			this.noise.stop(
+				time +
+					this.toSeconds(this.envelope.attack) +
+					this.toSeconds(this.envelope.decay)
+			);
 		}
 		return this;
 	}
@@ -110,7 +135,21 @@ export class NoiseSynth extends Instrument<NoiseSynthOptions> {
 		return this;
 	}
 
-	triggerAttackRelease(duration: Time, time?: Time, velocity: NormalRange = 1): this {
+	/**
+	 * Trigger the attack and then the release after the duration.
+	 * @param duration The amount of time to hold the note for
+	 * @param time The time the note should start
+	 * @param velocity The volume of the note (0-1)
+	 * @example
+	 * const noiseSynth = new Tone.NoiseSynth().toDestination();
+	 * // hold the note for 0.5 seconds
+	 * noiseSynth.triggerAttackRelease(0.5);
+	 */
+	triggerAttackRelease(
+		duration: Time,
+		time?: Time,
+		velocity: NormalRange = 1
+	): this {
 		time = this.toSeconds(time);
 		duration = this.toSeconds(duration);
 		this.triggerAttack(time, velocity);

package/Tone/instrument/PolySynth.test.ts

@@ -135,23 +135,6 @@ describe("PolySynth", () => {
 			});
 		});
 
-		it("can be synced to the transport", () => {
-			return Offline(({ transport }) => {
-				const polySynth = new PolySynth(Synth, {
-					envelope: {
-						release: 0.1,
-					},
-				}).sync();
-				polySynth.toDestination();
-				polySynth.triggerAttackRelease("C4", 0.1, 0.1);
-				polySynth.triggerAttackRelease("E4", 0.1, 0.3);
-				transport.start(0.1);
-			}, 0.8).then((buffer) => {
-				expect(buffer.getTimeOfFirstSound()).to.be.closeTo(0.2, 0.01);
-				expect(buffer.getTimeOfLastSound()).to.be.closeTo(0.6, 0.01);
-			});
-		});
-
 		it("disposes voices when they are no longer used", () => {
 			return Offline(() => {
 				const polySynth = new PolySynth(Synth, {
@@ -266,6 +249,86 @@ describe("PolySynth", () => {
 
 	});
 
+	context("Transport sync", () => {
+		it("can be synced to the transport", () => {
+			return Offline(({ transport }) => {
+				const polySynth = new PolySynth(Synth, {
+					envelope: {
+						release: 0.1,
+					},
+				}).sync();
+				polySynth.toDestination();
+				polySynth.triggerAttackRelease("C4", 0.1, 0.1);
+				polySynth.triggerAttackRelease("E4", 0.1, 0.3);
+				transport.start(0.1);
+			}, 0.8).then((buffer) => {
+				expect(buffer.getTimeOfFirstSound()).to.be.closeTo(0.2, 0.01);
+				expect(buffer.getTimeOfLastSound()).to.be.closeTo(0.6, 0.01);
+			});
+		});
+
+		it("is silent until the transport is started", () => {
+			return Offline(({ transport }) => {
+				const synth = new PolySynth(Synth).sync().toDestination();
+				synth.triggerAttackRelease("C4", 0.5);
+				transport.start(0.5);
+			}, 1).then((buffer) => {
+				expect(buffer.getTimeOfFirstSound()).is.closeTo(0.5, 0.1);
+			});
+		});
+
+		it("stops when the transport is stopped", () => {
+			return Offline(({ transport }) => {
+				const synth = new PolySynth(Synth, {
+					envelope: {
+						release: 0
+					}
+				}).sync().toDestination();
+				synth.triggerAttackRelease("C4", 0.5);
+				transport.start(0.5).stop(1);
+			}, 1.5).then((buffer) => {
+				expect(buffer.getTimeOfLastSound()).is.closeTo(1, 0.1);
+			});
+		});
+
+		it("goes silent at the loop boundary", () => {
+			return Offline(({ transport }) => {
+				const synth = new PolySynth(Synth, {
+					envelope: {
+						release: 0
+					}
+				}).sync().toDestination();
+				synth.triggerAttackRelease("C4", 0.8, 0.5);
+				transport.loopEnd = 1;
+				transport.loop = true;
+				transport.start();
+			}, 2).then((buffer) => {
+				expect(buffer.getRmsAtTime(0)).to.be.closeTo(0, 0.05);
+				expect(buffer.getRmsAtTime(0.6)).to.be.closeTo(0.2, 0.05);
+				expect(buffer.getRmsAtTime(1.1)).to.be.closeTo(0, 0.05);
+				expect(buffer.getRmsAtTime(1.6)).to.be.closeTo(0.2, 0.05);
+			});
+		});
+
+		it("can unsync", () => {
+			return Offline(({ transport }) => {
+				const synth = new PolySynth(Synth, {
+					envelope: {
+						sustain: 1,
+						release: 0
+					}
+				}).sync().toDestination().unsync();
+				synth.triggerAttackRelease("C4", 1, 0.5);
+				transport.start().stop(1);
+			}, 2).then((buffer) => {
+				expect(buffer.getRmsAtTime(0)).to.be.closeTo(0, 0.05);
+				expect(buffer.getRmsAtTime(0.6)).to.be.closeTo(0.6, 0.05);
+				expect(buffer.getRmsAtTime(1.4)).to.be.closeTo(0.6, 0.05);
+				expect(buffer.getRmsAtTime(1.6)).to.be.closeTo(0, 0.05);
+			});
+		});
+	});
+
 	context("API", () => {
 
 		it("can be constructed with an options object", () => {
@@ -282,7 +345,7 @@ describe("PolySynth", () => {
 			expect(() => {
 				// @ts-ignore
 				new PolySynth(PluckSynth);
-			}).throws(Error)
+			}).throws(Error);
 		});
 
 		it("can pass in the volume", () => {

package/Tone/instrument/PolySynth.ts

@@ -341,10 +341,20 @@ export class PolySynth<Voice extends Monophonic<any> = Synth> extends Instrument
 		if (this._syncState()) {
 			this._syncMethod("triggerAttack", 1);
 			this._syncMethod("triggerRelease", 1);
+
+			// make sure that the sound doesn't play after its been stopped
+			this.context.transport.on("stop", this._syncedRelease);
+			this.context.transport.on("pause", this._syncedRelease);
+			this.context.transport.on("loopEnd", this._syncedRelease);
 		}
 		return this;
 	}
 
+	/**
+	 * The release which is scheduled to the timeline. 
+	 */
+	 protected _syncedRelease = (time: number) => this.releaseAll(time);
+
 	/**
 	 * Set a member/attribute of the voices
 	 * @example
@@ -382,7 +392,7 @@ export class PolySynth<Voice extends Monophonic<any> = Synth> extends Instrument
 		});
 		return this;
 	}
-
+	
 	dispose(): this {
 		super.dispose();
 		this._dummyVoice.dispose();

package/Tone/instrument/Sampler.test.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/camelcase */
 import { expect } from "chai";
 import { BasicTests } from "test/helper/Basic";
 import { CompareToFile } from "test/helper/CompareToFile";

package/Tone/instrument/Sampler.ts

@@ -138,7 +138,7 @@ export class Sampler extends Instrument<SamplerOptions> {
 		return Object.assign(Instrument.getDefaults(), {
 			attack: 0,
 			baseUrl: "",
-			curve: "exponential" as "exponential",
+			curve: "exponential" as const,
 			onload: noOp,
 			onerror: noOp,
 			release: 0.1,

package/Tone/instrument/Synth.test.ts

@@ -106,6 +106,69 @@ describe("Synth", () => {
 		});
 	});
 
+	context("Transport sync", () => {
+		it("is silent until the transport is started", () => {
+			return Offline(({ transport }) => {
+				const synth = new Synth().sync().toDestination();
+				synth.triggerAttackRelease("C4", 0.5);
+				transport.start(0.5);
+			}, 1).then((buffer) => {
+				expect(buffer.getTimeOfFirstSound()).is.closeTo(0.5, 0.1);
+			});
+		});
+
+		it("stops when the transport is stopped", () => {
+			return Offline(({ transport }) => {
+				const synth = new Synth({
+					envelope: {
+						release: 0
+					}
+				}).sync().toDestination();
+				synth.triggerAttackRelease("C4", 0.5);
+				transport.start(0.5).stop(1);
+			}, 1.5).then((buffer) => {
+				expect(buffer.getTimeOfLastSound()).is.closeTo(1, 0.1);
+			});
+		});
+
+		it("goes silent at the loop boundary", () => {
+			return Offline(({ transport }) => {
+				const synth = new Synth({
+					envelope: {
+						release: 0
+					}
+				}).sync().toDestination();
+				synth.triggerAttackRelease("C4", 0.8, 0.5);
+				transport.loopEnd = 1;
+				transport.loop = true;
+				transport.start();
+			}, 2).then((buffer) => {
+				expect(buffer.getRmsAtTime(0)).to.be.closeTo(0, 0.05);
+				expect(buffer.getRmsAtTime(0.6)).to.be.closeTo(0.2, 0.05);
+				expect(buffer.getRmsAtTime(1.1)).to.be.closeTo(0, 0.05);
+				expect(buffer.getRmsAtTime(1.6)).to.be.closeTo(0.2, 0.05);
+			});
+		});
+
+		it("can unsync", () => {
+			return Offline(({ transport }) => {
+				const synth = new Synth({
+					envelope: {
+						sustain: 1,
+						release: 0
+					}
+				}).sync().toDestination().unsync();
+				synth.triggerAttackRelease("C4", 1, 0.5);
+				transport.start().stop(1);
+			}, 2).then((buffer) => {
+				expect(buffer.getRmsAtTime(0)).to.be.closeTo(0, 0.05);
+				expect(buffer.getRmsAtTime(0.6)).to.be.closeTo(0.6, 0.05);
+				expect(buffer.getRmsAtTime(1.4)).to.be.closeTo(0.6, 0.05);
+				expect(buffer.getRmsAtTime(1.6)).to.be.closeTo(0, 0.05);
+			});
+		});
+	});
+
 	context("Portamento", () => {
 		it("can play notes with a portamento", () => {
 			return Offline(() => {

package/Tone/source/oscillator/PWMOscillator.ts

@@ -106,7 +106,7 @@ export class PWMOscillator extends Source<PWMOscillatorOptions> implements ToneO
 			frequency: 440,
 			modulationFrequency: 0.4,
 			phase: 0,
-			type: "pwm" as "pwm",
+			type: "pwm" as const,
 		});
 	}
 	/**

package/Tone/source/oscillator/PulseOscillator.ts

@@ -128,7 +128,7 @@ export class PulseOscillator extends Source<PulseOscillatorOptions> implements T
 			detune: 0,
 			frequency: 440,
 			phase: 0,
-			type: "pulse" as "pulse",
+			type: "pulse" as const,
 			width: 0.2,
 		});
 	}

package/Tone/version.ts

@@ -1 +1 @@
-export const version: string = "14.8.29";
+export const version: string = "14.8.33";