@node-3d/webaudio 6.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Luis Blanco
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,59 @@
+# WebAudio for Node.js
+
+This is a part of [Node3D](https://github.com/node-3d) project.
+
+[![NPM](https://badge.fury.io/js/@node-3d%2Fwebaudio.svg)](https://badge.fury.io/js/@node-3d%2Fwebaudio)
+[![Lint](https://github.com/node-3d/webaudio/actions/workflows/lint.yml/badge.svg)](https://github.com/node-3d/webaudio/actions/workflows/lint.yml)
+[![Test](https://github.com/node-3d/webaudio/actions/workflows/test.yml/badge.svg)](https://github.com/node-3d/webaudio/actions/workflows/test.yml)
+[![Cpplint](https://github.com/node-3d/webaudio/actions/workflows/cpplint.yml/badge.svg)](https://github.com/node-3d/webaudio/actions/workflows/cpplint.yml)
+
+```bash
+npm install @node-3d/webaudio
+```
+
+
+
+
+**Node.js** addon implementing the
+[Web Audio Api](https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API).
+
+Import any class you like from the module and then follow the
+[doc](https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API):
+
+```js
+import { AudioContext } from '@node-3d/webaudio'; // usually this is enough
+```
+
+**This module is WORK IN PROGRESS.**
+Some features are missing for good.
+
+Currently exported classes:
+
+* `AudioBuffer`
+* `AudioContext`
+* `AudioParam`
+* `AnalyserNode`
+* `BiquadFilterNode`
+* `ConvolverNode`
+* `GainNode`
+* `PannerNode`
+* `AudioBufferSourceNode`
+* `OscillatorNode`
+* `AudioScheduledSourceNode`
+
+In examples directory, currently working examples are prepended with `_`.
+
+## Binary Origin
+
+Release archives are built by this repository's public GitHub Actions workflows.
+
+Attestations: https://github.com/node-3d/webaudio/attestations
+
+To verify a downloaded archive:
+
+```bash
+gh release download <tag> -R node-3d/webaudio -p <platform>.gz
+gh attestation verify <platform>.gz -R node-3d/webaudio
+```
+
+> This addon is ABI-compatible across Node.js versions. **There is no compilation** during `npm install`.

package/dist/audio-buffer.d.ts

@@ -0,0 +1,11 @@
+import { inspect } from 'node:util';
+declare const AudioBuffer: import("./native.ts").TNativeEs5Constructor<[context: import("./native.ts").TBaseAudioContext, source?: Readonly<{
+    length?: number;
+    numberOfChannels?: number;
+    sampleRate?: number;
+}> | import("./native.ts").TNativeExternal | undefined], import("./native.ts").TAudioBuffer>;
+declare class JsAudioBuffer extends AudioBuffer {
+    [inspect.custom](): string;
+    toString(): string;
+}
+export { JsAudioBuffer as AudioBuffer };

package/dist/audio-context.d.ts

@@ -0,0 +1,4 @@
+import type { TJsBaseAudioContext } from './base-audio-context.ts';
+import type { TAudioContext, TAudioContextOptions, TNativeConstructor } from './native.ts';
+declare const WrappedAudioContext: TNativeConstructor<[opts?: TAudioContextOptions], TAudioContext & TJsBaseAudioContext>;
+export { WrappedAudioContext as AudioContext };

package/dist/audio-destination-node.d.ts

@@ -0,0 +1,7 @@
+import type { TAudioDestinationNode, TBaseAudioContext, TNativeConstructor, TNativeExternal } from './native.ts';
+type TAudioDestinationNodeConstructor = TNativeConstructor<[
+    ctx: TBaseAudioContext,
+    node: TNativeExternal
+], TAudioDestinationNode>;
+declare const JsAudioDestinationNode: TAudioDestinationNodeConstructor;
+export { JsAudioDestinationNode as AudioDestinationNode };

package/dist/audio-listener.d.ts

@@ -0,0 +1,9 @@
+import { inspect } from 'node:util';
+import type { TBaseAudioContext, TNativeExternal } from './native.ts';
+declare const AudioListener: import("./native.ts").TNativeEs5Constructor<[context: TBaseAudioContext, listener: TNativeExternal, paramCtor: import("./native.ts").TAudioParamConstructor], import("./native.ts").TAudioListener>;
+declare class JsAudioListener extends AudioListener {
+    constructor(ctx: TBaseAudioContext, listener: TNativeExternal);
+    [inspect.custom](): string;
+    toString(): string;
+}
+export { JsAudioListener as AudioListener };

package/dist/audio-node.d.ts

@@ -0,0 +1,7 @@
+import type { TAudioNode, TBaseAudioContext, TNativeConstructor, TNativeExternal } from './native.ts';
+type TAudioNodeConstructor = TNativeConstructor<[
+    ctx: TBaseAudioContext,
+    node: TNativeExternal
+], TAudioNode>;
+declare const JsAudioNode: TAudioNodeConstructor;
+export { JsAudioNode as AudioNode };

package/dist/audio-param.d.ts

@@ -0,0 +1,12 @@
+import { inspect } from 'node:util';
+import type { TAudioEventCallbackList } from './native.ts';
+declare const AudioParam: import("./native.ts").TAudioParamConstructor;
+declare class JsAudioParam extends AudioParam {
+    get onerror(): TAudioEventCallbackList;
+    set onerror(cb: TAudioEventCallbackList);
+    get onended(): TAudioEventCallbackList;
+    set onended(cb: TAudioEventCallbackList);
+    [inspect.custom](): string;
+    toString(): string;
+}
+export { JsAudioParam as AudioParam };

package/dist/audio-scheduled-source-node.d.ts

@@ -0,0 +1,7 @@
+import type { TAudioScheduledSourceNode, TBaseAudioContext, TNativeConstructor, TNativeExternal } from './native.ts';
+type TAudioScheduledSourceNodeConstructor = TNativeConstructor<[
+    ctx: TBaseAudioContext,
+    node: TNativeExternal
+], TAudioScheduledSourceNode>;
+declare const JsAudioScheduledSourceNode: TAudioScheduledSourceNodeConstructor;
+export { JsAudioScheduledSourceNode as AudioScheduledSourceNode };

package/dist/base-audio-context.d.ts

@@ -0,0 +1,30 @@
+import { AudioDestinationNode } from './audio-destination-node.ts';
+import { AudioListener } from './audio-listener.ts';
+import type { TAnalyserNode, TAudioBuffer, TAudioBufferSourceNode, TAudioNodeOptions, TBaseAudioContext, TBiquadFilterNode, TConvolverNode, TDelayNode, TGainNode, TNativeConstructor, TNativeExternal, TOscillatorNode, TPannerNode } from './native.ts';
+export type TJsBaseAudioContext = TBaseAudioContext & {
+    _initListener: (destinationCtor: typeof AudioDestinationNode, listenerCtor: typeof AudioListener, sampleRate: number) => void;
+    createAnalyser: (opts?: TAudioNodeOptions) => TAnalyserNode;
+    createBiquadFilter: (opts?: TAudioNodeOptions) => TBiquadFilterNode;
+    createBuffer: (opts?: TAudioNodeOptions) => TAudioBuffer;
+    createBufferSource: (opts?: TAudioNodeOptions) => TAudioBufferSourceNode;
+    createConvolver: (opts?: TAudioNodeOptions) => TConvolverNode;
+    createDelay: (maxDelayTime?: number) => TDelayNode;
+    createGain: (opts?: TAudioNodeOptions) => TGainNode;
+    createOscillator: (opts?: TAudioNodeOptions) => TOscillatorNode;
+    createPanner: (opts?: TAudioNodeOptions) => TPannerNode;
+    createChannelMerger: (opts?: TAudioNodeOptions) => object;
+    createChannelSplitter: (opts?: TAudioNodeOptions) => object;
+    createConstantSource: (opts?: TAudioNodeOptions) => object;
+    createDynamicsCompressor: (opts?: TAudioNodeOptions) => object;
+    createIIRFilter: (opts?: TAudioNodeOptions) => object;
+    createPeriodicWave: (opts?: TAudioNodeOptions) => object;
+    createScriptProcessor: (opts?: TAudioNodeOptions) => object;
+    createStereoPanner: (opts?: TAudioNodeOptions) => object;
+    createWaveShaper: (opts?: TAudioNodeOptions) => object;
+};
+type TBaseAudioContextConstructor = TNativeConstructor<[
+    ctx: TNativeExternal,
+    sampleRate?: number
+], TJsBaseAudioContext>;
+declare const JsBaseAudioContext: TBaseAudioContextConstructor;
+export { JsBaseAudioContext as BaseAudioContext };

package/dist/core.d.ts

@@ -0,0 +1 @@
+export { native } from './native.ts';

package/dist/events.d.ts

@@ -0,0 +1,3 @@
+import type { EventEmitter } from 'node:events';
+import type { TAudioEventCallbackList } from './native.ts';
+export declare const setEventCallbacks: (emitter: EventEmitter, eventName: string, callbacks: TAudioEventCallbackList) => void;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { AudioBuffer } from './audio-buffer.ts';
+export { AudioContext } from './audio-context.ts';
+export { AudioParam } from './audio-param.ts';
+export * from './nodes.ts';
+export type * from './native.ts';

package/dist/index.js

@@ -0,0 +1,358 @@
+import { inherits, inspect } from "node:util";
+import node_events from "node:events";
+import { createRequire } from "node:module";
+import { getBin } from "@node-3d/addon-tools";
+import "@node-3d/segfault";
+import { hrtf } from "@node-3d/deps-labsound";
+const loadAddon = createRequire(import.meta.url);
+const native_native = loadAddon(`../${getBin()}/webaudio.node`);
+function _to_primitive(input, hint) {
+    if ("object" !== _type_of(input) || null === input) return input;
+    var prim = input[Symbol.toPrimitive];
+    if (void 0 !== prim) {
+        var res = prim.call(input, hint || "default");
+        if ("object" !== _type_of(res)) return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === hint ? String : Number)(input);
+}
+function _to_property_key(arg) {
+    var key = _to_primitive(arg, "string");
+    return "symbol" === _type_of(key) ? key : String(key);
+}
+function _type_of(obj) {
+    return obj && "u" > typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+let audio_buffer_computedKey;
+const { AudioBuffer: AudioBuffer } = native_native;
+inherits(AudioBuffer, node_events);
+audio_buffer_computedKey = _to_property_key(inspect.custom);
+class JsAudioBuffer extends AudioBuffer {
+    [audio_buffer_computedKey]() {
+        return this.toString();
+    }
+    toString() {
+        return 'AudioBuffer {}';
+    }
+}
+const setEventCallbacks = (emitter, eventName, callbacks)=>{
+    if (!callbacks) return void emitter.removeAllListeners(eventName);
+    if ('function' == typeof callbacks) return void emitter.on(eventName, callbacks);
+    for (const callback of callbacks)emitter.on(eventName, callback);
+};
+const { AudioNode: AudioNode } = native_native;
+inherits(AudioNode, node_events);
+const nonGcRefs = new Set();
+const audio_node_JsAudioNode = function(ctx, node) {
+    AudioNode.call(this, ctx, node);
+    nonGcRefs.add(this);
+    this.on('destroy', ()=>{
+        nonGcRefs.delete(this);
+    });
+};
+const audioNodePrototype = {
+    get onerror () {
+        return this.listeners('error');
+    },
+    set onerror (cb){
+        setEventCallbacks(this, 'error', cb);
+    },
+    get onended () {
+        return this.listeners('ended');
+    },
+    set onended (cb){
+        setEventCallbacks(this, 'ended', cb);
+    },
+    [inspect.custom] () {
+        return this.toString();
+    },
+    toString () {
+        return 'AudioNode {}';
+    }
+};
+audio_node_JsAudioNode.prototype = audioNodePrototype;
+inherits(audio_node_JsAudioNode, AudioNode);
+const { AudioDestinationNode: AudioDestinationNode } = native_native;
+inherits(AudioDestinationNode, audio_node_JsAudioNode);
+const audio_destination_node_JsAudioDestinationNode = function(ctx, node) {
+    AudioDestinationNode.call(this, ctx, node);
+};
+audio_destination_node_JsAudioDestinationNode.prototype = {
+    [inspect.custom] () {
+        return this.toString();
+    },
+    toString () {
+        return 'AudioDestinationNode {}';
+    }
+};
+inherits(audio_destination_node_JsAudioDestinationNode, AudioDestinationNode);
+function audio_param_to_primitive(input, hint) {
+    if ("object" !== audio_param_type_of(input) || null === input) return input;
+    var prim = input[Symbol.toPrimitive];
+    if (void 0 !== prim) {
+        var res = prim.call(input, hint || "default");
+        if ("object" !== audio_param_type_of(res)) return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === hint ? String : Number)(input);
+}
+function audio_param_to_property_key(arg) {
+    var key = audio_param_to_primitive(arg, "string");
+    return "symbol" === audio_param_type_of(key) ? key : String(key);
+}
+function audio_param_type_of(obj) {
+    return obj && "u" > typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+let audio_param_computedKey;
+const { AudioParam: AudioParam } = native_native;
+inherits(AudioParam, node_events);
+audio_param_computedKey = audio_param_to_property_key(inspect.custom);
+class JsAudioParam extends AudioParam {
+    get onerror() {
+        return this.listeners('error');
+    }
+    set onerror(cb1) {
+        setEventCallbacks(this, 'error', cb1);
+    }
+    get onended() {
+        return this.listeners('ended');
+    }
+    set onended(cb1) {
+        setEventCallbacks(this, 'ended', cb1);
+    }
+    [audio_param_computedKey]() {
+        return this.toString();
+    }
+    toString() {
+        return `AudioParam { ${this.value} }`;
+    }
+}
+function audio_listener_to_primitive(input, hint) {
+    if ("object" !== audio_listener_type_of(input) || null === input) return input;
+    var prim = input[Symbol.toPrimitive];
+    if (void 0 !== prim) {
+        var res = prim.call(input, hint || "default");
+        if ("object" !== audio_listener_type_of(res)) return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === hint ? String : Number)(input);
+}
+function audio_listener_to_property_key(arg) {
+    var key = audio_listener_to_primitive(arg, "string");
+    return "symbol" === audio_listener_type_of(key) ? key : String(key);
+}
+function audio_listener_type_of(obj) {
+    return obj && "u" > typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+let audio_listener_computedKey;
+const { AudioListener: AudioListener } = native_native;
+inherits(AudioListener, node_events);
+audio_listener_computedKey = audio_listener_to_property_key(inspect.custom);
+class JsAudioListener extends AudioListener {
+    constructor(ctx, listener){
+        super(ctx, listener, JsAudioParam);
+    }
+    [audio_listener_computedKey]() {
+        return this.toString();
+    }
+    toString() {
+        return 'AudioListener {}';
+    }
+}
+const { AudioScheduledSourceNode: AudioScheduledSourceNode } = native_native;
+inherits(AudioScheduledSourceNode, audio_node_JsAudioNode);
+const audio_scheduled_source_node_JsAudioScheduledSourceNode = function(ctx, node) {
+    AudioScheduledSourceNode.call(this, ctx, node);
+};
+audio_scheduled_source_node_JsAudioScheduledSourceNode.prototype = {
+    [inspect.custom] () {
+        return this.toString();
+    },
+    toString () {
+        return 'AudioScheduledSourceNode {}';
+    }
+};
+inherits(audio_scheduled_source_node_JsAudioScheduledSourceNode, AudioScheduledSourceNode);
+function nodes_to_primitive(input, hint) {
+    if ("object" !== nodes_type_of(input) || null === input) return input;
+    var prim = input[Symbol.toPrimitive];
+    if (void 0 !== prim) {
+        var res = prim.call(input, hint || "default");
+        if ("object" !== nodes_type_of(res)) return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === hint ? String : Number)(input);
+}
+function nodes_to_property_key(arg) {
+    var key = nodes_to_primitive(arg, "string");
+    return "symbol" === nodes_type_of(key) ? key : String(key);
+}
+function nodes_type_of(obj) {
+    return obj && "u" > typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+const baseDescs = [
+    'AnalyserNode',
+    'BiquadFilterNode',
+    'ConvolverNode',
+    'DelayNode',
+    'GainNode',
+    'PannerNode'
+];
+const scheduledDescs = [
+    'AudioBufferSourceNode',
+    'OscillatorNode'
+];
+const subclassBase = (name, SuperNode)=>{
+    let _computedKey;
+    const SuperClass = native_native[name];
+    inherits(SuperClass, SuperNode);
+    _computedKey = nodes_to_property_key(inspect.custom);
+    class JsNode extends SuperClass {
+        _opts;
+        constructor(ctx, opts = {}){
+            super(ctx, JsAudioParam, opts);
+            this._opts = opts;
+        }
+        [_computedKey]() {
+            return this.toString();
+        }
+        toString() {
+            return `${name} ${JSON.stringify(this._opts, null, '\t')}`;
+        }
+    }
+    return JsNode;
+};
+const baseNodes = {
+    AudioScheduledSourceNode: audio_scheduled_source_node_JsAudioScheduledSourceNode
+};
+for (const name of baseDescs)baseNodes[name] = subclassBase(name, audio_node_JsAudioNode);
+const scheduledNodes = {};
+for (const name of scheduledDescs)scheduledNodes[name] = subclassBase(name, audio_scheduled_source_node_JsAudioScheduledSourceNode);
+const nodes = {
+    ...baseNodes,
+    ...scheduledNodes
+};
+const { AudioScheduledSourceNode: nodes_AudioScheduledSourceNode, AnalyserNode: AnalyserNode, BiquadFilterNode: BiquadFilterNode, ConvolverNode: ConvolverNode, DelayNode: DelayNode, GainNode: GainNode, PannerNode: PannerNode, AudioBufferSourceNode: AudioBufferSourceNode, OscillatorNode: OscillatorNode } = nodes;
+const BaseAudioContext = native_native.BaseAudioContext;
+inherits(BaseAudioContext, node_events);
+BaseAudioContext.hrtf = hrtf;
+const base_audio_context_JsBaseAudioContext = function(ctx, sampleRate = -1) {
+    BaseAudioContext.call(this, ctx, sampleRate);
+    this._initListener(audio_destination_node_JsAudioDestinationNode, JsAudioListener, sampleRate);
+};
+const baseAudioContextPrototype = {
+    get onerror () {
+        return this.listeners('error');
+    },
+    set onerror (cb){
+        setEventCallbacks(this, 'error', cb);
+    },
+    get onstatechange () {
+        return this.listeners('statechange');
+    },
+    set onstatechange (cb){
+        setEventCallbacks(this, 'statechange', cb);
+    },
+    [inspect.custom] () {
+        return this.toString();
+    },
+    toString () {
+        return 'BaseAudioContext {}';
+    },
+    decodeAudioData (audioData, successCallback) {
+        BaseAudioContext.prototype.decodeAudioData.call(this, audioData, successCallback, JsAudioBuffer);
+    },
+    createAnalyser (opts = {}) {
+        return new nodes.AnalyserNode(this, opts);
+    },
+    createBiquadFilter (opts = {}) {
+        return new nodes.BiquadFilterNode(this, opts);
+    },
+    createBuffer (opts = {}) {
+        return new JsAudioBuffer(this, opts);
+    },
+    createBufferSource (opts = {}) {
+        return new nodes.AudioBufferSourceNode(this, opts);
+    },
+    createChannelMerger (opts = {}) {
+        return new nodes.ChannelMergerNode(this, opts);
+    },
+    createChannelSplitter (opts = {}) {
+        return new nodes.ChannelSplitterNode(this, opts);
+    },
+    createConstantSource (opts = {}) {
+        return new nodes.ConstantSourceNode(this, opts);
+    },
+    createConvolver (opts = {}) {
+        return new nodes.ConvolverNode(this, opts);
+    },
+    createDelay (maxDelayTime = 1) {
+        return new nodes.DelayNode(this, {
+            maxDelayTime
+        });
+    },
+    createDynamicsCompressor (opts = {}) {
+        return new nodes.DynamicsCompressorNode(this, opts);
+    },
+    createGain (opts = {}) {
+        return new nodes.GainNode(this, opts);
+    },
+    createIIRFilter (opts = {}) {
+        return new nodes.IIRFilterNode(this, opts);
+    },
+    createOscillator (opts = {}) {
+        return new nodes.OscillatorNode(this, opts);
+    },
+    createPanner (opts = {}) {
+        return new nodes.PannerNode(this, opts);
+    },
+    createPeriodicWave (opts = {}) {
+        return new nodes.PeriodicWaveNode(this, opts);
+    },
+    createScriptProcessor (opts = {}) {
+        return new nodes.ScriptProcessorNode(this, opts);
+    },
+    createStereoPanner (opts = {}) {
+        return new nodes.StereoPannerNode(this, opts);
+    },
+    createWaveShaper (opts = {}) {
+        return new nodes.WaveShaperNode(this, opts);
+    }
+};
+base_audio_context_JsBaseAudioContext.prototype = baseAudioContextPrototype;
+inherits(base_audio_context_JsBaseAudioContext, BaseAudioContext);
+function audio_context_to_primitive(input, hint) {
+    if ("object" !== audio_context_type_of(input) || null === input) return input;
+    var prim = input[Symbol.toPrimitive];
+    if (void 0 !== prim) {
+        var res = prim.call(input, hint || "default");
+        if ("object" !== audio_context_type_of(res)) return res;
+        throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === hint ? String : Number)(input);
+}
+function audio_context_to_property_key(arg) {
+    var key = audio_context_to_primitive(arg, "string");
+    return "symbol" === audio_context_type_of(key) ? key : String(key);
+}
+function audio_context_type_of(obj) {
+    return obj && "u" > typeof Symbol && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+let audio_context_computedKey;
+const { AudioContext: AudioContext } = native_native;
+inherits(AudioContext, base_audio_context_JsBaseAudioContext);
+audio_context_computedKey = audio_context_to_property_key(inspect.custom);
+class JsAudioContext extends AudioContext {
+    constructor(opts = {}){
+        if (void 0 === opts.sampleRate) super();
+        else super(opts.sampleRate);
+    }
+    [audio_context_computedKey]() {
+        return this.toString();
+    }
+    toString() {
+        return 'AudioContext {}';
+    }
+}
+const WrappedAudioContext = JsAudioContext;
+export { AnalyserNode, AudioBufferSourceNode, BiquadFilterNode, ConvolverNode, DelayNode, GainNode, JsAudioBuffer as AudioBuffer, JsAudioParam as AudioParam, OscillatorNode, PannerNode, WrappedAudioContext as AudioContext, nodes, nodes_AudioScheduledSourceNode as AudioScheduledSourceNode };

package/dist/native.d.ts

@@ -0,0 +1,252 @@
+import type { EventEmitter } from 'node:events';
+import '@node-3d/segfault';
+import '@node-3d/deps-labsound';
+export type TAudioEvent = Readonly<{
+    type: string;
+    [key: string]: unknown;
+}>;
+export type TAudioEventCallback<T extends TAudioEvent = TAudioEvent> = (event: T) => boolean | undefined;
+export type TAudioEventCallbackList<T extends TAudioEvent = TAudioEvent> = TAudioEventCallback<T> | readonly TAudioEventCallback<T>[] | null | undefined;
+export type TAudioContextState = 'closed' | 'interrupted' | 'running' | 'suspended';
+export type TChannelCountMode = 'clamped-max' | 'explicit' | 'max';
+export type TChannelInterpretation = 'discrete' | 'speakers';
+export type TDistanceModel = 'exponential' | 'inverse' | 'linear';
+export type TPanningModel = 'HRTF' | 'equalpower';
+export type TOscillatorType = 'custom' | 'sawtooth' | 'sine' | 'square' | 'triangle';
+export type TNativeExternal = object & {
+    readonly __nativeExternal: unique symbol;
+};
+export type TNativeConstructor<TArgs extends readonly unknown[], TInstance extends object> = {
+    prototype: TInstance;
+    new (...args: TArgs): TInstance;
+};
+export type TNativeEs5Constructor<TArgs extends readonly unknown[], TInstance extends object> = TNativeConstructor<TArgs, TInstance> & ((...args: TArgs) => TInstance);
+export type TAudioBufferData = ArrayLike<number> & object;
+export type TAudioBufferOptions = Readonly<{
+    length?: number;
+    numberOfChannels?: number;
+    sampleRate?: number;
+}>;
+export type TAudioContextOptions = Readonly<{
+    sampleRate?: number;
+}>;
+export type TAudioNodeOptions = Readonly<Record<string, unknown>>;
+export type TAudioObject = EventEmitter & {
+    destroy: () => void;
+};
+export type TNativeAudioParam = TAudioObject & {
+    value: number;
+    readonly defaultValue: number;
+    readonly maxValue: number;
+    readonly minValue: number;
+    cancelAndHoldAtTime: (startTime: number) => void;
+    cancelScheduledValues: (startTime: number) => void;
+    exponentialRampToValueAtTime: (value: number, time: number) => void;
+    linearRampToValueAtTime: (value: number, time: number) => void;
+    setTargetAtTime: (target: number, time: number, timeConstant: number) => void;
+    setValueAtTime: (value: number, time: number) => void;
+    setValueCurveAtTime: (values: readonly number[], time: number, duration: number) => void;
+};
+export type TAudioParam = TNativeAudioParam & {
+    onended: TAudioEventCallbackList;
+    onerror: TAudioEventCallbackList;
+};
+export type TAudioNode = TAudioObject & {
+    channelCount: number;
+    channelCountMode: TChannelCountMode;
+    channelInterpretation: TChannelInterpretation;
+    readonly context: TBaseAudioContext;
+    readonly numberOfInputs: number;
+    readonly numberOfOutputs: number;
+    connect: (destination: TAudioNode | TAudioParam, output?: number, input?: number) => void;
+    diagnose: () => void;
+    disconnect: (destination?: TAudioNode | TAudioParam | number, output?: number, input?: number) => void;
+    onended: TAudioEventCallbackList;
+    onerror: TAudioEventCallbackList;
+};
+export type TAudioBuffer = TAudioObject & {
+    readonly duration: number;
+    readonly length: number;
+    readonly numberOfChannels: number;
+    readonly sampleRate: number;
+    copyFromChannel: (destination: TAudioBufferData, channelNumber: number, startInChannel: number) => void;
+    copyToChannel: (source: TAudioBufferData, channelNumber: number, startInChannel: number) => void;
+    getChannelData: (channelIndex: number) => void;
+};
+export type TAudioListener = TAudioObject & {
+    readonly forwardX: TAudioParam;
+    readonly forwardY: TAudioParam;
+    readonly forwardZ: TAudioParam;
+    readonly positionX: TAudioParam;
+    readonly positionY: TAudioParam;
+    readonly positionZ: TAudioParam;
+    readonly upX: TAudioParam;
+    readonly upY: TAudioParam;
+    readonly upZ: TAudioParam;
+    setOrientation: (x: number, y: number, z: number, xUp: number, yUp: number, zUp: number) => void;
+    setPosition: (x: number, y: number, z: number) => void;
+};
+export type TBaseAudioContext = TAudioObject & {
+    readonly currentTime: number;
+    readonly destination: TAudioDestinationNode;
+    readonly listener: TAudioListener;
+    readonly sampleRate: number;
+    readonly state: TAudioContextState;
+    decodeAudioData: (source: Buffer, cb: (buffer: TAudioBuffer) => void) => void;
+    onerror: TAudioEventCallbackList;
+    onstatechange: TAudioEventCallbackList;
+    resume: () => void;
+    update: () => void;
+};
+export type TAudioContext = TBaseAudioContext & {
+    readonly baseLatency: number;
+    close: () => void;
+    getOutputTimestamp: () => void;
+    suspend: () => void;
+};
+export type TAudioDestinationNode = TAudioNode & {
+    readonly maxChannelCount: number;
+};
+export type TAudioScheduledSourceNode = TAudioNode & {
+    start: (when?: number) => void;
+    stop: (when?: number) => void;
+};
+export type TAnalyserNode = TAudioNode & {
+    fftSize: number;
+    maxDecibels: number;
+    minDecibels: number;
+    smoothingTimeConstant: number;
+    readonly frequencyBinCount: number;
+    getByteFrequencyData: (array: Uint8Array) => void;
+    getByteTimeDomainData: (array: Uint8Array) => void;
+    getFloatFrequencyData: (array: Float32Array) => void;
+    getFloatTimeDomainData: (array: Float32Array) => void;
+};
+export type TBiquadFilterNode = TAudioNode & {
+    type: number;
+    readonly Q: TAudioParam;
+    readonly detune: TAudioParam;
+    readonly frequency: TAudioParam;
+    readonly gain: TAudioParam;
+    getFrequencyResponse: () => void;
+};
+export type TConvolverNode = TAudioNode & {
+    buffer: TAudioBuffer;
+    normalize: boolean;
+};
+export type TDelayNode = TAudioNode & {
+    readonly delayTime: TAudioParam;
+};
+export type TGainNode = TAudioNode & {
+    readonly gain: TAudioParam;
+};
+export type TPannerNode = TAudioNode & {
+    coneInnerAngle: number;
+    coneOuterAngle: number;
+    coneOuterGain: number;
+    distanceModel: TDistanceModel;
+    maxDistance: number;
+    panningModel: TPanningModel;
+    readonly orientationX: TAudioParam;
+    readonly orientationY: TAudioParam;
+    readonly orientationZ: TAudioParam;
+    readonly positionX: TAudioParam;
+    readonly positionY: TAudioParam;
+    readonly positionZ: TAudioParam;
+    refDistance: number;
+    rolloffFactor: number;
+    setOrientation: (x: number, y: number, z: number) => void;
+    setPosition: (x: number, y: number, z: number) => void;
+    setVelocity: (x: number, y: number, z: number) => void;
+};
+export type TAudioBufferSourceNode = TAudioScheduledSourceNode & {
+    buffer: TAudioBuffer;
+    loop: boolean;
+    loopEnd: number;
+    loopStart: number;
+    readonly detune: TAudioParam;
+    readonly playbackRate: TAudioParam;
+    start: (when?: number, grainOffset?: number, grainDuration?: number) => void;
+};
+export type TOscillatorNode = TAudioScheduledSourceNode & {
+    type: TOscillatorType;
+    readonly detune: TAudioParam;
+    readonly frequency: TAudioParam;
+    setPeriodicWave: (periodicWave: object) => void;
+};
+export type TNative = Readonly<{
+    AnalyserNode: TNativeEs5Constructor<[
+        context: TBaseAudioContext,
+        paramCtor: TAudioParamConstructor,
+        opts: TAudioNodeOptions
+    ], TAnalyserNode>;
+    AudioBuffer: TNativeEs5Constructor<[
+        context: TBaseAudioContext,
+        source?: TNativeExternal | TAudioBufferOptions
+    ], TAudioBuffer>;
+    AudioBufferSourceNode: TNativeEs5Constructor<[
+        context: TBaseAudioContext,
+        paramCtor: TAudioParamConstructor,
+        opts: TAudioNodeOptions
+    ], TAudioBufferSourceNode>;
+    AudioContext: TNativeEs5Constructor<[sampleRate?: number], TAudioContext>;
+    AudioDestinationNode: TNativeEs5Constructor<[
+        context: TBaseAudioContext,
+        node: TNativeExternal
+    ], TAudioDestinationNode>;
+    AudioListener: TNativeEs5Constructor<[
+        context: TBaseAudioContext,
+        listener: TNativeExternal,
+        paramCtor: TAudioParamConstructor
+    ], TAudioListener>;
+    AudioNode: TNativeEs5Constructor<[
+        context: TBaseAudioContext,
+        node: TNativeExternal
+    ], TAudioNode>;
+    AudioParam: TAudioParamConstructor;
+    AudioScheduledSourceNode: TNativeEs5Constructor<[
+        context: TBaseAudioContext,
+        node: TNativeExternal
+    ], TAudioScheduledSourceNode>;
+    BaseAudioContext: TNativeEs5Constructor<[
+        context: TNativeExternal,
+        sampleRate: number
+    ], TBaseAudioContext> & {
+        hrtf: string;
+    };
+    BiquadFilterNode: TNativeEs5Constructor<[
+        context: TBaseAudioContext,
+        paramCtor: TAudioParamConstructor,
+        opts: TAudioNodeOptions
+    ], TBiquadFilterNode>;
+    ConvolverNode: TNativeEs5Constructor<[
+        context: TBaseAudioContext,
+        paramCtor: TAudioParamConstructor,
+        opts: TAudioNodeOptions
+    ], TConvolverNode>;
+    DelayNode: TNativeEs5Constructor<[
+        context: TBaseAudioContext,
+        paramCtor: TAudioParamConstructor,
+        opts: TAudioNodeOptions
+    ], TDelayNode>;
+    GainNode: TNativeEs5Constructor<[
+        context: TBaseAudioContext,
+        paramCtor: TAudioParamConstructor,
+        opts: TAudioNodeOptions
+    ], TGainNode>;
+    OscillatorNode: TNativeEs5Constructor<[
+        context: TBaseAudioContext,
+        paramCtor: TAudioParamConstructor,
+        opts: TAudioNodeOptions
+    ], TOscillatorNode>;
+    PannerNode: TNativeEs5Constructor<[
+        context: TBaseAudioContext,
+        paramCtor: TAudioParamConstructor,
+        opts: TAudioNodeOptions
+    ], TPannerNode>;
+}>;
+export type TAudioParamConstructor = TNativeConstructor<[
+    context: TBaseAudioContext,
+    param: TNativeExternal
+], TNativeAudioParam>;
+export declare const native: TNative;

package/dist/nodes.d.ts

@@ -0,0 +1,18 @@
+import type { TAnalyserNode, TAudioBufferSourceNode, TAudioNode, TAudioNodeOptions, TAudioScheduledSourceNode, TBaseAudioContext, TBiquadFilterNode, TConvolverNode, TDelayNode, TGainNode, TOscillatorNode, TPannerNode } from './native.ts';
+type TNodeConstructor<TInstance extends object = TAudioNode> = new (ctx: TBaseAudioContext, opts?: TAudioNodeOptions) => TInstance;
+type TExportedNodeName = 'AnalyserNode' | 'AudioBufferSourceNode' | 'AudioScheduledSourceNode' | 'BiquadFilterNode' | 'ConvolverNode' | 'DelayNode' | 'GainNode' | 'OscillatorNode' | 'PannerNode';
+type TNodeMap = {
+    AnalyserNode: TNodeConstructor<TAnalyserNode>;
+    AudioBufferSourceNode: TNodeConstructor<TAudioBufferSourceNode>;
+    AudioScheduledSourceNode: TNodeConstructor<TAudioScheduledSourceNode>;
+    BiquadFilterNode: TNodeConstructor<TBiquadFilterNode>;
+    ConvolverNode: TNodeConstructor<TConvolverNode>;
+    DelayNode: TNodeConstructor<TDelayNode>;
+    GainNode: TNodeConstructor<TGainNode>;
+    OscillatorNode: TNodeConstructor<TOscillatorNode>;
+    PannerNode: TNodeConstructor<TPannerNode>;
+} & Record<TExportedNodeName, TNodeConstructor> & Record<string, TNodeConstructor>;
+declare const nodes: TNodeMap;
+declare const AudioScheduledSourceNode: TNodeConstructor<TAudioScheduledSourceNode> & TNodeConstructor<TAudioNode>, AnalyserNode: TNodeConstructor<TAnalyserNode> & TNodeConstructor<TAudioNode>, BiquadFilterNode: TNodeConstructor<TBiquadFilterNode> & TNodeConstructor<TAudioNode>, ConvolverNode: TNodeConstructor<TConvolverNode> & TNodeConstructor<TAudioNode>, DelayNode: TNodeConstructor<TDelayNode> & TNodeConstructor<TAudioNode>, GainNode: TNodeConstructor<TGainNode> & TNodeConstructor<TAudioNode>, PannerNode: TNodeConstructor<TPannerNode> & TNodeConstructor<TAudioNode>, AudioBufferSourceNode: TNodeConstructor<TAudioBufferSourceNode> & TNodeConstructor<TAudioNode>, OscillatorNode: TNodeConstructor<TOscillatorNode> & TNodeConstructor<TAudioNode>;
+export { AudioScheduledSourceNode, AnalyserNode, BiquadFilterNode, ConvolverNode, DelayNode, GainNode, PannerNode, AudioBufferSourceNode, OscillatorNode, };
+export { nodes };

package/install.js

@@ -0,0 +1,6 @@
+import { install } from '@node-3d/addon-tools';
+
+const prefix = 'https://github.com/node-3d/webaudio/releases/download';
+const tag = '6.0.0';
+
+await install(`${prefix}/${tag}`);

package/package.json

@@ -0,0 +1,82 @@
+{
+	"author": "Luis Blanco <luisblanco1337@gmail.com>",
+	"name": "@node-3d/webaudio",
+	"version": "6.0.0",
+	"description": "Web Audio for Node.js",
+	"license": "MIT",
+	"main": "dist/index.js",
+	"keywords": [
+		"addon",
+		"webaudio",
+		"labsound",
+		"audio",
+		"sound",
+		"c++",
+		"bindings",
+		"native",
+		"gyp"
+	],
+	"files": [
+		"dist",
+		"install.js",
+		"LICENSE",
+		"package.json",
+		"tsconfig.json"
+	],
+	"engines": {
+		"node": ">=24.13.0",
+		"npm": ">=11.6.2"
+	},
+	"scripts": {
+		"postinstall": "node install.js",
+		"build:rebuild": "cd src && node-gyp rebuild -j max && node -e \"import('@node-3d/addon-tools').then((m) => m.cpbin('webaudio'))\"",
+		"build:compile": "cd src && node-gyp build -j max && node -e \"import('@node-3d/addon-tools').then((m) => m.cpbin('webaudio'))\"",
+		"test:watch": "node --test --watch \"ts/**/*.test.ts\"",
+		"test:ci": "node --test \"ts/**/*.test.ts\"",
+		"lint:all": "npm run lint:gypi && npm run lint:ts && npm run lint:oxlint",
+		"lint:gypi": "node -e \"import('@node-3d/addon-tools').then((m) => m.checkGypi())\"",
+		"lint:oxlint": "oxlint .",
+		"build:ci": "rslib build",
+		"build:watch": "rslib build --watch",
+		"lint:ts": "tsc -p tsconfig.json --noEmit",
+		"prepack": "npm run build:ci",
+		"format:src": "node -e \"import('@node-3d/addon-tools').then((m) => m.cpclangformat())\" && node -e \"const { readdirSync } = require('node:fs'); const { execFileSync } = require('node:child_process'); const { clangFormatPath } = require('clang-format-node'); const files = readdirSync('src/cpp').filter((file) => /\\.(?:cpp|hpp)$/.test(file)).map((file) => 'src/cpp/' + file); execFileSync(clangFormatPath, ['-i', ...files], { stdio: 'inherit' });\"",
+		"format:src:ci": "node -e \"import('@node-3d/addon-tools').then((m) => m.cpclangformat())\" && node -e \"const { readdirSync } = require('node:fs'); const { execFileSync } = require('node:child_process'); const { clangFormatPath } = require('clang-format-node'); const files = readdirSync('src/cpp').filter((file) => /\\.(?:cpp|hpp)$/.test(file)).map((file) => 'src/cpp/' + file); execFileSync(clangFormatPath, ['--dry-run', '--Werror', ...files], { stdio: 'inherit' });\"",
+		"format:ts": "oxfmt -c ./oxfmt.config.ts --no-error-on-unmatched-pattern \"**/*.{js,jsx,ts,tsx}\"",
+		"format:ts:ci": "oxfmt -c ./oxfmt.config.ts --check --no-error-on-unmatched-pattern \"**/*.{js,jsx,ts,tsx}\""
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/node-3d/webaudio.git"
+	},
+	"dependencies": {
+		"@node-3d/addon-tools": "~10.0.1",
+		"@node-3d/deps-labsound": "~7.0.0",
+		"@node-3d/segfault": "~4.0.0"
+	},
+	"devDependencies": {
+		"@types/node": "24.13.2",
+		"node-addon-api": "8.9.0",
+		"oxlint": "1.72.0",
+		"tslib": "2.8.1",
+		"@rslib/core": "0.23.2",
+		"oxfmt": "0.57.0",
+		"typescript": "7.0.2",
+		"clang-format-node": "3.0.7"
+	},
+	"type": "module",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		}
+	},
+	"bugs": {
+		"url": "https://github.com/node-3d/node-3d/issues"
+	},
+	"homepage": "https://github.com/node-3d/node-3d#readme",
+	"publishConfig": {
+		"access": "public"
+	}
+}

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+	"compilerOptions": {
+		"target": "ES2024",
+		"module": "ESNext",
+		"moduleResolution": "Bundler",
+		"strict": true,
+		"allowImportingTsExtensions": true,
+		"rewriteRelativeImportExtensions": true,
+		"declaration": true,
+		"declarationMap": false,
+		"sourceMap": false,
+		"rootDir": ".",
+		"outDir": "dist",
+		"paths": {
+			"@node-3d/webaudio": [
+				"./ts/index.ts"
+			]
+		},
+		"verbatimModuleSyntax": true,
+		"skipLibCheck": true,
+		"types": [
+			"node"
+		]
+	},
+	"include": [
+		"*.ts",
+		"ts/**/*.ts",
+		"examples/**/*.ts"
+	]
+}