react-native-audio-api 0.8.3 → 0.9.0

package/src/core/OfflineAudioContext.ts

@@ -3,12 +3,17 @@ import BaseAudioContext from './BaseAudioContext';
 import { OfflineAudioContextOptions } from '../types';
 import { InvalidStateError, NotSupportedError } from '../errors';
 import AudioBuffer from './AudioBuffer';
+import { isWorkletsAvailable, workletsModule } from '../utils';
 
 export default class OfflineAudioContext extends BaseAudioContext {
   private isSuspended: boolean;
   private isRendering: boolean;
   private duration: number;
 
+  // We need to keep here a reference to this runtime to better manage its lifecycle
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any
+  private _audioRuntime: any;
+
   constructor(options: OfflineAudioContextOptions);
   constructor(numberOfChannels: number, length: number, sampleRate: number);
   constructor(
@@ -16,10 +21,20 @@ export default class OfflineAudioContext extends BaseAudioContext {
     arg1?: number,
     arg2?: number
   ) {
+    let audioRuntime = null;
+    if (isWorkletsAvailable) {
+      audioRuntime = workletsModule.createWorkletRuntime('AudioWorkletRuntime');
+    }
+
     if (typeof arg0 === 'object') {
       const { numberOfChannels, length, sampleRate } = arg0;
       super(
-        global.createOfflineAudioContext(numberOfChannels, length, sampleRate)
+        global.createOfflineAudioContext(
+          numberOfChannels,
+          length,
+          sampleRate,
+          audioRuntime
+        )
       );
 
       this.duration = length / sampleRate;
@@ -28,7 +43,7 @@ export default class OfflineAudioContext extends BaseAudioContext {
       typeof arg1 === 'number' &&
       typeof arg2 === 'number'
     ) {
-      super(global.createOfflineAudioContext(arg0, arg1, arg2));
+      super(global.createOfflineAudioContext(arg0, arg1, arg2, audioRuntime));
       this.duration = arg1 / arg2;
     } else {
       throw new NotSupportedError('Invalid constructor arguments');
@@ -36,6 +51,7 @@ export default class OfflineAudioContext extends BaseAudioContext {
 
     this.isSuspended = false;
     this.isRendering = false;
+    this._audioRuntime = audioRuntime;
   }
 
   async resume(): Promise<undefined> {

package/src/core/OscillatorNode.ts

@@ -5,6 +5,7 @@ import AudioParam from './AudioParam';
 import BaseAudioContext from './BaseAudioContext';
 import PeriodicWave from './PeriodicWave';
 import { InvalidStateError } from '../errors';
+import { EventEmptyType } from '../events/types';
 
 export default class OscillatorNode extends AudioScheduledSourceNode {
   readonly frequency: AudioParam;
@@ -34,4 +35,14 @@ export default class OscillatorNode extends AudioScheduledSourceNode {
   public setPeriodicWave(wave: PeriodicWave): void {
     (this.node as IOscillatorNode).setPeriodicWave(wave.periodicWave);
   }
+
+  public override get onEnded(): ((event: EventEmptyType) => void) | undefined {
+    return super.onEnded as ((event: EventEmptyType) => void) | undefined;
+  }
+
+  public override set onEnded(
+    callback: ((event: EventEmptyType) => void) | null
+  ) {
+    super.onEnded = callback;
+  }
 }

package/src/core/WorkletNode.ts

@@ -0,0 +1,3 @@
+import AudioNode from './AudioNode';
+
+export default class WorkletNode extends AudioNode {}

package/src/core/WorkletProcessingNode.ts

@@ -0,0 +1,3 @@
+import AudioNode from './AudioNode';
+
+export default class WorkletProcessingNode extends AudioNode {}

package/src/core/WorkletSourceNode.ts

@@ -0,0 +1,3 @@
+import AudioScheduledSourceNode from './AudioScheduledSourceNode';
+
+export default class WorkletSourceNode extends AudioScheduledSourceNode {}

package/src/events/types.ts

@@ -46,6 +46,7 @@ type SystemEvents = RemoteCommandEvents & {
 
 export interface OnEndedEventType extends EventEmptyType {
   bufferId: string | undefined;
+  isLast: boolean | undefined;
 }
 
 export interface OnAudioReadyEventType {
@@ -56,6 +57,7 @@ export interface OnAudioReadyEventType {
 
 interface AudioAPIEvents {
   ended: OnEndedEventType;
+  loopEnded: EventEmptyType;
   audioReady: OnAudioReadyEventType;
   positionChanged: EventTypeWithValue;
   audioError: EventEmptyType; // to change

package/src/interfaces.ts

@@ -1,12 +1,36 @@
+import { AudioEventCallback, AudioEventName } from './events/types';
 import {
-  WindowType,
-  ContextState,
-  OscillatorType,
   BiquadFilterType,
   ChannelCountMode,
   ChannelInterpretation,
+  ContextState,
+  OscillatorType,
+  WindowType,
 } from './types';
-import { AudioEventName, AudioEventCallback } from './events/types';
+
+export type WorkletNodeCallback = (
+  audioData: Array<ArrayBuffer>,
+  channelCount: number
+) => void;
+
+export type WorkletSourceNodeCallback = (
+  audioData: Array<ArrayBuffer>,
+  framesToProcess: number,
+  currentTime: number,
+  startOffset: number
+) => void;
+
+export type WorkletProcessingNodeCallback = (
+  inputData: Array<ArrayBuffer>,
+  outputData: Array<ArrayBuffer>,
+  framesToProcess: number,
+  currentTime: number
+) => void;
+
+export type ShareableWorkletCallback =
+  | WorkletNodeCallback
+  | WorkletSourceNodeCallback
+  | WorkletProcessingNodeCallback;
 
 export interface IBaseAudioContext {
   readonly destination: IAudioDestinationNode;
@@ -15,12 +39,29 @@ export interface IBaseAudioContext {
   readonly currentTime: number;
 
   createRecorderAdapter(): IRecorderAdapterNode;
+  createWorkletSourceNode(
+    shareableWorklet: ShareableWorkletCallback,
+    shouldUseUiRuntime: boolean
+  ): IWorkletSourceNode;
+  createWorkletNode(
+    shareableWorklet: ShareableWorkletCallback,
+    shouldUseUiRuntime: boolean,
+    bufferLength: number,
+    inputChannelCount: number
+  ): IWorkletNode;
+  createWorkletProcessingNode(
+    shareableWorklet: ShareableWorkletCallback,
+    shouldUseUiRuntime: boolean
+  ): IWorkletProcessingNode;
   createOscillator(): IOscillatorNode;
+  createConstantSource(): IConstantSourceNode;
   createGain(): IGainNode;
   createStereoPanner(): IStereoPannerNode;
   createBiquadFilter: () => IBiquadFilterNode;
   createBufferSource: (pitchCorrection: boolean) => IAudioBufferSourceNode;
-  createBufferQueueSource: () => IAudioBufferQueueSourceNode;
+  createBufferQueueSource: (
+    pitchCorrection: boolean
+  ) => IAudioBufferQueueSourceNode;
   createBuffer: (
     channels: number,
     length: number,
@@ -119,6 +160,10 @@ export interface IStreamerNode extends IAudioNode {
   initialize(streamPath: string): boolean;
 }
 
+export interface IConstantSourceNode extends IAudioScheduledSourceNode {
+  readonly offset: IAudioParam;
+}
+
 export interface IAudioBufferSourceNode extends IAudioBufferBaseSourceNode {
   buffer: IAudioBuffer | null;
   loop: boolean;
@@ -128,6 +173,9 @@ export interface IAudioBufferSourceNode extends IAudioBufferBaseSourceNode {
 
   start: (when?: number, offset?: number, duration?: number) => void;
   setBuffer: (audioBuffer: IAudioBuffer | null) => void;
+
+  // passing subscriptionId(uint_64 in cpp, string in js) to the cpp
+  onLoopEnded: string;
 }
 
 export interface IAudioBufferQueueSourceNode
@@ -200,6 +248,12 @@ export interface IAnalyserNode extends IAudioNode {
 
 export interface IRecorderAdapterNode extends IAudioNode {}
 
+export interface IWorkletNode extends IAudioNode {}
+
+export interface IWorkletSourceNode extends IAudioScheduledSourceNode {}
+
+export interface IWorkletProcessingNode extends IAudioNode {}
+
 export interface IAudioRecorder {
   start: () => void;
   stop: () => void;

package/src/types.ts

@@ -14,6 +14,8 @@ export type BiquadFilterType =
 
 export type ContextState = 'running' | 'closed' | `suspended`;
 
+export type AudioWorkletRuntime = 'AudioRuntime' | 'UIRuntime';
+
 export type OscillatorType =
   | 'sine'
   | 'square'
@@ -43,7 +45,7 @@ export interface AudioRecorderOptions {
 
 export type WindowType = 'blackman' | 'hann';
 
-export interface AudioBufferSourceNodeOptions {
+export interface AudioBufferBaseSourceNodeOptions {
   pitchCorrection: boolean;
 }
 

package/src/utils/index.ts

@@ -1,3 +1,24 @@
+import type { ShareableWorkletCallback } from '../interfaces';
+
+interface SimplifiedWorkletModule {
+  makeShareableCloneRecursive: (
+    workletCallback: ShareableWorkletCallback
+  ) => ShareableWorkletCallback;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  createWorkletRuntime: (options?: any) => any;
+}
+
 export function clamp(value: number, min: number, max: number): number {
   return Math.min(Math.max(value, min), max);
 }
+
+export let isWorkletsAvailable = false;
+export let workletsModule: SimplifiedWorkletModule;
+
+try {
+  workletsModule = require('react-native-worklets');
+  isWorkletsAvailable = true;
+} catch (error) {
+  isWorkletsAvailable = false;
+}

package/src/web-core/AudioBufferSourceNode.tsx

@@ -26,7 +26,7 @@ interface IStretcherNode extends globalThis.AudioNode {
   numberOfInputs: number;
   numberOfOutputs: number;
 
-  onended:
+  onEnded:
     | ((this: globalThis.AudioScheduledSourceNode, ev: Event) => unknown)
     | null;
   addEventListener: (

package/src/web-core/AudioContext.tsx

@@ -2,7 +2,7 @@ import {
   ContextState,
   PeriodicWaveConstraints,
   AudioContextOptions,
-  AudioBufferSourceNodeOptions,
+  AudioBufferBaseSourceNodeOptions,
 } from '../types';
 import { InvalidAccessError, NotSupportedError } from '../errors';
 import BaseAudioContext from './BaseAudioContext';
@@ -17,6 +17,7 @@ import PeriodicWave from './PeriodicWave';
 import StereoPannerNode from './StereoPannerNode';
 
 import { globalWasmPromise, globalTag } from './custom/LoadCustomWasm';
+import ConstantSourceNode from './ConstantSourceNode';
 
 export default class AudioContext implements BaseAudioContext {
   readonly context: globalThis.AudioContext;
@@ -53,6 +54,10 @@ export default class AudioContext implements BaseAudioContext {
     return new OscillatorNode(this, this.context.createOscillator());
   }
 
+  createConstantSource(): ConstantSourceNode {
+    return new ConstantSourceNode(this, this.context.createConstantSource());
+  }
+
   createGain(): GainNode {
     return new GainNode(this, this.context.createGain());
   }
@@ -66,7 +71,7 @@ export default class AudioContext implements BaseAudioContext {
   }
 
   async createBufferSource(
-    options?: AudioBufferSourceNodeOptions
+    options?: AudioBufferBaseSourceNodeOptions
   ): Promise<AudioBufferSourceNode> {
     if (!options || !options.pitchCorrection) {
       return new AudioBufferSourceNode(

package/src/web-core/AudioScheduledSourceNode.tsx

@@ -37,7 +37,7 @@ export default class AudioScheduledSourceNode extends AudioNode {
   }
 
   // eslint-disable-next-line accessor-pairs
-  public set onended(callback: (event: EventEmptyType) => void) {
+  public set onEnded(callback: (event: EventEmptyType) => void) {
     (this.node as globalThis.AudioScheduledSourceNode).onended = callback;
   }
 }

package/src/web-core/BaseAudioContext.tsx

@@ -8,6 +8,7 @@ import GainNode from './GainNode';
 import OscillatorNode from './OscillatorNode';
 import PeriodicWave from './PeriodicWave';
 import StereoPannerNode from './StereoPannerNode';
+import ConstantSourceNode from './ConstantSourceNode';
 
 export default interface BaseAudioContext {
   readonly context: globalThis.BaseAudioContext;
@@ -18,6 +19,7 @@ export default interface BaseAudioContext {
   get currentTime(): number;
   get state(): ContextState;
   createOscillator(): OscillatorNode;
+  createConstantSource(): ConstantSourceNode;
   createGain(): GainNode;
   createStereoPanner(): StereoPannerNode;
   createBiquadFilter(): BiquadFilterNode;

package/src/web-core/ConstantSourceNode.tsx

@@ -0,0 +1,12 @@
+import AudioParam from './AudioParam';
+import AudioScheduledSourceNode from './AudioScheduledSourceNode';
+import BaseAudioContext from './BaseAudioContext';
+
+export default class ConstantSourceNode extends AudioScheduledSourceNode {
+  readonly offset: AudioParam;
+
+  constructor(context: BaseAudioContext, node: globalThis.ConstantSourceNode) {
+    super(context, node);
+    this.offset = new AudioParam(node.offset, context);
+  }
+}

package/src/web-core/OfflineAudioContext.tsx

@@ -2,7 +2,7 @@ import {
   ContextState,
   PeriodicWaveConstraints,
   OfflineAudioContextOptions,
-  AudioBufferSourceNodeOptions,
+  AudioBufferBaseSourceNodeOptions,
 } from '../types';
 import { InvalidAccessError, NotSupportedError } from '../errors';
 import BaseAudioContext from './BaseAudioContext';
@@ -15,6 +15,7 @@ import GainNode from './GainNode';
 import OscillatorNode from './OscillatorNode';
 import PeriodicWave from './PeriodicWave';
 import StereoPannerNode from './StereoPannerNode';
+import ConstantSourceNode from './ConstantSourceNode';
 
 import { globalWasmPromise, globalTag } from './custom/LoadCustomWasm';
 
@@ -59,6 +60,10 @@ export default class OfflineAudioContext implements BaseAudioContext {
     return new OscillatorNode(this, this.context.createOscillator());
   }
 
+  createConstantSource(): ConstantSourceNode {
+    return new ConstantSourceNode(this, this.context.createConstantSource());
+  }
+
   createGain(): GainNode {
     return new GainNode(this, this.context.createGain());
   }
@@ -72,7 +77,7 @@ export default class OfflineAudioContext implements BaseAudioContext {
   }
 
   async createBufferSource(
-    options?: AudioBufferSourceNodeOptions
+    options?: AudioBufferBaseSourceNodeOptions
   ): Promise<AudioBufferSourceNode> {
     if (!options || !options.pitchCorrection) {
       return new AudioBufferSourceNode(

package/common/cpp/audioapi/HostObjects/AnalyserNodeHostObject.h

@@ -1,149 +0,0 @@
-#pragma once
-
-#include <audioapi/core/analysis/AnalyserNode.h>
-#include <audioapi/HostObjects/AudioNodeHostObject.h>
-
-#include <memory>
-#include <string>
-#include <vector>
-
-namespace audioapi {
-using namespace facebook;
-
-class AnalyserNodeHostObject : public AudioNodeHostObject {
- public:
-  explicit AnalyserNodeHostObject(const std::shared_ptr<AnalyserNode> &node)
-      : AudioNodeHostObject(node) {
-    addGetters(
-        JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, fftSize),
-        JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, frequencyBinCount),
-        JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, minDecibels),
-        JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, maxDecibels),
-        JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, smoothingTimeConstant),
-        JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, window));
-
-    addFunctions(
-        JSI_EXPORT_FUNCTION(
-            AnalyserNodeHostObject, getFloatFrequencyData),
-        JSI_EXPORT_FUNCTION(
-            AnalyserNodeHostObject, getByteFrequencyData),
-        JSI_EXPORT_FUNCTION(
-            AnalyserNodeHostObject, getFloatTimeDomainData),
-        JSI_EXPORT_FUNCTION(
-            AnalyserNodeHostObject, getByteTimeDomainData));
-
-    addSetters(
-        JSI_EXPORT_PROPERTY_SETTER(AnalyserNodeHostObject, fftSize),
-        JSI_EXPORT_PROPERTY_SETTER(AnalyserNodeHostObject, minDecibels),
-        JSI_EXPORT_PROPERTY_SETTER(AnalyserNodeHostObject, maxDecibels),
-        JSI_EXPORT_PROPERTY_SETTER(
-            AnalyserNodeHostObject, smoothingTimeConstant),
-        JSI_EXPORT_PROPERTY_SETTER(AnalyserNodeHostObject, window));
-  }
-
-  JSI_PROPERTY_GETTER(fftSize) {
-    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-    return {static_cast<int>(analyserNode->getFftSize())};
-  }
-
-  JSI_PROPERTY_GETTER(frequencyBinCount) {
-    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-    return {static_cast<int>(analyserNode->getFrequencyBinCount())};
-  }
-
-  JSI_PROPERTY_GETTER(minDecibels) {
-    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-    return {analyserNode->getMinDecibels()};
-  }
-
-  JSI_PROPERTY_GETTER(maxDecibels) {
-    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-    return {analyserNode->getMaxDecibels()};
-  }
-
-  JSI_PROPERTY_GETTER(smoothingTimeConstant) {
-    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-    return {analyserNode->getSmoothingTimeConstant()};
-  }
-
-  JSI_PROPERTY_GETTER(window) {
-    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-    auto windowType = analyserNode->getWindowType();
-    return jsi::String::createFromUtf8(runtime, windowType);
-  }
-
-  JSI_HOST_FUNCTION(getFloatFrequencyData) {
-    auto arrayBuffer = args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
-    auto data = reinterpret_cast<float *>(arrayBuffer.data(runtime));
-    auto length = static_cast<int>(arrayBuffer.size(runtime));
-
-    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-    analyserNode->getFloatFrequencyData(data, length);
-
-    return jsi::Value::undefined();
-  }
-
-  JSI_HOST_FUNCTION(getByteFrequencyData) {
-    auto arrayBuffer = args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
-    auto data = arrayBuffer.data(runtime);
-    auto length = static_cast<int>(arrayBuffer.size(runtime));
-
-    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-    analyserNode->getByteFrequencyData(data, length);
-
-    return jsi::Value::undefined();
-  }
-
-  JSI_HOST_FUNCTION(getFloatTimeDomainData) {
-    auto arrayBuffer = args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
-    auto data = reinterpret_cast<float *>(arrayBuffer.data(runtime));
-    auto length = static_cast<int>(arrayBuffer.size(runtime));
-
-    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-    analyserNode->getFloatTimeDomainData(data, length);
-
-    return jsi::Value::undefined();
-  }
-
-  JSI_HOST_FUNCTION(getByteTimeDomainData) {
-    auto arrayBuffer = args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
-    auto data = arrayBuffer.data(runtime);
-    auto length = static_cast<int>(arrayBuffer.size(runtime));
-
-    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-    analyserNode->getByteTimeDomainData(data, length);
-
-    return jsi::Value::undefined();
-  }
-
-  JSI_PROPERTY_SETTER(fftSize) {
-    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-    auto fftSize = static_cast<int>(value.getNumber());
-    analyserNode->setFftSize(fftSize);
-  }
-
-  JSI_PROPERTY_SETTER(minDecibels) {
-    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-    auto minDecibels = static_cast<float>(value.getNumber());
-    analyserNode->setMinDecibels(minDecibels);
-  }
-
-  JSI_PROPERTY_SETTER(maxDecibels) {
-    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-      auto maxDecibels = static_cast<float>(value.getNumber());
-      analyserNode->setMaxDecibels(maxDecibels);
-  }
-
-  JSI_PROPERTY_SETTER(smoothingTimeConstant) {
-    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-    auto smoothingTimeConstant = static_cast<float>(value.getNumber());
-    analyserNode->setSmoothingTimeConstant(smoothingTimeConstant);
-  }
-
-  JSI_PROPERTY_SETTER(window) {
-    auto analyserNode = std::static_pointer_cast<AnalyserNode>(node_);
-    analyserNode->setWindowType(value.getString(runtime).utf8(runtime));
-  }
-};
-
-} // namespace audioapi

package/common/cpp/audioapi/HostObjects/AudioBufferBaseSourceNodeHostObject.h

@@ -1,76 +0,0 @@
-#pragma once
-
-#include <audioapi/core/sources/AudioBufferBaseSourceNode.h>
-#include <audioapi/HostObjects/AudioParamHostObject.h>
-#include <audioapi/HostObjects/AudioScheduledSourceNodeHostObject.h>
-
-#include <memory>
-#include <vector>
-
-namespace audioapi {
-using namespace facebook;
-
-class AudioBufferBaseSourceNodeHostObject
-        : public AudioScheduledSourceNodeHostObject {
- public:
-    explicit AudioBufferBaseSourceNodeHostObject(
-            const std::shared_ptr<AudioBufferBaseSourceNode> &node)
-            : AudioScheduledSourceNodeHostObject(node) {
-        addGetters(
-                JSI_EXPORT_PROPERTY_GETTER(AudioBufferBaseSourceNodeHostObject, detune),
-                JSI_EXPORT_PROPERTY_GETTER(AudioBufferBaseSourceNodeHostObject, playbackRate),
-                JSI_EXPORT_PROPERTY_GETTER(AudioBufferBaseSourceNodeHostObject, onPositionChangedInterval));
-
-        addSetters(
-                JSI_EXPORT_PROPERTY_SETTER(AudioBufferBaseSourceNodeHostObject, onPositionChanged),
-                JSI_EXPORT_PROPERTY_SETTER(AudioBufferBaseSourceNodeHostObject, onPositionChangedInterval));
-    }
-
-    ~AudioBufferBaseSourceNodeHostObject() {
-        auto sourceNode =
-                std::static_pointer_cast<AudioBufferBaseSourceNode>(node_);
-
-      // When JSI object is garbage collected (together with the eventual callback),
-      // underlying source node might still be active and try to call the non-existing callback.
-      sourceNode->clearOnPositionChangedCallback();
-    }
-
-    JSI_PROPERTY_GETTER(detune) {
-        auto sourceNode =
-                std::static_pointer_cast<AudioBufferBaseSourceNode>(node_);
-        auto detune = sourceNode->getDetuneParam();
-        auto detuneHostObject = std::make_shared<AudioParamHostObject>(detune);
-        return jsi::Object::createFromHostObject(runtime, detuneHostObject);
-    }
-
-    JSI_PROPERTY_GETTER(playbackRate) {
-        auto sourceNode =
-                std::static_pointer_cast<AudioBufferBaseSourceNode>(node_);
-        auto playbackRate = sourceNode->getPlaybackRateParam();
-        auto playbackRateHostObject =
-                std::make_shared<AudioParamHostObject>(playbackRate);
-        return jsi::Object::createFromHostObject(runtime, playbackRateHostObject);
-    }
-
-    JSI_PROPERTY_SETTER(onPositionChanged) {
-        auto sourceNode =
-                std::static_pointer_cast<AudioBufferBaseSourceNode>(node_);
-
-        sourceNode->setOnPositionChangedCallbackId(std::stoull(value.getString(runtime).utf8(runtime)));
-    }
-
-    JSI_PROPERTY_GETTER(onPositionChangedInterval) {
-        auto sourceNode =
-                std::static_pointer_cast<AudioBufferBaseSourceNode>(node_);
-        return jsi::Value(sourceNode->getOnPositionChangedInterval());
-    }
-
-    JSI_PROPERTY_SETTER(onPositionChangedInterval) {
-        auto sourceNode =
-                std::static_pointer_cast<AudioBufferBaseSourceNode>(node_);
-
-        sourceNode->setOnPositionChangedInterval(static_cast<int>(value.getNumber()));
-    }
-};
-
-} // namespace audioapi