feat(*): update implementation to allow custom analyzers, streams, and contexts

package.json

@@ -30,8 +30,7 @@
   },
   "lint-staged": {
     "*.{ts,js}": [
-      "biome format",
-      "biome lint --fix"
+      "mise run fix"
     ]
   }
 }

src/analyser.ts

@@ -0,0 +1,82 @@
+export class Analyser {
+	readonly node: AnalyserNode;
+	readonly #data: Uint8Array<ArrayBuffer>;
+
+	constructor(
+		readonly context: AudioContext = new AudioContext(),
+		readonly options: AnalyserOptions = {},
+	) {
+		this.node = this.context.createAnalyser();
+
+		if (options?.fftSize) {
+			this.node.fftSize = options.fftSize;
+		}
+
+		if (options?.minDecibels) {
+			this.node.minDecibels = options.minDecibels;
+		}
+
+		if (options?.maxDecibels) {
+			this.node.maxDecibels = options.maxDecibels;
+		}
+
+		if (options?.smoothingTimeConstant) {
+			this.node.smoothingTimeConstant = options.smoothingTimeConstant;
+		}
+
+		if (options?.channelCount) {
+			this.node.channelCount = options.channelCount;
+		}
+
+		if (options?.channelInterpretation) {
+			this.node.channelInterpretation = options.channelInterpretation;
+		}
+
+		if (options?.channelCountMode) {
+			this.node.channelCountMode = options.channelCountMode;
+		}
+
+		this.#data = new Uint8Array(this.node.frequencyBinCount);
+	}
+
+	/**
+	 * Returns the frequency data provided by the default analyzer
+	 */
+	get frequencyData(): Uint8Array {
+		this.node.getByteFrequencyData(this.#data);
+		return this.#data;
+	}
+
+	/**
+	 * Retrieves the current volume (average of amplitude^2)
+	 */
+	get volume(): number {
+		const data = this.frequencyData;
+
+		let sum = 0;
+
+		for (const amplitude of data) {
+			sum += amplitude * amplitude;
+		}
+
+		return Math.sqrt(sum / data.length);
+	}
+
+	connect(
+		destinationNode: AudioNode,
+		output?: number,
+		input?: number,
+	): AudioNode;
+	connect(destinationParam: AudioParam, output?: number): void;
+	connect(
+		destination: AudioNode | AudioParam,
+		output?: number,
+		input?: number,
+	): AudioNode | undefined {
+		if (destination instanceof AudioNode) {
+			return this.node.connect(destination, output, input);
+		} else {
+			this.node.connect(destination, output);
+		}
+	}
+}

src/index.ts

@@ -1,2 +1,4 @@
+export * from "./analyser.js";
+export * from "./monitor.js";
 export * from "./recorder.js";
-export * from "./types.js";
+export * from "./utils.js";

src/monitor.ts

@@ -0,0 +1,52 @@
+import { Analyser } from "./analyser.js";
+
+export interface MonitorOptions {
+	context?: AudioContext;
+	defaultAnalyser?: Analyser;
+}
+
+export class Monitor {
+	readonly context: AudioContext;
+	readonly source: MediaStreamAudioSourceNode;
+	readonly destination: AudioDestinationNode;
+	readonly analyser: Analyser;
+	readonly #options: MonitorOptions;
+
+	constructor(
+		readonly stream: MediaStream,
+		options: MonitorOptions,
+	) {
+		this.#options = options;
+		this.context = this.#options.context ?? new AudioContext();
+		this.destination = this.context.destination;
+		this.source = this.context.createMediaStreamSource(this.stream);
+		this.analyser = this.#options.defaultAnalyser ?? new Analyser(this.context);
+		this.source.connect(this.analyser.node);
+		this.analyser.connect(this.destination);
+	}
+
+	/**
+	 * Retrieves the current volume (average of amplitude^2)
+	 */
+	get volume() {
+		return this.analyser.volume;
+	}
+
+	/**
+	 * Retrieves the current analyzer's frequency data
+	 */
+	get frequencyData() {
+		return this.analyser.frequencyData;
+	}
+
+	/**
+	 * Adds a custom audio worklet to the current audio context
+	 *
+	 * @param name The registered name of the worklet
+	 * @param path The absolute path to the worklet
+	 */
+	async installWorklet(name: string, path: string): Promise<AudioWorkletNode> {
+		await this.context.audioWorklet.addModule(path);
+		return new AudioWorkletNode(this.context, name);
+	}
+}