@gjsify/webaudio 0.3.13 → 0.3.15

package/lib/esm/audio-buffer-source-node.js

@@ -2,62 +2,64 @@ import { AudioNode } from "./audio-node.js";
 import { AudioParam } from "./audio-param.js";
 import { GstPlayer } from "./gst-player.js";
 import { GainNode } from "./gain-node.js";
-class AudioBufferSourceNode extends AudioNode {
-  buffer = null;
-  loop = false;
-  loopStart = 0;
-  loopEnd = 0;
-  playbackRate;
-  onended = null;
-  _player = null;
-  _started = false;
-  constructor() {
-    super(0, 1);
-    this.playbackRate = new AudioParam(1, 0.0625, 16);
-  }
-  start(when = 0, offset = 0, duration) {
-    if (this._started) {
-      throw new DOMException("AudioBufferSourceNode can only be started once", "InvalidStateError");
-    }
-    this._started = true;
-    if (!this.buffer) return;
-    const gainNode = this._findGainNode();
-    const volume = gainNode ? gainNode.gain.value : 1;
-    this._player = new GstPlayer({
-      audioBuffer: this.buffer,
-      volume,
-      loop: this.loop,
-      offset,
-      duration,
-      playbackRate: this.playbackRate.value,
-      onEnded: () => {
-        if (gainNode) {
-          gainNode._activePlayers.delete(this._player);
-        }
-        this._player = null;
-        this.onended?.();
-      }
-    });
-    if (gainNode && this._player) {
-      gainNode._activePlayers.add(this._player);
-    }
-  }
-  stop(_when = 0) {
-    if (this._player) {
-      this._player.stop();
-    }
-  }
-  /** Walk the output chain to find a GainNode */
-  _findGainNode() {
-    for (const node of this._outputs) {
-      if (node instanceof GainNode) return node;
-      for (const inner of node._outputs) {
-        if (inner instanceof GainNode) return inner;
-      }
-    }
-    return null;
-  }
-}
-export {
-  AudioBufferSourceNode
+
+//#region src/audio-buffer-source-node.ts
+var AudioBufferSourceNode = class extends AudioNode {
+	buffer = null;
+	loop = false;
+	loopStart = 0;
+	loopEnd = 0;
+	playbackRate;
+	onended = null;
+	_player = null;
+	_started = false;
+	constructor() {
+		super(0, 1);
+		this.playbackRate = new AudioParam(1, .0625, 16);
+	}
+	start(when = 0, offset = 0, duration) {
+		if (this._started) {
+			throw new DOMException("AudioBufferSourceNode can only be started once", "InvalidStateError");
+		}
+		this._started = true;
+		if (!this.buffer) return;
+		const gainNode = this._findGainNode();
+		const volume = gainNode ? gainNode.gain.value : 1;
+		this._player = new GstPlayer({
+			audioBuffer: this.buffer,
+			volume,
+			loop: this.loop,
+			offset,
+			duration,
+			playbackRate: this.playbackRate.value,
+			onEnded: () => {
+				if (gainNode) {
+					gainNode._activePlayers.delete(this._player);
+				}
+				this._player = null;
+				this.onended?.();
+			}
+		});
+		if (gainNode && this._player) {
+			gainNode._activePlayers.add(this._player);
+		}
+	}
+	stop(_when = 0) {
+		if (this._player) {
+			this._player.stop();
+		}
+	}
+	/** Walk the output chain to find a GainNode */
+	_findGainNode() {
+		for (const node of this._outputs) {
+			if (node instanceof GainNode) return node;
+			for (const inner of node._outputs) {
+				if (inner instanceof GainNode) return inner;
+			}
+		}
+		return null;
+	}
 };
+
+//#endregion
+export { AudioBufferSourceNode };

package/lib/esm/audio-buffer.js

@@ -1,37 +1,38 @@
-class AudioBuffer {
-  sampleRate;
-  length;
-  duration;
-  numberOfChannels;
-  /** @internal */
-  _channelData;
-  constructor(options) {
-    this.sampleRate = options.sampleRate;
-    this.length = options.length;
-    this.numberOfChannels = options.numberOfChannels;
-    this.duration = this.length / this.sampleRate;
-    this._channelData = [];
-    for (let i = 0; i < this.numberOfChannels; i++) {
-      this._channelData.push(new Float32Array(this.length));
-    }
-  }
-  getChannelData(channel) {
-    if (channel < 0 || channel >= this.numberOfChannels) {
-      throw new RangeError(`channel index ${channel} out of range [0, ${this.numberOfChannels})`);
-    }
-    return this._channelData[channel];
-  }
-  copyFromChannel(destination, channelNumber, bufferOffset = 0) {
-    const src = this.getChannelData(channelNumber);
-    const len = Math.min(destination.length, src.length - bufferOffset);
-    destination.set(src.subarray(bufferOffset, bufferOffset + len));
-  }
-  copyToChannel(source, channelNumber, bufferOffset = 0) {
-    const dest = this.getChannelData(channelNumber);
-    const len = Math.min(source.length, dest.length - bufferOffset);
-    dest.set(source.subarray(0, len), bufferOffset);
-  }
-}
-export {
-  AudioBuffer
+//#region src/audio-buffer.ts
+var AudioBuffer = class {
+	sampleRate;
+	length;
+	duration;
+	numberOfChannels;
+	/** @internal */
+	_channelData;
+	constructor(options) {
+		this.sampleRate = options.sampleRate;
+		this.length = options.length;
+		this.numberOfChannels = options.numberOfChannels;
+		this.duration = this.length / this.sampleRate;
+		this._channelData = [];
+		for (let i = 0; i < this.numberOfChannels; i++) {
+			this._channelData.push(new Float32Array(this.length));
+		}
+	}
+	getChannelData(channel) {
+		if (channel < 0 || channel >= this.numberOfChannels) {
+			throw new RangeError(`channel index ${channel} out of range [0, ${this.numberOfChannels})`);
+		}
+		return this._channelData[channel];
+	}
+	copyFromChannel(destination, channelNumber, bufferOffset = 0) {
+		const src = this.getChannelData(channelNumber);
+		const len = Math.min(destination.length, src.length - bufferOffset);
+		destination.set(src.subarray(bufferOffset, bufferOffset + len));
+	}
+	copyToChannel(source, channelNumber, bufferOffset = 0) {
+		const dest = this.getChannelData(channelNumber);
+		const len = Math.min(source.length, dest.length - bufferOffset);
+		dest.set(source.subarray(0, len), bufferOffset);
+	}
 };
+
+//#endregion
+export { AudioBuffer };

package/lib/esm/audio-context.js

@@ -1,94 +1,93 @@
-import GLib from "gi://GLib?version=2.0";
+import { AudioNode } from "./audio-node.js";
 import { ensureGstInit } from "./gst-init.js";
+import { GainNode } from "./gain-node.js";
+import { AudioBufferSourceNode } from "./audio-buffer-source-node.js";
 import { AudioBuffer } from "./audio-buffer.js";
-import { AudioNode } from "./audio-node.js";
 import { AudioDestinationNode } from "./audio-destination-node.js";
-import { AudioBufferSourceNode } from "./audio-buffer-source-node.js";
-import { GainNode } from "./gain-node.js";
 import { decodeAudioDataSync } from "./gst-decoder.js";
-class AudioContext {
-  state = "suspended";
-  sampleRate = 44100;
-  destination;
-  listener = {};
-  _startTime;
-  constructor() {
-    ensureGstInit();
-    this._startTime = GLib.get_monotonic_time();
-    this.destination = new AudioDestinationNode();
-  }
-  /** Monotonically increasing time in seconds since context creation. */
-  get currentTime() {
-    return (GLib.get_monotonic_time() - this._startTime) / 1e6;
-  }
-  createGain() {
-    return new GainNode();
-  }
-  createBufferSource() {
-    return new AudioBufferSourceNode();
-  }
-  createBuffer(numberOfChannels, length, sampleRate) {
-    return new AudioBuffer({ numberOfChannels, length, sampleRate });
-  }
-  /**
-   * Decode encoded audio data (MP3, WAV, OGG, etc.) into an AudioBuffer.
-   * Uses GStreamer's decodebin for format-agnostic decoding.
-   */
-  decodeAudioData(arrayBuffer, successCallback, errorCallback) {
-    try {
-      const buffer = decodeAudioDataSync(arrayBuffer);
-      successCallback?.(buffer);
-      return Promise.resolve(buffer);
-    } catch (err) {
-      const domErr = err instanceof DOMException ? err : new DOMException("Unable to decode audio data", "EncodingError");
-      errorCallback?.(domErr);
-      return Promise.reject(domErr);
-    }
-  }
-  async resume() {
-    this.state = "running";
-  }
-  async suspend() {
-    this.state = "suspended";
-  }
-  async close() {
-    this.state = "closed";
-  }
-  // Stub methods for APIs not yet backed by GStreamer (Phase 3)
-  createAnalyser() {
-    return {
-      connect: () => {
-      },
-      disconnect: () => {
-      },
-      fftSize: 2048,
-      frequencyBinCount: 1024,
-      getByteFrequencyData: () => {
-      },
-      getFloatFrequencyData: () => {
-      }
-    };
-  }
-  createDynamicsCompressor() {
-    return new AudioNode();
-  }
-  createBiquadFilter() {
-    return new AudioNode();
-  }
-  createConvolver() {
-    return new AudioNode();
-  }
-  createPanner() {
-    return new AudioNode();
-  }
-  createStereoPanner() {
-    return new AudioNode();
-  }
-  addEventListener(_type, _listener) {
-  }
-  removeEventListener(_type, _listener) {
-  }
-}
-export {
-  AudioContext
+import GLib from "gi://GLib?version=2.0";
+
+//#region src/audio-context.ts
+var AudioContext = class {
+	state = "suspended";
+	sampleRate = 44100;
+	destination;
+	listener = {};
+	_startTime;
+	constructor() {
+		ensureGstInit();
+		this._startTime = GLib.get_monotonic_time();
+		this.destination = new AudioDestinationNode();
+	}
+	/** Monotonically increasing time in seconds since context creation. */
+	get currentTime() {
+		return (GLib.get_monotonic_time() - this._startTime) / 1e6;
+	}
+	createGain() {
+		return new GainNode();
+	}
+	createBufferSource() {
+		return new AudioBufferSourceNode();
+	}
+	createBuffer(numberOfChannels, length, sampleRate) {
+		return new AudioBuffer({
+			numberOfChannels,
+			length,
+			sampleRate
+		});
+	}
+	/**
+	* Decode encoded audio data (MP3, WAV, OGG, etc.) into an AudioBuffer.
+	* Uses GStreamer's decodebin for format-agnostic decoding.
+	*/
+	decodeAudioData(arrayBuffer, successCallback, errorCallback) {
+		try {
+			const buffer = decodeAudioDataSync(arrayBuffer);
+			successCallback?.(buffer);
+			return Promise.resolve(buffer);
+		} catch (err) {
+			const domErr = err instanceof DOMException ? err : new DOMException("Unable to decode audio data", "EncodingError");
+			errorCallback?.(domErr);
+			return Promise.reject(domErr);
+		}
+	}
+	async resume() {
+		this.state = "running";
+	}
+	async suspend() {
+		this.state = "suspended";
+	}
+	async close() {
+		this.state = "closed";
+	}
+	createAnalyser() {
+		return {
+			connect: () => {},
+			disconnect: () => {},
+			fftSize: 2048,
+			frequencyBinCount: 1024,
+			getByteFrequencyData: () => {},
+			getFloatFrequencyData: () => {}
+		};
+	}
+	createDynamicsCompressor() {
+		return new AudioNode();
+	}
+	createBiquadFilter() {
+		return new AudioNode();
+	}
+	createConvolver() {
+		return new AudioNode();
+	}
+	createPanner() {
+		return new AudioNode();
+	}
+	createStereoPanner() {
+		return new AudioNode();
+	}
+	addEventListener(_type, _listener) {}
+	removeEventListener(_type, _listener) {}
 };
+
+//#endregion
+export { AudioContext };

package/lib/esm/audio-destination-node.js

@@ -1,10 +1,12 @@
 import { AudioNode } from "./audio-node.js";
-class AudioDestinationNode extends AudioNode {
-  maxChannelCount = 2;
-  constructor() {
-    super(1, 0);
-  }
-}
-export {
-  AudioDestinationNode
+
+//#region src/audio-destination-node.ts
+var AudioDestinationNode = class extends AudioNode {
+	maxChannelCount = 2;
+	constructor() {
+		super(1, 0);
+	}
 };
+
+//#endregion
+export { AudioDestinationNode };

package/lib/esm/audio-node.js

@@ -1,33 +1,34 @@
-class AudioNode {
-  /** @internal downstream connections */
-  _outputs = /* @__PURE__ */ new Set();
-  /** @internal upstream connections */
-  _inputs = /* @__PURE__ */ new Set();
-  numberOfInputs;
-  numberOfOutputs;
-  channelCount;
-  constructor(numberOfInputs = 1, numberOfOutputs = 1) {
-    this.numberOfInputs = numberOfInputs;
-    this.numberOfOutputs = numberOfOutputs;
-    this.channelCount = 2;
-  }
-  connect(destination) {
-    this._outputs.add(destination);
-    destination._inputs.add(this);
-    return destination;
-  }
-  disconnect(destination) {
-    if (destination) {
-      this._outputs.delete(destination);
-      destination._inputs.delete(this);
-    } else {
-      for (const node of this._outputs) {
-        node._inputs.delete(this);
-      }
-      this._outputs.clear();
-    }
-  }
-}
-export {
-  AudioNode
+//#region src/audio-node.ts
+var AudioNode = class {
+	/** @internal downstream connections */
+	_outputs = new Set();
+	/** @internal upstream connections */
+	_inputs = new Set();
+	numberOfInputs;
+	numberOfOutputs;
+	channelCount;
+	constructor(numberOfInputs = 1, numberOfOutputs = 1) {
+		this.numberOfInputs = numberOfInputs;
+		this.numberOfOutputs = numberOfOutputs;
+		this.channelCount = 2;
+	}
+	connect(destination) {
+		this._outputs.add(destination);
+		destination._inputs.add(this);
+		return destination;
+	}
+	disconnect(destination) {
+		if (destination) {
+			this._outputs.delete(destination);
+			destination._inputs.delete(this);
+		} else {
+			for (const node of this._outputs) {
+				node._inputs.delete(this);
+			}
+			this._outputs.clear();
+		}
+	}
 };
+
+//#endregion
+export { AudioNode };

package/lib/esm/audio-param.js

@@ -1,78 +1,80 @@
 import GLib from "gi://GLib?version=2.0";
-class AudioParam {
-  defaultValue;
-  minValue;
-  maxValue;
-  /** @internal callback invoked when value changes */
-  _onChange = null;
-  _value;
-  _rampTimerId = null;
-  constructor(defaultValue = 0, minValue = -34028235e31, maxValue = 34028235e31) {
-    this.defaultValue = defaultValue;
-    this.minValue = minValue;
-    this.maxValue = maxValue;
-    this._value = defaultValue;
-  }
-  get value() {
-    return this._value;
-  }
-  set value(v) {
-    this._cancelRamp();
-    this._value = Math.max(this.minValue, Math.min(this.maxValue, v));
-    this._onChange?.(this._value);
-  }
-  setValueAtTime(value, _startTime) {
-    this.value = value;
-    return this;
-  }
-  linearRampToValueAtTime(value, _endTime) {
-    this.value = value;
-    return this;
-  }
-  exponentialRampToValueAtTime(value, _endTime) {
-    this.value = value;
-    return this;
-  }
-  setTargetAtTime(target, _startTime, timeConstant) {
-    this._cancelRamp();
-    if (timeConstant <= 0) {
-      this.value = target;
-      return this;
-    }
-    const stepMs = Math.max(10, Math.round(timeConstant * 100));
-    this._rampTimerId = GLib.timeout_add(GLib.PRIORITY_DEFAULT, stepMs, () => {
-      const diff = target - this._value;
-      if (Math.abs(diff) < 1e-3) {
-        this._value = target;
-        this._onChange?.(this._value);
-        this._rampTimerId = null;
-        return GLib.SOURCE_REMOVE;
-      }
-      const factor = 1 - Math.exp(-stepMs / (timeConstant * 1e3));
-      this._value += diff * factor;
-      this._onChange?.(this._value);
-      return GLib.SOURCE_CONTINUE;
-    });
-    return this;
-  }
-  setValueCurveAtTime(_values, _startTime, _duration) {
-    return this;
-  }
-  cancelScheduledValues(_startTime) {
-    this._cancelRamp();
-    return this;
-  }
-  cancelAndHoldAtTime(_cancelTime) {
-    this._cancelRamp();
-    return this;
-  }
-  _cancelRamp() {
-    if (this._rampTimerId !== null) {
-      GLib.source_remove(this._rampTimerId);
-      this._rampTimerId = null;
-    }
-  }
-}
-export {
-  AudioParam
+
+//#region src/audio-param.ts
+var AudioParam = class {
+	defaultValue;
+	minValue;
+	maxValue;
+	/** @internal callback invoked when value changes */
+	_onChange = null;
+	_value;
+	_rampTimerId = null;
+	constructor(defaultValue = 0, minValue = -34028235e31, maxValue = 34028235e31) {
+		this.defaultValue = defaultValue;
+		this.minValue = minValue;
+		this.maxValue = maxValue;
+		this._value = defaultValue;
+	}
+	get value() {
+		return this._value;
+	}
+	set value(v) {
+		this._cancelRamp();
+		this._value = Math.max(this.minValue, Math.min(this.maxValue, v));
+		this._onChange?.(this._value);
+	}
+	setValueAtTime(value, _startTime) {
+		this.value = value;
+		return this;
+	}
+	linearRampToValueAtTime(value, _endTime) {
+		this.value = value;
+		return this;
+	}
+	exponentialRampToValueAtTime(value, _endTime) {
+		this.value = value;
+		return this;
+	}
+	setTargetAtTime(target, _startTime, timeConstant) {
+		this._cancelRamp();
+		if (timeConstant <= 0) {
+			this.value = target;
+			return this;
+		}
+		const stepMs = Math.max(10, Math.round(timeConstant * 100));
+		this._rampTimerId = GLib.timeout_add(GLib.PRIORITY_DEFAULT, stepMs, () => {
+			const diff = target - this._value;
+			if (Math.abs(diff) < .001) {
+				this._value = target;
+				this._onChange?.(this._value);
+				this._rampTimerId = null;
+				return GLib.SOURCE_REMOVE;
+			}
+			const factor = 1 - Math.exp(-stepMs / (timeConstant * 1e3));
+			this._value += diff * factor;
+			this._onChange?.(this._value);
+			return GLib.SOURCE_CONTINUE;
+		});
+		return this;
+	}
+	setValueCurveAtTime(_values, _startTime, _duration) {
+		return this;
+	}
+	cancelScheduledValues(_startTime) {
+		this._cancelRamp();
+		return this;
+	}
+	cancelAndHoldAtTime(_cancelTime) {
+		this._cancelRamp();
+		return this;
+	}
+	_cancelRamp() {
+		if (this._rampTimerId !== null) {
+			GLib.source_remove(this._rampTimerId);
+			this._rampTimerId = null;
+		}
+	}
 };
+
+//#endregion
+export { AudioParam };