react-native-audio-api 0.12.0-nightly-0d1a19d-20260120 → 0.12.0-nightly-75589dc-20260121

package/src/core/BaseAudioContext.ts

@@ -1,19 +1,10 @@
-import AudioAPIModule from '../AudioAPIModule';
 import {
   InvalidAccessError,
   InvalidStateError,
   NotSupportedError,
 } from '../errors';
 import { IBaseAudioContext } from '../interfaces';
-import {
-  AudioBufferBaseSourceNodeOptions,
-  AudioWorkletRuntime,
-  ContextState,
-  ConvolverNodeOptions,
-  DecodeDataInput,
-  IIRFilterNodeOptions,
-  PeriodicWaveConstraints,
-} from '../types';
+import { AudioWorkletRuntime, ContextState, DecodeDataInput } from '../types';
 import { assertWorkletsEnabled } from '../utils';
 import AnalyserNode from './AnalyserNode';
 import AudioBuffer from './AudioBuffer';
@@ -96,26 +87,12 @@ export default class BaseAudioContext {
     }
 
     assertWorkletsEnabled();
-
-    const shareableWorklet =
-      AudioAPIModule.workletsModule!.makeShareableCloneRecursive(
-        (audioBuffers: Array<ArrayBuffer>, channelCount: number) => {
-          'worklet';
-          const floatAudioData: Array<Float32Array> = audioBuffers.map(
-            (buffer) => new Float32Array(buffer)
-          );
-          callback(floatAudioData, channelCount);
-        }
-      );
-
     return new WorkletNode(
       this,
-      this.context.createWorkletNode(
-        shareableWorklet,
-        workletRuntime === 'UIRuntime',
-        bufferLength,
-        inputChannelCount
-      )
+      workletRuntime,
+      callback,
+      bufferLength,
+      inputChannelCount
     );
   }
 
@@ -129,33 +106,7 @@ export default class BaseAudioContext {
     workletRuntime: AudioWorkletRuntime = 'AudioRuntime'
   ): WorkletProcessingNode {
     assertWorkletsEnabled();
-
-    const shareableWorklet =
-      AudioAPIModule.workletsModule!.makeShareableCloneRecursive(
-        (
-          inputBuffers: Array<ArrayBuffer>,
-          outputBuffers: Array<ArrayBuffer>,
-          framesToProcess: number,
-          currentTime: number
-        ) => {
-          'worklet';
-          const inputData: Array<Float32Array> = inputBuffers.map(
-            (buffer) => new Float32Array(buffer, 0, framesToProcess)
-          );
-          const outputData: Array<Float32Array> = outputBuffers.map(
-            (buffer) => new Float32Array(buffer, 0, framesToProcess)
-          );
-          callback(inputData, outputData, framesToProcess, currentTime);
-        }
-      );
-
-    return new WorkletProcessingNode(
-      this,
-      this.context.createWorkletProcessingNode(
-        shareableWorklet,
-        workletRuntime === 'UIRuntime'
-      )
-    );
+    return new WorkletProcessingNode(this, workletRuntime, callback);
   }
 
   createWorkletSourceNode(
@@ -168,71 +119,56 @@ export default class BaseAudioContext {
     workletRuntime: AudioWorkletRuntime = 'AudioRuntime'
   ): WorkletSourceNode {
     assertWorkletsEnabled();
-    const shareableWorklet =
-      AudioAPIModule.workletsModule!.makeShareableCloneRecursive(
-        (
-          audioBuffers: Array<ArrayBuffer>,
-          framesToProcess: number,
-          currentTime: number,
-          startOffset: number
-        ) => {
-          'worklet';
-          const floatAudioData: Array<Float32Array> = audioBuffers.map(
-            (buffer) => new Float32Array(buffer)
-          );
-          callback(floatAudioData, framesToProcess, currentTime, startOffset);
-        }
-      );
-
-    return new WorkletSourceNode(
-      this,
-      this.context.createWorkletSourceNode(
-        shareableWorklet,
-        workletRuntime === 'UIRuntime'
-      )
-    );
+    return new WorkletSourceNode(this, workletRuntime, callback);
   }
 
   createRecorderAdapter(): RecorderAdapterNode {
-    return new RecorderAdapterNode(this, this.context.createRecorderAdapter());
+    return new RecorderAdapterNode(this);
   }
 
   createOscillator(): OscillatorNode {
-    return new OscillatorNode(this, this.context.createOscillator());
+    return new OscillatorNode(this);
   }
 
   createStreamer(): StreamerNode {
-    const streamer = this.context.createStreamer();
-    if (!streamer) {
-      throw new NotSupportedError('StreamerNode requires FFmpeg build');
-    }
-    return new StreamerNode(this, streamer);
+    return new StreamerNode(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 {
-    const maxTime = maxDelayTime ?? 1.0;
-    return new DelayNode(this, this.context.createDelay(maxTime));
+    if (maxDelayTime !== undefined) {
+      return new DelayNode(this, { maxDelayTime });
+    } else {
+      return new DelayNode(this);
+    }
   }
 
   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);
+  }
+
+  createBufferSource(options: {
+    pitchCorrection?: boolean;
+  }): AudioBufferSourceNode {
+    if (options.pitchCorrection !== undefined) {
+      return new AudioBufferSourceNode(this, options);
+    } else {
+      return new AudioBufferSourceNode(this);
+    }
   }
 
-  createIIRFilter(options: IIRFilterNodeOptions): IIRFilterNode {
-    const feedforward = options.feedforward;
-    const feedback = options.feedback;
+  createIIRFilter(feedforward: number[], feedback: number[]): IIRFilterNode {
     if (feedforward.length < 1 || feedforward.length > 20) {
       throw new NotSupportedError(
         `The provided feedforward array has length (${feedforward.length}) outside the range [1, 20]`
@@ -256,42 +192,27 @@ export default class BaseAudioContext {
       );
     }
 
-    return new IIRFilterNode(
-      this,
-      this.context.createIIRFilter(feedforward, feedback)
-    );
+    return new IIRFilterNode(this, { feedforward, feedback });
   }
 
-  createBufferSource(
-    options?: AudioBufferBaseSourceNodeOptions
-  ): AudioBufferSourceNode {
-    const pitchCorrection = options?.pitchCorrection ?? false;
-
-    return new AudioBufferSourceNode(
-      this,
-      this.context.createBufferSource(pitchCorrection)
-    );
-  }
-
-  createBufferQueueSource(
-    options?: AudioBufferBaseSourceNodeOptions
-  ): AudioBufferQueueSourceNode {
-    const pitchCorrection = options?.pitchCorrection ?? false;
-
-    return new AudioBufferQueueSourceNode(
-      this,
-      this.context.createBufferQueueSource(pitchCorrection)
-    );
+  createBufferQueueSource(options: {
+    pitchCorrection?: boolean;
+  }): AudioBufferQueueSourceNode {
+    if (options.pitchCorrection !== undefined) {
+      return new AudioBufferQueueSourceNode(this, options);
+    } else {
+      return new AudioBufferQueueSourceNode(this);
+    }
   }
 
   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]`
       );
     }
 
@@ -307,9 +228,7 @@ export default class BaseAudioContext {
       );
     }
 
-    return new AudioBuffer(
-      this.context.createBuffer(numOfChannels, length, sampleRate)
-    );
+    return new AudioBuffer(this, { numberOfChannels, length, sampleRate });
   }
 
   createPeriodicWave(
@@ -322,40 +241,18 @@ export default class BaseAudioContext {
         `The lengths of the real (${real.length}) and imaginary (${imag.length}) arrays must match.`
       );
     }
-
-    const disableNormalization = constraints?.disableNormalization ?? false;
-
-    return new PeriodicWave(
-      this.context.createPeriodicWave(real, imag, disableNormalization)
-    );
+    return new PeriodicWave(this, { real, imag, ...constraints });
   }
 
   createAnalyser(): AnalyserNode {
-    return new AnalyserNode(this, this.context.createAnalyser());
+    return new AnalyserNode(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?.buffer, disableNormalization)
-    );
+  createConvolver(): ConvolverNode {
+    return new ConvolverNode(this);
   }
 
   createWaveShaper(): WaveShaperNode {
-    return new WaveShaperNode(this, this.context.createWaveShaper());
+    return new WaveShaperNode(this);
   }
 }

package/src/core/BiquadFilterNode.ts

@@ -3,7 +3,8 @@ import { IBiquadFilterNode } from '../interfaces';
 import AudioNode from './AudioNode';
 import AudioParam from './AudioParam';
 import BaseAudioContext from './BaseAudioContext';
-import { BiquadFilterType } from '../types';
+import { BiquadFilterOptions } from '../defaults';
+import { TBiquadFilterOptions } from '../types';
 
 export default class BiquadFilterNode extends AudioNode {
   readonly frequency: AudioParam;
@@ -11,7 +12,13 @@ export default class BiquadFilterNode extends AudioNode {
   readonly Q: AudioParam;
   readonly gain: AudioParam;
 
-  constructor(context: BaseAudioContext, biquadFilter: IBiquadFilterNode) {
+  constructor(context: BaseAudioContext, options?: TBiquadFilterOptions) {
+    const finalOptions: TBiquadFilterOptions = {
+      ...BiquadFilterOptions,
+      ...options,
+    };
+    const biquadFilter: IBiquadFilterNode =
+      context.context.createBiquadFilter(finalOptions);
     super(context, biquadFilter);
     this.frequency = new AudioParam(biquadFilter.frequency, context);
     this.detune = new AudioParam(biquadFilter.detune, context);

package/src/core/ConstantSourceNode.ts

@@ -1,4 +1,6 @@
 import { IConstantSourceNode } from '../interfaces';
+import { ConstantSourceOptions } from '../defaults';
+import { TConstantSourceOptions } from '../types';
 import AudioParam from './AudioParam';
 import AudioScheduledSourceNode from './AudioScheduledSourceNode';
 import BaseAudioContext from './BaseAudioContext';
@@ -6,7 +8,13 @@ import BaseAudioContext from './BaseAudioContext';
 export default class ConstantSourceNode extends AudioScheduledSourceNode {
   readonly offset: AudioParam;
 
-  constructor(context: BaseAudioContext, node: IConstantSourceNode) {
+  constructor(context: BaseAudioContext, options?: TConstantSourceOptions) {
+    const finalOptions: TConstantSourceOptions = {
+      ...ConstantSourceOptions,
+      ...options,
+    };
+    const node: IConstantSourceNode =
+      context.context.createConstantSource(finalOptions);
     super(context, node);
     this.offset = new AudioParam(node.offset, context);
   }

package/src/core/ConvolverNode.ts

@@ -1,12 +1,20 @@
 import { IConvolverNode } from '../interfaces';
+import { ConvolverOptions } from '../defaults';
+import { TConvolverOptions } from '../types';
 import BaseAudioContext from './BaseAudioContext';
 import AudioNode from './AudioNode';
 import AudioBuffer from './AudioBuffer';
 
 export default class ConvolverNode extends AudioNode {
-  constructor(context: BaseAudioContext, node: IConvolverNode) {
-    super(context, node);
-    this.normalize = node.normalize;
+  constructor(context: BaseAudioContext, options?: TConvolverOptions) {
+    const finalOptions: TConvolverOptions = {
+      ...ConvolverOptions,
+      ...options,
+    };
+    const convolverNode: IConvolverNode =
+      context.context.createConvolver(finalOptions);
+    super(context, convolverNode);
+    this.normalize = convolverNode.normalize;
   }
 
   public get buffer(): AudioBuffer | null {

package/src/core/DelayNode.ts

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

package/src/core/GainNode.ts

@@ -1,4 +1,6 @@
 import { IGainNode } from '../interfaces';
+import { GainOptions } from '../defaults';
+import { TGainOptions } from '../types';
 import AudioNode from './AudioNode';
 import AudioParam from './AudioParam';
 import BaseAudioContext from './BaseAudioContext';
@@ -6,8 +8,13 @@ import BaseAudioContext from './BaseAudioContext';
 export default class GainNode extends AudioNode {
   readonly gain: AudioParam;
 
-  constructor(context: BaseAudioContext, gain: IGainNode) {
-    super(context, gain);
-    this.gain = new AudioParam(gain.gain, context);
+  constructor(context: BaseAudioContext, options?: TGainOptions) {
+    const finalOptions: TGainOptions = {
+      ...GainOptions,
+      ...options,
+    };
+    const gainNode: IGainNode = context.context.createGain(finalOptions);
+    super(context, gainNode);
+    this.gain = new AudioParam(gainNode.gain, context);
   }
 }

package/src/core/IIRFilterNode.ts

@@ -1,8 +1,20 @@
 import { NotSupportedError } from '../errors';
 import { IIIRFilterNode } from '../interfaces';
 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 = context.context.createIIRFilter(finalOptions);
+    super(context, iirFilterNode);
+  }
+
   public getFrequencyResponse(
     frequencyArray: Float32Array,
     magResponseOutput: Float32Array,

package/src/core/OscillatorNode.ts

@@ -1,17 +1,28 @@
 import { IOscillatorNode } from '../interfaces';
-import { OscillatorType } from '../types';
 import AudioScheduledSourceNode from './AudioScheduledSourceNode';
 import AudioParam from './AudioParam';
 import BaseAudioContext from './BaseAudioContext';
 import PeriodicWave from './PeriodicWave';
 import { InvalidStateError } from '../errors';
 import { EventEmptyType } from '../events/types';
+import { OscillatorOptions } from '../defaults';
+import { TOscillatorOptions } from '../types';
 
 export default class OscillatorNode extends AudioScheduledSourceNode {
   readonly frequency: AudioParam;
   readonly detune: AudioParam;
 
-  constructor(context: BaseAudioContext, node: IOscillatorNode) {
+  constructor(context: BaseAudioContext, options?: TOscillatorOptions) {
+    const finalOptions: TOscillatorOptions = {
+      ...OscillatorOptions,
+      ...options,
+    };
+
+    if (finalOptions.periodicWave) {
+      finalOptions.type = 'custom';
+    }
+
+    const node = context.context.createOscillator(finalOptions);
     super(context, node);
     this.frequency = new AudioParam(node.frequency, context);
     this.detune = new AudioParam(node.detune, context);

package/src/core/PeriodicWave.ts

@@ -1,10 +1,44 @@
 import { IPeriodicWave } from '../interfaces';
+import BaseAudioContext from './BaseAudioContext';
+import { TPeriodicWaveOptions } from '../types';
+import { PeriodicWaveConstraints } from '../defaults';
+import { PeriodicWaveOptionsValidator } from '../options-validators';
+
+export function generateRealAndImag(
+  options?: TPeriodicWaveOptions
+): TPeriodicWaveOptions {
+  let real: Float32Array | undefined;
+  let imag: Float32Array | undefined;
+  if (!options || (!options.real && !options.imag)) {
+    real = new Float32Array(2);
+    imag = new Float32Array(2);
+    imag[1] = 1;
+  } else {
+    real = options.real;
+    imag = options.imag;
+    PeriodicWaveOptionsValidator.validate(options);
+    if (real && !imag) {
+      imag = new Float32Array(real.length);
+    } else if (!real && imag) {
+      real = new Float32Array(imag.length);
+    }
+  }
+  const norm: boolean = options?.disableNormalization
+    ? options.disableNormalization
+    : PeriodicWaveConstraints.disableNormalization!;
+  return { real, imag, disableNormalization: norm };
+}
 
 export default class PeriodicWave {
   /** @internal */
   public readonly periodicWave: IPeriodicWave;
 
-  constructor(periodicWave: IPeriodicWave) {
-    this.periodicWave = periodicWave;
+  constructor(context: BaseAudioContext, options?: TPeriodicWaveOptions) {
+    const finalOptions = generateRealAndImag(options);
+    this.periodicWave = context.context.createPeriodicWave(
+      finalOptions.real!,
+      finalOptions.imag!,
+      finalOptions.disableNormalization!
+    );
   }
 }

package/src/core/RecorderAdapterNode.ts

@@ -1,10 +1,15 @@
 import { IRecorderAdapterNode } from '../interfaces';
 import AudioNode from './AudioNode';
+import BaseAudioContext from './BaseAudioContext';
 
 export default class RecorderAdapterNode extends AudioNode {
   /** @internal */
   public wasConnected: boolean = false;
 
+  constructor(context: BaseAudioContext) {
+    super(context, context.context.createRecorderAdapter());
+  }
+
   /** @internal */
   public getNode(): IRecorderAdapterNode {
     return this.node as IRecorderAdapterNode;

package/src/core/StereoPannerNode.ts

@@ -1,4 +1,6 @@
 import { IStereoPannerNode } from '../interfaces';
+import { SteroPannerOptions } from '../defaults';
+import { TSteroPannerOptions } from '../types';
 import AudioNode from './AudioNode';
 import AudioParam from './AudioParam';
 import BaseAudioContext from './BaseAudioContext';
@@ -6,7 +8,13 @@ import BaseAudioContext from './BaseAudioContext';
 export default class StereoPannerNode extends AudioNode {
   readonly pan: AudioParam;
 
-  constructor(context: BaseAudioContext, pan: IStereoPannerNode) {
+  constructor(context: BaseAudioContext, options?: TSteroPannerOptions) {
+    const finalOptions: TSteroPannerOptions = {
+      ...SteroPannerOptions,
+      ...options,
+    };
+    const pan: IStereoPannerNode =
+      context.context.createStereoPanner(finalOptions);
     super(context, pan);
     this.pan = new AudioParam(pan.pan, context);
   }

package/src/core/StreamerNode.ts

@@ -1,8 +1,36 @@
 import { IStreamerNode } from '../interfaces';
 import AudioScheduledSourceNode from './AudioScheduledSourceNode';
+import { TStreamerOptions } from '../types';
+import { InvalidStateError, NotSupportedError } from '../errors';
+import BaseAudioContext from './BaseAudioContext';
 
 export default class StreamerNode extends AudioScheduledSourceNode {
+  private hasBeenSetup: boolean = false;
+  constructor(context: BaseAudioContext, options?: TStreamerOptions) {
+    const node = context.context.createStreamer(options);
+    if (!node) {
+      throw new NotSupportedError('StreamerNode requires FFmpeg build');
+    }
+    super(context, node);
+    if (options?.streamPath) {
+      if (this.initialize(options.streamPath)) {
+        this.hasBeenSetup = true;
+      }
+    }
+  }
+
   public initialize(streamPath: string): boolean {
-    return (this.node as IStreamerNode).initialize(streamPath);
+    if (this.hasBeenSetup) {
+      throw new InvalidStateError('Node is already setup');
+    }
+    const res = (this.node as IStreamerNode).initialize(streamPath);
+    if (res) {
+      this.hasBeenSetup = true;
+    }
+    return res;
+  }
+
+  public get streamPath(): string {
+    return (this.node as IStreamerNode).streamPath;
   }
 }

package/src/core/WaveShaperNode.ts

@@ -1,10 +1,27 @@
 import AudioNode from './AudioNode';
+import BaseAudioContext from './BaseAudioContext';
 import { InvalidStateError } from '../errors';
 import { IWaveShaperNode } from '../interfaces';
+import { WaveShaperOptions } from '../defaults';
+import { TWaveShaperOptions } from '../types';
 
 export default class WaveShaperNode extends AudioNode {
   private isCurveSet: boolean = false;
 
+  constructor(context: BaseAudioContext, options?: TWaveShaperOptions) {
+    const finalOptions: TWaveShaperOptions = {
+      ...WaveShaperOptions,
+      ...options,
+    };
+
+    const node = context.context.createWaveShaper(finalOptions);
+    super(context, node);
+
+    if (finalOptions.curve) {
+      this.isCurveSet = true;
+    }
+  }
+
   get curve(): Float32Array | null {
     if (!this.isCurveSet) {
       return null;

package/src/core/WorkletNode.ts

@@ -1,3 +1,32 @@
 import AudioNode from './AudioNode';
+import BaseAudioContext from './BaseAudioContext';
+import { AudioWorkletRuntime } from '../types';
+import AudioAPIModule from '../AudioAPIModule';
 
-export default class WorkletNode extends AudioNode {}
+export default class WorkletNode extends AudioNode {
+  constructor(
+    context: BaseAudioContext,
+    runtime: AudioWorkletRuntime,
+    callback: (audioData: Array<Float32Array>, channelCount: number) => void,
+    bufferLength: number,
+    inputChannelCount: number
+  ) {
+    const shareableWorklet =
+      AudioAPIModule.workletsModule!.makeShareableCloneRecursive(
+        (audioBuffers: Array<ArrayBuffer>, channelCount: number) => {
+          'worklet';
+          const floatAudioData: Array<Float32Array> = audioBuffers.map(
+            (buffer) => new Float32Array(buffer)
+          );
+          callback(floatAudioData, channelCount);
+        }
+      );
+    const node = context.context.createWorkletNode(
+      shareableWorklet,
+      runtime === 'UIRuntime',
+      bufferLength,
+      inputChannelCount
+    );
+    super(context, node);
+  }
+}