react-native-audio-api 0.12.0-nightly-37d6b7c-20260119 → 0.12.0-nightly-75589dc-20260121

package/src/web-core/AudioContext.tsx

@@ -1,12 +1,5 @@
 import { InvalidAccessError, NotSupportedError } from '../errors';
-import {
-  AudioBufferBaseSourceNodeOptions,
-  AudioContextOptions,
-  ContextState,
-  DecodeDataInput,
-  IIRFilterNodeOptions,
-  PeriodicWaveConstraints,
-} from '../types';
+import { AudioContextOptions, ContextState, DecodeDataInput } from '../types';
 import AnalyserNode from './AnalyserNode';
 import AudioBuffer from './AudioBuffer';
 import AudioBufferSourceNode from './AudioBufferSourceNode';
@@ -14,16 +7,13 @@ import AudioDestinationNode from './AudioDestinationNode';
 import BaseAudioContext from './BaseAudioContext';
 import BiquadFilterNode from './BiquadFilterNode';
 import ConvolverNode from './ConvolverNode';
-import { ConvolverNodeOptions } from './ConvolverNodeOptions';
 import DelayNode from './DelayNode';
 import GainNode from './GainNode';
 import IIRFilterNode from './IIRFilterNode';
 import OscillatorNode from './OscillatorNode';
 import PeriodicWave from './PeriodicWave';
 import StereoPannerNode from './StereoPannerNode';
-
 import ConstantSourceNode from './ConstantSourceNode';
-import { globalTag, globalWasmPromise } from './custom/LoadCustomWasm';
 import WaveShaperNode from './WaveShaperNode';
 
 export default class AudioContext implements BaseAudioContext {
@@ -58,85 +48,49 @@ export default class AudioContext implements BaseAudioContext {
   }
 
   createOscillator(): OscillatorNode {
-    return new OscillatorNode(this, this.context.createOscillator());
+    return new OscillatorNode(this);
   }
 
   createConstantSource(): ConstantSourceNode {
-    return new ConstantSourceNode(this, this.context.createConstantSource());
+    return new ConstantSourceNode(this);
   }
 
   createGain(): GainNode {
-    return new GainNode(this, this.context.createGain());
+    return new GainNode(this);
   }
 
   createDelay(maxDelayTime?: number): DelayNode {
-    return new DelayNode(this, this.context.createDelay(maxDelayTime));
+    return new DelayNode(this, { maxDelayTime });
   }
 
   createStereoPanner(): StereoPannerNode {
-    return new StereoPannerNode(this, this.context.createStereoPanner());
+    return new StereoPannerNode(this);
   }
 
   createBiquadFilter(): BiquadFilterNode {
-    return new BiquadFilterNode(this, this.context.createBiquadFilter());
-  }
-
-  createIIRFilter(options: IIRFilterNodeOptions): IIRFilterNode {
-    return new IIRFilterNode(
-      this,
-      this.context.createIIRFilter(options.feedforward, options.feedback)
-    );
-  }
-
-  createConvolver(options?: ConvolverNodeOptions): ConvolverNode {
-    if (options?.buffer) {
-      const numberOfChannels = options.buffer.numberOfChannels;
-      if (
-        numberOfChannels !== 1 &&
-        numberOfChannels !== 2 &&
-        numberOfChannels !== 4
-      ) {
-        throw new NotSupportedError(
-          `The number of channels provided (${numberOfChannels}) in impulse response for ConvolverNode buffer must be 1 or 2 or 4.`
-        );
-      }
-    }
-    const buffer = options?.buffer ?? null;
-    const disableNormalization = options?.disableNormalization ?? false;
-    return new ConvolverNode(
-      this,
-      this.context.createConvolver(),
-      buffer,
-      disableNormalization
-    );
-  }
-
-  async createBufferSource(
-    options?: AudioBufferBaseSourceNodeOptions
-  ): Promise<AudioBufferSourceNode> {
-    if (!options || !options.pitchCorrection) {
-      return new AudioBufferSourceNode(
-        this,
-        this.context.createBufferSource(),
-        false
-      );
-    }
+    return new BiquadFilterNode(this);
+  }
 
-    await globalWasmPromise;
+  createConvolver(): ConvolverNode {
+    return new ConvolverNode(this);
+  }
 
-    const wasmStretch = await window[globalTag](this.context);
+  createIIRFilter(feedforward: number[], feedback: number[]): IIRFilterNode {
+    return new IIRFilterNode(this, { feedforward, feedback });
+  }
 
-    return new AudioBufferSourceNode(this, wasmStretch, true);
+  createBufferSource(pitchCorrection?: boolean): AudioBufferSourceNode {
+    return new AudioBufferSourceNode(this, { pitchCorrection });
   }
 
   createBuffer(
-    numOfChannels: number,
+    numberOfChannels: number,
     length: number,
     sampleRate: number
   ): AudioBuffer {
-    if (numOfChannels < 1 || numOfChannels >= 32) {
+    if (numberOfChannels < 1 || numberOfChannels >= 32) {
       throw new NotSupportedError(
-        `The number of channels provided (${numOfChannels}) is outside the range [1, 32]`
+        `The number of channels provided (${numberOfChannels}) is outside the range [1, 32]`
       );
     }
 
@@ -152,9 +106,7 @@ export default class AudioContext implements BaseAudioContext {
       );
     }
 
-    return new AudioBuffer(
-      this.context.createBuffer(numOfChannels, length, sampleRate)
-    );
+    return new AudioBuffer(this, { numberOfChannels, length, sampleRate });
   }
 
   createPeriodicWave(
@@ -168,13 +120,11 @@ export default class AudioContext implements BaseAudioContext {
       );
     }
 
-    return new PeriodicWave(
-      this.context.createPeriodicWave(real, imag, constraints)
-    );
+    return new PeriodicWave(this, { real, imag, ...constraints });
   }
 
   createAnalyser(): AnalyserNode {
-    return new AnalyserNode(this, this.context.createAnalyser());
+    return new AnalyserNode(this);
   }
 
   createWaveShaper(): WaveShaperNode {

package/src/web-core/AudioNode.tsx

@@ -10,7 +10,7 @@ export default class AudioNode {
   readonly channelCountMode: ChannelCountMode;
   readonly channelInterpretation: ChannelInterpretation;
 
-  protected readonly node: globalThis.AudioNode;
+  readonly node: globalThis.AudioNode;
 
   constructor(context: BaseAudioContext, node: globalThis.AudioNode) {
     this.context = context;
@@ -38,12 +38,16 @@ export default class AudioNode {
     return destination;
   }
 
-  public disconnect(destination?: AudioNode): void {
+  public disconnect(destination?: AudioNode | AudioParam): void {
     if (destination === undefined) {
       this.node.disconnect();
       return;
     }
 
+    if (destination instanceof AudioParam) {
+      this.node.disconnect(destination.param);
+      return;
+    }
     this.node.disconnect(destination.node);
   }
 }

package/src/web-core/BaseAudioContext.tsx

@@ -1,8 +1,4 @@
-import {
-  ContextState,
-  IIRFilterNodeOptions,
-  PeriodicWaveConstraints,
-} from '../types';
+import { ContextState } from '../types';
 import AnalyserNode from './AnalyserNode';
 import AudioBuffer from './AudioBuffer';
 import AudioBufferSourceNode from './AudioBufferSourceNode';
@@ -32,9 +28,9 @@ export default interface BaseAudioContext {
   createDelay(maxDelayTime?: number): DelayNode;
   createStereoPanner(): StereoPannerNode;
   createBiquadFilter(): BiquadFilterNode;
-  createIIRFilter(options: IIRFilterNodeOptions): IIRFilterNode;
+  createIIRFilter(feedforward: number[], feedback: number[]): IIRFilterNode;
   createConvolver(): ConvolverNode;
-  createBufferSource(): Promise<AudioBufferSourceNode>;
+  createBufferSource(): AudioBufferSourceNode;
   createBuffer(
     numOfChannels: number,
     length: number,

package/src/web-core/BiquadFilterNode.tsx

@@ -1,8 +1,8 @@
 import AudioParam from './AudioParam';
 import AudioNode from './AudioNode';
 import BaseAudioContext from './BaseAudioContext';
-import { BiquadFilterType } from '../types';
 import { InvalidAccessError } from '../errors';
+import { TBiquadFilterOptions } from '../types';
 
 export default class BiquadFilterNode extends AudioNode {
   readonly frequency: AudioParam;
@@ -12,8 +12,12 @@ export default class BiquadFilterNode extends AudioNode {
 
   constructor(
     context: BaseAudioContext,
-    biquadFilter: globalThis.BiquadFilterNode
+    biquadFilterOptions?: TBiquadFilterOptions
   ) {
+    const biquadFilter = new globalThis.BiquadFilterNode(
+      context.context,
+      biquadFilterOptions
+    );
     super(context, biquadFilter);
     this.frequency = new AudioParam(biquadFilter.frequency, context);
     this.detune = new AudioParam(biquadFilter.detune, context);

package/src/web-core/ConstantSourceNode.tsx

@@ -1,11 +1,13 @@
 import AudioParam from './AudioParam';
 import AudioScheduledSourceNode from './AudioScheduledSourceNode';
 import BaseAudioContext from './BaseAudioContext';
+import { TConstantSourceOptions } from '../types';
 
 export default class ConstantSourceNode extends AudioScheduledSourceNode {
   readonly offset: AudioParam;
 
-  constructor(context: BaseAudioContext, node: globalThis.ConstantSourceNode) {
+  constructor(context: BaseAudioContext, options?: TConstantSourceOptions) {
+    const node = new globalThis.ConstantSourceNode(context.context, options);
     super(context, node);
     this.offset = new AudioParam(node.offset, context);
   }

package/src/web-core/ConvolverNode.tsx

@@ -1,20 +1,20 @@
 import BaseAudioContext from './BaseAudioContext';
 import AudioNode from './AudioNode';
 import AudioBuffer from './AudioBuffer';
+import { TWebConvolverOptions } from '../types';
 
 export default class ConvolverNode extends AudioNode {
   constructor(
     context: BaseAudioContext,
-    node: globalThis.ConvolverNode,
-    buffer: AudioBuffer | null = null,
-    disableNormalization: boolean = false
+    convolverOptions?: TWebConvolverOptions
   ) {
-    super(context, node);
+    const convolver = new globalThis.ConvolverNode(
+      context.context,
+      convolverOptions
+    );
 
-    (this.node as globalThis.ConvolverNode).normalize = !disableNormalization;
-    if (buffer) {
-      (this.node as globalThis.ConvolverNode).buffer = buffer.buffer;
-    }
+    const node = convolver;
+    super(context, node);
   }
 
   public get buffer(): AudioBuffer | null {

package/src/web-core/DelayNode.tsx

@@ -1,11 +1,15 @@
 import BaseAudioContext from './BaseAudioContext';
 import AudioNode from './AudioNode';
 import AudioParam from './AudioParam';
+import { TDelayOptions } from '../types';
+import { DelayOptions } from '../defaults';
 
 export default class DelayNode extends AudioNode {
   readonly delayTime: AudioParam;
 
-  constructor(context: BaseAudioContext, delay: globalThis.DelayNode) {
+  constructor(context: BaseAudioContext, options?: TDelayOptions) {
+    const finalOptions = { ...DelayOptions, ...options };
+    const delay = new globalThis.DelayNode(context.context, finalOptions);
     super(context, delay);
     this.delayTime = new AudioParam(delay.delayTime, context);
   }

package/src/web-core/GainNode.tsx

@@ -1,11 +1,13 @@
 import BaseAudioContext from './BaseAudioContext';
 import AudioNode from './AudioNode';
 import AudioParam from './AudioParam';
+import { TGainOptions } from '../types';
 
 export default class GainNode extends AudioNode {
   readonly gain: AudioParam;
 
-  constructor(context: BaseAudioContext, gain: globalThis.GainNode) {
+  constructor(context: BaseAudioContext, gainOptions?: TGainOptions) {
+    const gain = new globalThis.GainNode(context.context, gainOptions);
     super(context, gain);
     this.gain = new AudioParam(gain.gain, context);
   }

package/src/web-core/IIRFilterNode.tsx

@@ -1,7 +1,22 @@
 import { NotSupportedError } from '../errors';
 import AudioNode from './AudioNode';
+import { TIIRFilterOptions } from '../types';
+import { AudioNodeOptions } from '../defaults';
+import BaseAudioContext from './BaseAudioContext';
 
 export default class IIRFilterNode extends AudioNode {
+  constructor(context: BaseAudioContext, options: TIIRFilterOptions) {
+    const finalOptions: TIIRFilterOptions = {
+      ...AudioNodeOptions,
+      ...options,
+    };
+    const iirFilterNode = new globalThis.IIRFilterNode(context.context, {
+      feedforward: finalOptions.feedforward,
+      feedback: finalOptions.feedback,
+    });
+    super(context, iirFilterNode);
+  }
+
   public getFrequencyResponse(
     frequencyArray: Float32Array,
     magResponseOutput: Float32Array,

package/src/web-core/OfflineAudioContext.tsx

@@ -1,10 +1,4 @@
-import {
-  ContextState,
-  PeriodicWaveConstraints,
-  OfflineAudioContextOptions,
-  AudioBufferBaseSourceNodeOptions,
-  IIRFilterNodeOptions,
-} from '../types';
+import { ContextState, OfflineAudioContextOptions } from '../types';
 import { InvalidAccessError, NotSupportedError } from '../errors';
 import BaseAudioContext from './BaseAudioContext';
 import AnalyserNode from './AnalyserNode';
@@ -20,9 +14,7 @@ import StereoPannerNode from './StereoPannerNode';
 import ConstantSourceNode from './ConstantSourceNode';
 import WaveShaperNode from './WaveShaperNode';
 
-import { globalWasmPromise, globalTag } from './custom/LoadCustomWasm';
 import ConvolverNode from './ConvolverNode';
-import { ConvolverNodeOptions } from './ConvolverNodeOptions';
 import DelayNode from './DelayNode';
 
 export default class OfflineAudioContext implements BaseAudioContext {
@@ -63,85 +55,49 @@ export default class OfflineAudioContext implements BaseAudioContext {
   }
 
   createOscillator(): OscillatorNode {
-    return new OscillatorNode(this, this.context.createOscillator());
+    return new OscillatorNode(this);
   }
 
   createConstantSource(): ConstantSourceNode {
-    return new ConstantSourceNode(this, this.context.createConstantSource());
+    return new ConstantSourceNode(this);
   }
 
   createGain(): GainNode {
-    return new GainNode(this, this.context.createGain());
+    return new GainNode(this);
   }
 
   createDelay(maxDelayTime?: number): DelayNode {
-    return new DelayNode(this, this.context.createDelay(maxDelayTime));
+    return new DelayNode(this, { maxDelayTime });
   }
 
   createStereoPanner(): StereoPannerNode {
-    return new StereoPannerNode(this, this.context.createStereoPanner());
+    return new StereoPannerNode(this);
   }
 
   createBiquadFilter(): BiquadFilterNode {
-    return new BiquadFilterNode(this, this.context.createBiquadFilter());
+    return new BiquadFilterNode(this);
   }
 
-  createIIRFilter(options: IIRFilterNodeOptions): IIRFilterNode {
-    return new IIRFilterNode(
-      this,
-      this.context.createIIRFilter(options.feedforward, options.feedback)
-    );
+  createConvolver(): ConvolverNode {
+    return new ConvolverNode(this);
   }
 
-  createConvolver(options?: ConvolverNodeOptions): ConvolverNode {
-    if (options?.buffer) {
-      const numberOfChannels = options.buffer.numberOfChannels;
-      if (
-        numberOfChannels !== 1 &&
-        numberOfChannels !== 2 &&
-        numberOfChannels !== 4
-      ) {
-        throw new NotSupportedError(
-          `The number of channels provided (${numberOfChannels}) in impulse response for ConvolverNode buffer must be 1 or 2 or 4.`
-        );
-      }
-    }
-    const buffer = options?.buffer ?? null;
-    const disableNormalization = options?.disableNormalization ?? false;
-    return new ConvolverNode(
-      this,
-      this.context.createConvolver(),
-      buffer,
-      disableNormalization
-    );
+  createIIRFilter(feedforward: number[], feedback: number[]): IIRFilterNode {
+    return new IIRFilterNode(this, { feedforward, feedback });
   }
 
-  async createBufferSource(
-    options?: AudioBufferBaseSourceNodeOptions
-  ): Promise<AudioBufferSourceNode> {
-    if (!options || !options.pitchCorrection) {
-      return new AudioBufferSourceNode(
-        this,
-        this.context.createBufferSource(),
-        false
-      );
-    }
-
-    await globalWasmPromise;
-
-    const wasmStretch = await window[globalTag](this.context);
-
-    return new AudioBufferSourceNode(this, wasmStretch, true);
+  createBufferSource(pitchCorrection?: boolean): AudioBufferSourceNode {
+    return new AudioBufferSourceNode(this, { pitchCorrection });
   }
 
   createBuffer(
-    numOfChannels: number,
+    numberOfChannels: number,
     length: number,
     sampleRate: number
   ): AudioBuffer {
-    if (numOfChannels < 1 || numOfChannels >= 32) {
+    if (numberOfChannels < 1 || numberOfChannels >= 32) {
       throw new NotSupportedError(
-        `The number of channels provided (${numOfChannels}) is outside the range [1, 32]`
+        `The number of channels provided (${numberOfChannels}) is outside the range [1, 32]`
       );
     }
 
@@ -157,9 +113,7 @@ export default class OfflineAudioContext implements BaseAudioContext {
       );
     }
 
-    return new AudioBuffer(
-      this.context.createBuffer(numOfChannels, length, sampleRate)
-    );
+    return new AudioBuffer(this, { numberOfChannels, length, sampleRate });
   }
 
   createPeriodicWave(
@@ -173,13 +127,11 @@ export default class OfflineAudioContext implements BaseAudioContext {
       );
     }
 
-    return new PeriodicWave(
-      this.context.createPeriodicWave(real, imag, constraints)
-    );
+    return new PeriodicWave(this, { real, imag, ...constraints });
   }
 
   createAnalyser(): AnalyserNode {
-    return new AnalyserNode(this, this.context.createAnalyser());
+    return new AnalyserNode(this);
   }
 
   createWaveShaper(): WaveShaperNode {

package/src/web-core/OscillatorNode.tsx

@@ -1,4 +1,4 @@
-import { OscillatorType } from '../types';
+import { OscillatorType, TOscillatorOptions } from '../types';
 import { InvalidStateError } from '../errors';
 import AudioScheduledSourceNode from './AudioScheduledSourceNode';
 import BaseAudioContext from './BaseAudioContext';
@@ -9,7 +9,8 @@ export default class OscillatorNode extends AudioScheduledSourceNode {
   readonly frequency: AudioParam;
   readonly detune: AudioParam;
 
-  constructor(context: BaseAudioContext, node: globalThis.OscillatorNode) {
+  constructor(context: BaseAudioContext, options?: TOscillatorOptions) {
+    const node = new globalThis.OscillatorNode(context.context, options);
     super(context, node);
 
     this.detune = new AudioParam(node.detune, context);

package/src/web-core/PeriodicWave.tsx

@@ -1,8 +1,18 @@
+import BaseAudioContext from './BaseAudioContext';
+import { TPeriodicWaveOptions } from '../types';
+import { generateRealAndImag } from '../core/PeriodicWave';
+
 export default class PeriodicWave {
   /** @internal */
   readonly periodicWave: globalThis.PeriodicWave;
 
-  constructor(periodicWave: globalThis.PeriodicWave) {
+  constructor(context: BaseAudioContext, options?: TPeriodicWaveOptions) {
+    const finalOptions = generateRealAndImag(options);
+    const periodicWave = context.context.createPeriodicWave(
+      finalOptions.real!,
+      finalOptions.imag!,
+      { disableNormalization: finalOptions.disableNormalization }
+    );
     this.periodicWave = periodicWave;
   }
 }

package/src/web-core/StereoPannerNode.tsx

@@ -1,11 +1,19 @@
 import BaseAudioContext from './BaseAudioContext';
 import AudioNode from './AudioNode';
 import AudioParam from './AudioParam';
+import { TSteroPannerOptions } from '../types';
 
 export default class StereoPannerNode extends AudioNode {
   readonly pan: AudioParam;
 
-  constructor(context: BaseAudioContext, pan: globalThis.StereoPannerNode) {
+  constructor(
+    context: BaseAudioContext,
+    stereoPannerOptions?: TSteroPannerOptions
+  ) {
+    const pan = new globalThis.StereoPannerNode(
+      context.context,
+      stereoPannerOptions
+    );
     super(context, pan);
     this.pan = new AudioParam(pan.pan, context);
   }