tone 15.5.56 → 15.5.58

package/Tone/event/PatternGenerator.test.ts

@@ -99,5 +99,23 @@ describe("PatternGenerator", () => {
 				currentIndex = nextIndex;
 			}
 		});
+
+		it("never randomly walks outside of the range of values", () => {
+			[1, 2, 3, 4].forEach((numValues) => {
+				const pattern = PatternGenerator(numValues, "randomWalk");
+				for (let i = 0; i < 100; i++) {
+					expect(pattern.next().value)
+						.to.be.at.least(0)
+						.and.at.most(numValues - 1);
+				}
+			});
+		});
+
+		it("randomly walks in place when there is only one value", () => {
+			const pattern = PatternGenerator(1, "randomWalk");
+			expect(getArrayValues(pattern, 10)).to.deep.equal([
+				0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+			]);
+		});
 	});
 });

package/Tone/event/PatternGenerator.ts

@@ -138,6 +138,11 @@ function* randomWalk(numValues: number): IterableIterator<number> {
 	// randomly choose a starting index
 	let index = Math.floor(Math.random() * numValues);
 	while (true) {
+		// with a single value there is nowhere to step to
+		if (numValues === 1) {
+			yield index;
+			continue;
+		}
 		if (index === 0) {
 			index++; // at bottom, so force upward step
 		} else if (index === numValues - 1) {

package/Tone/instrument/Sampler.test.ts

@@ -88,6 +88,27 @@ describe("Sampler", () => {
 			expect(buffer.isSilent()).to.be.false;
 		});
 
+		it("get() reports back the urls, baseUrl, onload and onerror it was constructed with", () => {
+			const onload = () => {};
+			const onerror = () => {};
+			const sampler = new Sampler({
+				urls: {
+					69: A4_buffer,
+				},
+				baseUrl: "./test/audio/",
+				onload,
+				onerror,
+			});
+			const options = sampler.get();
+			expect(options.urls).to.deep.equal({
+				69: A4_buffer,
+			});
+			expect(options.baseUrl).to.equal("./test/audio/");
+			expect(options.onload).to.equal(onload);
+			expect(options.onerror).to.equal(onerror);
+			sampler.dispose();
+		});
+
 		it("throws an error if there are no available notes to play", () => {
 			expect(() => {
 				const sampler = new Sampler();

package/Tone/instrument/Sampler.ts

@@ -34,9 +34,9 @@ export interface SamplerOptions extends InstrumentOptions {
 	baseUrl: string;
 	curve: ToneBufferSourceCurve;
 	urls: SamplesMap;
-    loop: boolean;
-    loopEnd: number;
-    loopStart: number;
+	loop: boolean;
+	loopEnd: number;
+	loopStart: number;
 }
 
 /**
@@ -73,14 +73,14 @@ export class Sampler extends Instrument<SamplerOptions> {
 	 */
 	private _activeSources: Map<MidiNote, ToneBufferSource[]> = new Map();
 
-    /** 
-     * The list of all provided midi notes
-     */
-    private _providedMidiNotes: MidiNote[] = [];
+	/**
+	 * The list of all provided midi notes
+	 */
+	private _providedMidiNotes: MidiNote[] = [];
 
-    /**
-     * if the buffer should loop once its over
-     */
+	/**
+	 * if the buffer should loop once its over
+	 */
 	private _loop: boolean;
 
 	/**
@@ -115,6 +115,26 @@ export class Sampler extends Instrument<SamplerOptions> {
 	 */
 	curve: ToneBufferSourceCurve;
 
+	/**
+	 * The urls passed in the constructor, kept so `get()` can report them back.
+	 */
+	private _urls: SamplesMap;
+
+	/**
+	 * The baseUrl passed in the constructor, kept so `get()` can report it back.
+	 */
+	private _baseUrl: string;
+
+	/**
+	 * The onload callback passed in the constructor, kept so `get()` can report it back.
+	 */
+	private _onload: () => void;
+
+	/**
+	 * The onerror callback passed in the constructor, kept so `get()` can report it back.
+	 */
+	private _onerror: (error: Error) => void;
+
 	/**
 	 * @param samples An object of samples mapping either Midi Note Numbers or
 	 * 			Scientific Pitch Notation to the url of that sample.
@@ -167,9 +187,13 @@ export class Sampler extends Instrument<SamplerOptions> {
 		this.attack = options.attack;
 		this.release = options.release;
 		this.curve = options.curve;
-        this._loop = options.loop;
-        this._loopStart = options.loopStart;
-        this._loopEnd = options.loopEnd;
+		this._urls = options.urls;
+		this._baseUrl = options.baseUrl;
+		this._onload = options.onload;
+		this._onerror = options.onerror;
+		this._loop = options.loop;
+		this._loopStart = options.loopStart;
+		this._loopEnd = options.loopEnd;
 
 		// invoke the callback if it's already loaded
 		if (this._buffers.loaded) {
@@ -187,9 +211,23 @@ export class Sampler extends Instrument<SamplerOptions> {
 			onerror: noOp,
 			release: 0.1,
 			urls: {},
-            loop: false,
-            loopEnd: 0,
-            loopStart: 0,
+			loop: false,
+			loopEnd: 0,
+			loopStart: 0,
+		});
+	}
+
+	/**
+	 * urls, baseUrl, onload and onerror aren't stored as regular class
+	 * properties (unlike attack/release/curve), so the base implementation
+	 * can't find them via `Reflect.has` and they'd be silently missing here.
+	 */
+	get(): SamplerOptions {
+		return Object.assign(super.get(), {
+			urls: this._urls,
+			baseUrl: this._baseUrl,
+			onload: this._onload,
+			onerror: this._onerror,
 		});
 	}
 
@@ -226,7 +264,7 @@ export class Sampler extends Instrument<SamplerOptions> {
 		if (!Array.isArray(notes)) {
 			notes = [notes];
 		}
-        const offset = defaultArg(this._loopStart, 0);
+		const offset = defaultArg(this._loopStart, 0);
 		notes.forEach((note) => {
 			const midiFloat = ftomf(
 				new FrequencyClass(this.context, note).toFrequency()
@@ -240,9 +278,9 @@ export class Sampler extends Instrument<SamplerOptions> {
 			const playbackRate = intervalToFrequencyRatio(
 				difference + remainder
 			);
-            const duration = this._loop 
-                ? undefined
-                : buffer.duration / playbackRate;
+			const duration = this._loop
+				? undefined
+				: buffer.duration / playbackRate;
 			// play that note
 			const source = new ToneBufferSource({
 				url: buffer,
@@ -250,9 +288,9 @@ export class Sampler extends Instrument<SamplerOptions> {
 				curve: this.curve,
 				fadeIn: this.attack,
 				fadeOut: this.release,
-                loop: this._loop,
-                loopStart: this._loopStart,
-                loopEnd: this._loopEnd,
+				loop: this._loop,
+				loopStart: this._loopStart,
+				loopEnd: this._loopEnd,
 				playbackRate,
 			}).connect(this.output);
 			source.start(time, offset, duration, velocity);
@@ -393,98 +431,97 @@ export class Sampler extends Instrument<SamplerOptions> {
 		return this._buffers.loaded;
 	}
 
-    /**
-     * Set the loop start and end. Will only loop if loop is set to true.
-     * @param loopStart The loop start time
-     * @param loopEnd The loop end time
-     * @example
-     * const sampler = new Tone.Sampler({
-     *      urls: {  
-     *           A1: "https://tonejs.github.io/audio/berklee/guitar_chord4.mp3",  
-     *      },
-     * }).toDestination();
-     * // loop between the given points
-     * sampler.setLoopPoints(0.2, 0.3);
-     * sampler.loop = true;
-     */
-    setLoopPoints(loopStart: Time, loopEnd: Time): this {
-        this.loopStart = loopStart;
-        this.loopEnd = loopEnd;
-        return this;
-    }
-
-    /**
-     * If loop is true, the loop will start at this position.
-     */
-    get loopStart(): Time {
-        return this._loopStart;
-    }
-    set loopStart(loopStart) {
-        this._loopStart = loopStart;
-        this._providedMidiNotes.forEach((midiNote) => {
-            const buffer = this._buffers.get(midiNote);
-            if (buffer.loaded) {
-                assertRange(this.toSeconds(loopStart), 0, buffer.duration);
-            }
-        });
-        // get the current sources
-        this._activeSources.forEach((sourceList) => {
-            sourceList.forEach((source) => {
-                source.loopStart = loopStart;
-            });
-        });
-    }
-
-    /**
-     * If loop is true, the loop will end at this position.
-     */
-    get loopEnd(): Time {
-        return this._loopEnd;
-    }
-    set loopEnd(loopEnd) {
-        this._loopEnd = loopEnd;
-        this._providedMidiNotes.forEach((midiNote) => {
-            const buffer = this._buffers.get(midiNote);
-            if (buffer.loaded) {
-                assertRange(this.toSeconds(loopEnd), 0, buffer.duration);
-            }
-        });
-        // get the current sources
-        this._activeSources.forEach((sourceList) => {
-            sourceList.forEach((source) => {
-                source.loopEnd = loopEnd;
-            });
-        });
-    }
-
-
-    /**
-     * If the buffers should loop once they are over.
-     * @example
-     * const sampler = new Tone.Sampler({
-     *      urls: {  
-     *           A4: "https://tonejs.github.io/audio/berklee/femalevoice_aa_A4.mp3",  
-     *      },
-     * }).toDestination();
-     * sampler.loop = true;
-     */
-    get loop(): boolean {
-        return this._loop;
-    }
-    set loop(loop) {
-        // if no change, do nothing
-        if (this._loop === loop) {
-            return;
-        }
-        this._loop = loop;
-        // set the loop of all of the sources
-        this._activeSources.forEach((sourceList) => {
-            sourceList.forEach((source) => {
-                source.loop = loop;
-            });
-        });
-    }
-    
+	/**
+	 * Set the loop start and end. Will only loop if loop is set to true.
+	 * @param loopStart The loop start time
+	 * @param loopEnd The loop end time
+	 * @example
+	 * const sampler = new Tone.Sampler({
+	 *      urls: {
+	 *           A1: "https://tonejs.github.io/audio/berklee/guitar_chord4.mp3",
+	 *      },
+	 * }).toDestination();
+	 * // loop between the given points
+	 * sampler.setLoopPoints(0.2, 0.3);
+	 * sampler.loop = true;
+	 */
+	setLoopPoints(loopStart: Time, loopEnd: Time): this {
+		this.loopStart = loopStart;
+		this.loopEnd = loopEnd;
+		return this;
+	}
+
+	/**
+	 * If loop is true, the loop will start at this position.
+	 */
+	get loopStart(): Time {
+		return this._loopStart;
+	}
+	set loopStart(loopStart) {
+		this._loopStart = loopStart;
+		this._providedMidiNotes.forEach((midiNote) => {
+			const buffer = this._buffers.get(midiNote);
+			if (buffer.loaded) {
+				assertRange(this.toSeconds(loopStart), 0, buffer.duration);
+			}
+		});
+		// get the current sources
+		this._activeSources.forEach((sourceList) => {
+			sourceList.forEach((source) => {
+				source.loopStart = loopStart;
+			});
+		});
+	}
+
+	/**
+	 * If loop is true, the loop will end at this position.
+	 */
+	get loopEnd(): Time {
+		return this._loopEnd;
+	}
+	set loopEnd(loopEnd) {
+		this._loopEnd = loopEnd;
+		this._providedMidiNotes.forEach((midiNote) => {
+			const buffer = this._buffers.get(midiNote);
+			if (buffer.loaded) {
+				assertRange(this.toSeconds(loopEnd), 0, buffer.duration);
+			}
+		});
+		// get the current sources
+		this._activeSources.forEach((sourceList) => {
+			sourceList.forEach((source) => {
+				source.loopEnd = loopEnd;
+			});
+		});
+	}
+
+	/**
+	 * If the buffers should loop once they are over.
+	 * @example
+	 * const sampler = new Tone.Sampler({
+	 *      urls: {
+	 *           A4: "https://tonejs.github.io/audio/berklee/femalevoice_aa_A4.mp3",
+	 *      },
+	 * }).toDestination();
+	 * sampler.loop = true;
+	 */
+	get loop(): boolean {
+		return this._loop;
+	}
+	set loop(loop) {
+		// if no change, do nothing
+		if (this._loop === loop) {
+			return;
+		}
+		this._loop = loop;
+		// set the loop of all of the sources
+		this._activeSources.forEach((sourceList) => {
+			sourceList.forEach((source) => {
+				source.loop = loop;
+			});
+		});
+	}
+
 	/**
 	 * Clean up
 	 */

package/Tone/signal/ToneConstantSource.test.ts

@@ -38,30 +38,30 @@ describe("ToneConstantSource", () => {
 	});
 
 	context("onended", () => {
-		it("invokes the onended callback in the online context", (done) => {
+		it("invokes the onended callback in the online context", async () => {
 			const source = new ToneConstantSource();
 			source.start();
 			source.stop("+0.3");
 			const now = source.now();
-			source.onended = () => {
-				expect(source.now() - now).to.be.closeTo(0.3, 0.15);
-				source.dispose();
-				done();
-			};
+			await new Promise<void>((resolve) => {
+				source.onended = () => resolve();
+			});
+			expect(source.now() - now).to.be.within(0.25, 0.6);
+			source.dispose();
 		});
 
-		it("invokes the onended callback only once in the online context", (done) => {
+		it("invokes the onended callback only once in the online context", async () => {
 			const source = new ToneConstantSource();
 			source.start();
 			source.stop("+0.1");
 			source.stop("+0.2");
 			source.stop("+0.3");
 			const now = source.now();
-			source.onended = () => {
-				expect(source.now() - now).to.be.within(0.25, 0.5);
-				source.dispose();
-				done();
-			};
+			await new Promise<void>((resolve) => {
+				source.onended = () => resolve();
+			});
+			expect(source.now() - now).to.be.within(0.25, 0.6);
+			source.dispose();
 		});
 
 		it("invokes the onended callback in the offline context", async () => {
@@ -129,6 +129,17 @@ describe("ToneConstantSource", () => {
 			expect(buffer.getValueAtTime(0.2)).to.equal(0);
 		});
 
+		it("stops the native ConstantSourceNode once stop() takes effect", async () => {
+			const stopSpy = sinon.spy(ConstantSourceNode.prototype, "stop");
+			const source = new ToneConstantSource().start();
+			source.stop();
+			await new Promise<void>((resolve) => {
+				source.onended = () => resolve();
+			});
+			expect(stopSpy).to.have.been.calledOnce;
+			source.dispose();
+		});
+
 		it("clamps start time to the currentTime", () => {
 			const source = new ToneConstantSource();
 			source.start(0);

package/Tone/signal/ToneConstantSource.ts

@@ -31,6 +31,11 @@ export class ToneConstantSource<
 	 */
 	private _source?: ConstantSourceNode;
 
+	/**
+	 * Whether the native source was started, so it can be stopped
+	 */
+	private _sourceStarted = false;
+
 	/**
 	 * The offset of the signal generator
 	 */
@@ -86,6 +91,7 @@ export class ToneConstantSource<
 			this._stopTime !== -1 && this._stopTime < this._startTime;
 		if (isStarted && !isStoppedBeforeStart) {
 			this._source.start(this._startTime);
+			this._sourceStarted = true;
 		}
 	}
 
@@ -97,15 +103,19 @@ export class ToneConstantSource<
 		const computedTime = this.toSeconds(time);
 		this.log("start", computedTime);
 		this._startGain(computedTime);
-		this._source?.start(computedTime);
+		if (this._source) {
+			this._source.start(computedTime);
+			this._sourceStarted = true;
+		}
 		return this;
 	}
 
 	protected _stopSource(time?: Seconds): void {
-		if (this.state === "stopped") {
-			return;
+		// state is already "stopped" here: OneShotSource defers this call
+		// until after _stopTime, so check the native node instead
+		if (this._sourceStarted) {
+			this._source?.stop(time);
 		}
-		this._source?.stop(time);
 	}
 
 	dispose(): this {

package/Tone/version.ts

@@ -1 +1 @@
-export const version: string = "15.5.56";
+export const version: string = "15.5.58";