react-native-audio-api 0.12.0-nightly-6a44b58-20260126 → 0.12.0-nightly-1a3c43b-20260128

package/common/cpp/audioapi/HostObjects/BaseAudioContextHostObject.cpp

@@ -1,5 +1,4 @@
 #include <audioapi/HostObjects/BaseAudioContextHostObject.h>
-
 #include <audioapi/HostObjects/WorkletNodeHostObject.h>
 #include <audioapi/HostObjects/WorkletProcessingNodeHostObject.h>
 #include <audioapi/HostObjects/analysis/AnalyserNodeHostObject.h>
@@ -20,9 +19,10 @@
 #include <audioapi/HostObjects/sources/RecorderAdapterNodeHostObject.h>
 #include <audioapi/HostObjects/sources/StreamerNodeHostObject.h>
 #include <audioapi/HostObjects/sources/WorkletSourceNodeHostObject.h>
+#include <audioapi/HostObjects/utils/JsEnumParser.h>
+#include <audioapi/HostObjects/utils/NodeOptionsParser.h>
 #include <audioapi/core/BaseAudioContext.h>
 
-#include <audioapi/HostObjects/utils/NodeOptionsParser.h>
 #include <memory>
 #include <utility>
 #include <vector>
@@ -33,8 +33,11 @@ BaseAudioContextHostObject::BaseAudioContextHostObject(
     const std::shared_ptr<BaseAudioContext> &context,
     jsi::Runtime *runtime,
     const std::shared_ptr<react::CallInvoker> &callInvoker)
-    : context_(context), callInvoker_(callInvoker) {
-  promiseVendor_ = std::make_shared<PromiseVendor>(runtime, callInvoker);
+    : context_(context),
+      promiseVendor_(std::make_shared<PromiseVendor>(runtime, callInvoker)),
+      callInvoker_(callInvoker) {
+  context_->initialize();
+  destination_ = std::make_shared<AudioDestinationNodeHostObject>(context_->getDestination());
 
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(BaseAudioContextHostObject, destination),
@@ -71,12 +74,11 @@ BaseAudioContextHostObject::BaseAudioContextHostObject(
 BaseAudioContextHostObject::~BaseAudioContextHostObject() = default;
 
 JSI_PROPERTY_GETTER_IMPL(BaseAudioContextHostObject, destination) {
-  auto destination = std::make_shared<AudioDestinationNodeHostObject>(context_->getDestination());
-  return jsi::Object::createFromHostObject(runtime, destination);
+  return jsi::Object::createFromHostObject(runtime, destination_);
 }
 
 JSI_PROPERTY_GETTER_IMPL(BaseAudioContextHostObject, state) {
-  return jsi::String::createFromUtf8(runtime, context_->getState());
+    return jsi::String::createFromUtf8(runtime, js_enum_parser::contextStateToString(context_->getState()));
 }
 
 JSI_PROPERTY_GETTER_IMPL(BaseAudioContextHostObject, sampleRate) {
@@ -169,8 +171,8 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createRecorderAdapter) {
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createOscillator) {
   const auto options = args[0].asObject(runtime);
   const auto oscillatorOptions = audioapi::option_parser::parseOscillatorOptions(runtime, options);
-  auto oscillator = context_->createOscillator(oscillatorOptions);
-  auto oscillatorHostObject = std::make_shared<OscillatorNodeHostObject>(oscillator);
+  auto oscillatorHostObject =
+      std::make_shared<OscillatorNodeHostObject>(context_, oscillatorOptions);
   return jsi::Object::createFromHostObject(runtime, oscillatorHostObject);
 }
 
@@ -181,8 +183,7 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createStreamer) {
     const auto options = args[0].asObject(runtime);
     streamerOptions = audioapi::option_parser::parseStreamerOptions(runtime, options);
   }
-  auto streamer = context_->createStreamer(streamerOptions);
-  auto streamerHostObject = std::make_shared<StreamerNodeHostObject>(streamer);
+  auto streamerHostObject = std::make_shared<StreamerNodeHostObject>(context_, streamerOptions);
   auto object = jsi::Object::createFromHostObject(runtime, streamerHostObject);
   object.setExternalMemoryPressure(runtime, StreamerNodeHostObject::getSizeInBytes());
   return object;
@@ -195,24 +196,22 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createConstantSource) {
   const auto options = args[0].asObject(runtime);
   const auto constantSourceOptions =
       audioapi::option_parser::parseConstantSourceOptions(runtime, options);
-  auto constantSource = context_->createConstantSource(constantSourceOptions);
-  auto constantSourceHostObject = std::make_shared<ConstantSourceNodeHostObject>(constantSource);
+  auto constantSourceHostObject =
+      std::make_shared<ConstantSourceNodeHostObject>(context_, constantSourceOptions);
   return jsi::Object::createFromHostObject(runtime, constantSourceHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createGain) {
   const auto options = args[0].asObject(runtime);
   const auto gainOptions = audioapi::option_parser::parseGainOptions(runtime, options);
-  auto gain = context_->createGain(std::move(gainOptions));
-  auto gainHostObject = std::make_shared<GainNodeHostObject>(gain);
+  auto gainHostObject = std::make_shared<GainNodeHostObject>(context_, gainOptions);
   return jsi::Object::createFromHostObject(runtime, gainHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createDelay) {
   const auto options = args[0].asObject(runtime);
   const auto delayOptions = audioapi::option_parser::parseDelayOptions(runtime, options);
-  auto delayNode = context_->createDelay(delayOptions);
-  auto delayNodeHostObject = std::make_shared<DelayNodeHostObject>(delayNode);
+  auto delayNodeHostObject = std::make_shared<DelayNodeHostObject>(context_, delayOptions);
   auto jsiObject = jsi::Object::createFromHostObject(runtime, delayNodeHostObject);
   jsiObject.setExternalMemoryPressure(runtime, delayNodeHostObject->getSizeInBytes());
   return jsiObject;
@@ -220,25 +219,26 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createDelay) {
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createStereoPanner) {
   const auto options = args[0].asObject(runtime);
-  const auto stereoPannerOptions = audioapi::option_parser::parseStereoPannerOptions(runtime, options);
-  auto stereoPanner = context_->createStereoPanner(stereoPannerOptions);
-  auto stereoPannerHostObject = std::make_shared<StereoPannerNodeHostObject>(stereoPanner);
+  const auto stereoPannerOptions =
+      audioapi::option_parser::parseStereoPannerOptions(runtime, options);
+  auto stereoPannerHostObject =
+      std::make_shared<StereoPannerNodeHostObject>(context_, stereoPannerOptions);
   return jsi::Object::createFromHostObject(runtime, stereoPannerHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBiquadFilter) {
   const auto options = args[0].asObject(runtime);
-  const auto biquadFilterOptions = audioapi::option_parser::parseBiquadFilterOptions(runtime, options);
-  auto biquadFilter = context_->createBiquadFilter(biquadFilterOptions);
-  auto biquadFilterHostObject = std::make_shared<BiquadFilterNodeHostObject>(biquadFilter);
+  const auto biquadFilterOptions =
+      audioapi::option_parser::parseBiquadFilterOptions(runtime, options);
+  auto biquadFilterHostObject =
+      std::make_shared<BiquadFilterNodeHostObject>(context_, biquadFilterOptions);
   return jsi::Object::createFromHostObject(runtime, biquadFilterHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createIIRFilter) {
   const auto options = args[0].asObject(runtime);
   const auto iirFilterOptions = audioapi::option_parser::parseIIRFilterOptions(runtime, options);
-  auto iirFilter = context_->createIIRFilter(iirFilterOptions);
-  auto iirFilterHostObject = std::make_shared<IIRFilterNodeHostObject>(iirFilter);
+  auto iirFilterHostObject = std::make_shared<IIRFilterNodeHostObject>(context_, iirFilterOptions);
   return jsi::Object::createFromHostObject(runtime, iirFilterHostObject);
 }
 
@@ -246,8 +246,8 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBufferSource) {
   const auto options = args[0].asObject(runtime);
   const auto audioBufferSourceOptions =
       audioapi::option_parser::parseAudioBufferSourceOptions(runtime, options);
-  auto bufferSource = context_->createBufferSource(audioBufferSourceOptions);
-  auto bufferSourceHostObject = std::make_shared<AudioBufferSourceNodeHostObject>(bufferSource);
+  auto bufferSourceHostObject =
+      std::make_shared<AudioBufferSourceNodeHostObject>(context_, audioBufferSourceOptions);
   return jsi::Object::createFromHostObject(runtime, bufferSourceHostObject);
 }
 
@@ -255,15 +255,15 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBufferQueueSource) {
   const auto options = args[0].asObject(runtime);
   const auto baseAudioBufferSourceOptions =
       audioapi::option_parser::parseBaseAudioBufferSourceOptions(runtime, options);
-  auto bufferSource = context_->createBufferQueueSource(baseAudioBufferSourceOptions);
-  auto bufferStreamSourceHostObject =
-      std::make_shared<AudioBufferQueueSourceNodeHostObject>(bufferSource);
+  auto bufferStreamSourceHostObject = std::make_shared<AudioBufferQueueSourceNodeHostObject>(
+      context_, baseAudioBufferSourceOptions);
   return jsi::Object::createFromHostObject(runtime, bufferStreamSourceHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBuffer) {
   const auto options = args[0].asObject(runtime);
-  const auto audioBufferOptions = audioapi::option_parser::parseAudioBufferOptions(runtime, options);
+  const auto audioBufferOptions =
+      audioapi::option_parser::parseAudioBufferOptions(runtime, options);
   auto buffer = BaseAudioContext::createBuffer(audioBufferOptions);
   auto bufferHostObject = std::make_shared<AudioBufferHostObject>(buffer);
 
@@ -300,19 +300,19 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createPeriodicWave) {
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createAnalyser) {
   const auto options = args[0].asObject(runtime);
   const auto analyserOptions = audioapi::option_parser::parseAnalyserOptions(runtime, options);
-  auto analyser = context_->createAnalyser(analyserOptions);
-  auto analyserHostObject = std::make_shared<AnalyserNodeHostObject>(analyser);
+  auto analyserHostObject = std::make_shared<AnalyserNodeHostObject>(context_, analyserOptions);
   return jsi::Object::createFromHostObject(runtime, analyserHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createConvolver) {
   const auto options = args[0].asObject(runtime);
   const auto convolverOptions = audioapi::option_parser::parseConvolverOptions(runtime, options);
-  auto convolver = context_->createConvolver(convolverOptions);
-  auto convolverHostObject = std::make_shared<ConvolverNodeHostObject>(convolver);
+  auto convolverHostObject = std::make_shared<ConvolverNodeHostObject>(context_, convolverOptions);
   auto jsiObject = jsi::Object::createFromHostObject(runtime, convolverHostObject);
   if (convolverOptions.bus != nullptr) {
-    auto bufferHostObject = options.getProperty(runtime, "buffer").getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
+    auto bufferHostObject = options.getProperty(runtime, "buffer")
+                                .getObject(runtime)
+                                .asHostObject<AudioBufferHostObject>(runtime);
     jsiObject.setExternalMemoryPressure(runtime, bufferHostObject->getSizeInBytes());
   }
   return jsiObject;
@@ -321,8 +321,8 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createConvolver) {
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWaveShaper) {
   const auto options = args[0].asObject(runtime);
   const auto waveShaperOptions = audioapi::option_parser::parseWaveShaperOptions(runtime, options);
-  auto waveShaper = context_->createWaveShaper(waveShaperOptions);
-  auto waveShaperHostObject = std::make_shared<WaveShaperNodeHostObject>(waveShaper);
+  auto waveShaperHostObject =
+      std::make_shared<WaveShaperNodeHostObject>(context_, waveShaperOptions);
   return jsi::Object::createFromHostObject(runtime, waveShaperHostObject);
 }
 } // namespace audioapi

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

@@ -13,6 +13,7 @@ namespace audioapi {
 using namespace facebook;
 
 class BaseAudioContext;
+class AudioDestinationNodeHostObject;
 
 class BaseAudioContextHostObject : public JsiHostObject {
  public:
@@ -48,10 +49,11 @@ class BaseAudioContextHostObject : public JsiHostObject {
   JSI_HOST_FUNCTION_DECL(createWaveShaper);
   JSI_HOST_FUNCTION_DECL(createDelay);
 
-  std::shared_ptr<BaseAudioContext> context_;
-
  protected:
+  std::shared_ptr<BaseAudioContext> context_;
   std::shared_ptr<PromiseVendor> promiseVendor_;
   std::shared_ptr<react::CallInvoker> callInvoker_;
+
+  std::shared_ptr<AudioDestinationNodeHostObject> destination_;
 };
 } // namespace audioapi

package/common/cpp/audioapi/HostObjects/OfflineAudioContextHostObject.cpp

@@ -8,10 +8,14 @@
 namespace audioapi {
 
 OfflineAudioContextHostObject::OfflineAudioContextHostObject(
-    const std::shared_ptr<OfflineAudioContext> &offlineAudioContext,
-    jsi::Runtime *runtime,
-    const std::shared_ptr<react::CallInvoker> &callInvoker)
-    : BaseAudioContextHostObject(offlineAudioContext, runtime, callInvoker) {
+        int numberOfChannels,
+        size_t length,
+        float sampleRate,
+        const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry,
+        const RuntimeRegistry &runtimeRegistry,
+        jsi::Runtime *runtime,
+        const std::shared_ptr<react::CallInvoker> &callInvoker)
+    : BaseAudioContextHostObject(std::make_shared<OfflineAudioContext>(numberOfChannels, length, sampleRate, audioEventHandlerRegistry, runtimeRegistry), runtime, callInvoker) {
   addFunctions(
       JSI_EXPORT_FUNCTION(OfflineAudioContextHostObject, resume),
       JSI_EXPORT_FUNCTION(OfflineAudioContextHostObject, suspend),

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

@@ -1,6 +1,8 @@
 #pragma once
 
 #include <audioapi/HostObjects/BaseAudioContextHostObject.h>
+#include <audioapi/core/utils/worklets/SafeIncludes.h>
+#include <audioapi/events/IAudioEventHandlerRegistry.h>
 
 #include <jsi/jsi.h>
 #include <memory>
@@ -15,7 +17,11 @@ class OfflineAudioContext;
 class OfflineAudioContextHostObject : public BaseAudioContextHostObject {
  public:
   explicit OfflineAudioContextHostObject(
-      const std::shared_ptr<OfflineAudioContext> &offlineAudioContext,
+      int numberOfChannels,
+      size_t length,
+      float sampleRate,
+      const std::shared_ptr<IAudioEventHandlerRegistry> &audioEventHandlerRegistry,
+      const RuntimeRegistry &runtimeRegistry,
       jsi::Runtime *runtime,
       const std::shared_ptr<react::CallInvoker> &callInvoker);
 

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

@@ -1,13 +1,15 @@
 #include <audioapi/HostObjects/analysis/AnalyserNodeHostObject.h>
-
-#include <audioapi/core/analysis/AnalyserNode.h>
+#include <audioapi/HostObjects/utils/NodeOptions.h>
 #include <audioapi/HostObjects/utils/JsEnumParser.h>
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/analysis/AnalyserNode.h>
+
 #include <memory>
 
 namespace audioapi {
 
-AnalyserNodeHostObject::AnalyserNodeHostObject(const std::shared_ptr<AnalyserNode> &node)
-    : AudioNodeHostObject(node) {
+AnalyserNodeHostObject::AnalyserNodeHostObject(const std::shared_ptr<BaseAudioContext>& context, const AnalyserOptions &options)
+    : AudioNodeHostObject(context->createAnalyser(options)) {
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, fftSize),
       JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, frequencyBinCount),

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

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <audioapi/HostObjects/AudioNodeHostObject.h>
-#include <audioapi/core/analysis/AnalyserNode.h>
 
 #include <memory>
 #include <string>
@@ -10,9 +9,14 @@
 namespace audioapi {
 using namespace facebook;
 
+struct AnalyserOptions;
+class BaseAudioContext;
+
 class AnalyserNodeHostObject : public AudioNodeHostObject {
  public:
-  explicit AnalyserNodeHostObject(const std::shared_ptr<AnalyserNode> &node);
+  explicit AnalyserNodeHostObject(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const AnalyserOptions &options);
 
   JSI_PROPERTY_GETTER_DECL(fftSize);
   JSI_PROPERTY_GETTER_DECL(frequencyBinCount);

package/common/cpp/audioapi/HostObjects/effects/BiquadFilterNodeHostObject.cpp

@@ -1,15 +1,18 @@
 #include <audioapi/HostObjects/effects/BiquadFilterNodeHostObject.h>
-
 #include <audioapi/HostObjects/AudioParamHostObject.h>
-#include <audioapi/core/effects/BiquadFilterNode.h>
 #include <audioapi/HostObjects/utils/JsEnumParser.h>
+#include <audioapi/HostObjects/utils/NodeOptions.h>
+#include <audioapi/core/BaseAudioContext.h>
+#include <audioapi/core/effects/BiquadFilterNode.h>
+#include <audioapi/core/types/BiquadFilterType.h>
+
 #include <memory>
 
 namespace audioapi {
 
-BiquadFilterNodeHostObject::BiquadFilterNodeHostObject(
-    const std::shared_ptr<BiquadFilterNode> &node)
-    : AudioNodeHostObject(node) {
+BiquadFilterNodeHostObject::BiquadFilterNodeHostObject(const std::shared_ptr<BaseAudioContext>& context,
+                                                       const BiquadFilterOptions &options)
+    : AudioNodeHostObject(context->createBiquadFilter(options)) {
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(BiquadFilterNodeHostObject, frequency),
       JSI_EXPORT_PROPERTY_GETTER(BiquadFilterNodeHostObject, detune),

package/common/cpp/audioapi/HostObjects/effects/BiquadFilterNodeHostObject.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <audioapi/HostObjects/AudioNodeHostObject.h>
-#include <audioapi/core/types/BiquadFilterType.h>
 
 #include <memory>
 #include <string>
@@ -10,11 +9,14 @@
 namespace audioapi {
 using namespace facebook;
 
-class BiquadFilterNode;
+struct BiquadFilterOptions;
+class BaseAudioContext;
 
 class BiquadFilterNodeHostObject : public AudioNodeHostObject {
  public:
-  explicit BiquadFilterNodeHostObject(const std::shared_ptr<BiquadFilterNode> &node);
+  explicit BiquadFilterNodeHostObject(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const BiquadFilterOptions &options);
 
   JSI_PROPERTY_GETTER_DECL(frequency);
   JSI_PROPERTY_GETTER_DECL(detune);

package/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.cpp

@@ -1,13 +1,15 @@
 #include <audioapi/HostObjects/effects/ConvolverNodeHostObject.h>
-
 #include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
+#include <audioapi/HostObjects/utils/NodeOptions.h>
+#include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/effects/ConvolverNode.h>
+
 #include <memory>
 
 namespace audioapi {
 
-ConvolverNodeHostObject::ConvolverNodeHostObject(const std::shared_ptr<ConvolverNode> &node)
-    : AudioNodeHostObject(node) {
+ConvolverNodeHostObject::ConvolverNodeHostObject(const std::shared_ptr<BaseAudioContext>& context, const ConvolverOptions &options)
+    : AudioNodeHostObject(context->createConvolver(options)) {
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(ConvolverNodeHostObject, normalize),
       JSI_EXPORT_PROPERTY_GETTER(ConvolverNodeHostObject, buffer));

package/common/cpp/audioapi/HostObjects/effects/ConvolverNodeHostObject.h

@@ -7,11 +7,14 @@
 namespace audioapi {
 using namespace facebook;
 
-class ConvolverNode;
+struct ConvolverOptions;
+class BaseAudioContext;
 
 class ConvolverNodeHostObject : public AudioNodeHostObject {
  public:
-  explicit ConvolverNodeHostObject(const std::shared_ptr<ConvolverNode> &node);
+  explicit ConvolverNodeHostObject(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const ConvolverOptions &options);
   JSI_PROPERTY_GETTER_DECL(normalize);
   JSI_PROPERTY_GETTER_DECL(buffer);
   JSI_PROPERTY_SETTER_DECL(normalize);

package/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.cpp

@@ -1,14 +1,15 @@
 #include <audioapi/HostObjects/effects/DelayNodeHostObject.h>
-
 #include <audioapi/HostObjects/AudioParamHostObject.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/effects/DelayNode.h>
+#include <audioapi/HostObjects/utils/NodeOptions.h>
+
 #include <memory>
 
 namespace audioapi {
 
-DelayNodeHostObject::DelayNodeHostObject(const std::shared_ptr<DelayNode> &node)
-    : AudioNodeHostObject(node) {
+DelayNodeHostObject::DelayNodeHostObject(const std::shared_ptr<BaseAudioContext>& context, const DelayOptions &options)
+    : AudioNodeHostObject(context->createDelay(options)) {
   addGetters(JSI_EXPORT_PROPERTY_GETTER(DelayNodeHostObject, delayTime));
 }
 

package/common/cpp/audioapi/HostObjects/effects/DelayNodeHostObject.h

@@ -8,11 +8,14 @@
 namespace audioapi {
 using namespace facebook;
 
-class DelayNode;
+struct DelayOptions;
+class BaseAudioContext;
 
 class DelayNodeHostObject : public AudioNodeHostObject {
  public:
-  explicit DelayNodeHostObject(const std::shared_ptr<DelayNode> &node);
+  explicit DelayNodeHostObject(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const DelayOptions &options);
 
   [[nodiscard]] size_t getSizeInBytes() const;
 

package/common/cpp/audioapi/HostObjects/effects/GainNodeHostObject.cpp

@@ -1,13 +1,17 @@
 #include <audioapi/HostObjects/effects/GainNodeHostObject.h>
 
 #include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/HostObjects/utils/NodeOptions.h>
+#include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/effects/GainNode.h>
 #include <memory>
 
 namespace audioapi {
 
-GainNodeHostObject::GainNodeHostObject(const std::shared_ptr<GainNode> &node)
-    : AudioNodeHostObject(node) {
+GainNodeHostObject::GainNodeHostObject(
+    const std::shared_ptr<BaseAudioContext> &context,
+    const GainOptions &options)
+    : AudioNodeHostObject(context->createGain(options)) {
   addGetters(JSI_EXPORT_PROPERTY_GETTER(GainNodeHostObject, gain));
 }
 

package/common/cpp/audioapi/HostObjects/effects/GainNodeHostObject.h

@@ -8,11 +8,14 @@
 namespace audioapi {
 using namespace facebook;
 
-class GainNode;
+struct GainOptions;
+class BaseAudioContext;
 
 class GainNodeHostObject : public AudioNodeHostObject {
  public:
-  explicit GainNodeHostObject(const std::shared_ptr<GainNode> &node);
+  explicit GainNodeHostObject(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const GainOptions &options);
 
   JSI_PROPERTY_GETTER_DECL(gain);
 };

package/common/cpp/audioapi/HostObjects/effects/IIRFilterNodeHostObject.cpp

@@ -1,11 +1,15 @@
 #include <audioapi/HostObjects/effects/IIRFilterNodeHostObject.h>
+#include <audioapi/HostObjects/utils/NodeOptions.h>
+#include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/effects/IIRFilterNode.h>
 #include <memory>
 
 namespace audioapi {
 
-IIRFilterNodeHostObject::IIRFilterNodeHostObject(const std::shared_ptr<IIRFilterNode> &node)
-    : AudioNodeHostObject(node) {
+IIRFilterNodeHostObject::IIRFilterNodeHostObject(
+    const std::shared_ptr<BaseAudioContext> &context,
+    const IIRFilterOptions &options)
+    : AudioNodeHostObject(context->createIIRFilter(options)) {
 
   addFunctions(JSI_EXPORT_FUNCTION(IIRFilterNodeHostObject, getFrequencyResponse));
 }

package/common/cpp/audioapi/HostObjects/effects/IIRFilterNodeHostObject.h

@@ -9,11 +9,14 @@
 namespace audioapi {
 using namespace facebook;
 
-class IIRFilterNode;
+struct IIRFilterOptions;
+class BaseAudioContext;
 
 class IIRFilterNodeHostObject : public AudioNodeHostObject {
  public:
-  explicit IIRFilterNodeHostObject(const std::shared_ptr<IIRFilterNode> &node);
+  explicit IIRFilterNodeHostObject(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const IIRFilterOptions &options);
 
   JSI_HOST_FUNCTION_DECL(getFrequencyResponse);
 };

package/common/cpp/audioapi/HostObjects/effects/StereoPannerNodeHostObject.cpp

@@ -1,14 +1,17 @@
 #include <audioapi/HostObjects/effects/StereoPannerNodeHostObject.h>
 
 #include <audioapi/HostObjects/AudioParamHostObject.h>
+#include <audioapi/HostObjects/utils/NodeOptions.h>
+#include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/effects/StereoPannerNode.h>
 #include <memory>
 
 namespace audioapi {
 
 StereoPannerNodeHostObject::StereoPannerNodeHostObject(
-    const std::shared_ptr<StereoPannerNode> &node)
-    : AudioNodeHostObject(node) {
+    const std::shared_ptr<BaseAudioContext> &context,
+    const StereoPannerOptions &options)
+    : AudioNodeHostObject(context->createStereoPanner(options)) {
   addGetters(JSI_EXPORT_PROPERTY_GETTER(StereoPannerNodeHostObject, pan));
 }
 

package/common/cpp/audioapi/HostObjects/effects/StereoPannerNodeHostObject.h

@@ -9,11 +9,14 @@
 namespace audioapi {
 using namespace facebook;
 
-class StereoPannerNode;
+struct StereoPannerOptions;
+class BaseAudioContext;
 
 class StereoPannerNodeHostObject : public AudioNodeHostObject {
  public:
-  explicit StereoPannerNodeHostObject(const std::shared_ptr<StereoPannerNode> &node);
+  explicit StereoPannerNodeHostObject(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const StereoPannerOptions &options);
 
   JSI_PROPERTY_GETTER_DECL(pan);
 };

package/common/cpp/audioapi/HostObjects/effects/WaveShaperNodeHostObject.cpp

@@ -1,15 +1,19 @@
 #include <audioapi/HostObjects/effects/WaveShaperNodeHostObject.h>
+#include <audioapi/HostObjects/utils/JsEnumParser.h>
+#include <audioapi/HostObjects/utils/NodeOptions.h>
+#include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/effects/WaveShaperNode.h>
 #include <audioapi/jsi/AudioArrayBuffer.h>
-#include <audioapi/HostObjects/utils/JsEnumParser.h>
 
 #include <memory>
 #include <string>
 
 namespace audioapi {
 
-WaveShaperNodeHostObject::WaveShaperNodeHostObject(const std::shared_ptr<WaveShaperNode> &node)
-    : AudioNodeHostObject(node) {
+WaveShaperNodeHostObject::WaveShaperNodeHostObject(
+    const std::shared_ptr<BaseAudioContext> &context,
+    const WaveShaperOptions &options)
+    : AudioNodeHostObject(context->createWaveShaper(options)) {
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(WaveShaperNodeHostObject, oversample),
       JSI_EXPORT_PROPERTY_GETTER(WaveShaperNodeHostObject, curve));
@@ -20,7 +24,8 @@ WaveShaperNodeHostObject::WaveShaperNodeHostObject(const std::shared_ptr<WaveSha
 
 JSI_PROPERTY_GETTER_IMPL(WaveShaperNodeHostObject, oversample) {
   auto waveShaperNode = std::static_pointer_cast<WaveShaperNode>(node_);
-  return jsi::String::createFromUtf8(runtime, js_enum_parser::overSampleTypeToString(waveShaperNode->getOversample()));
+  return jsi::String::createFromUtf8(
+      runtime, js_enum_parser::overSampleTypeToString(waveShaperNode->getOversample()));
 }
 
 JSI_PROPERTY_GETTER_IMPL(WaveShaperNodeHostObject, curve) {

package/common/cpp/audioapi/HostObjects/effects/WaveShaperNodeHostObject.h

@@ -10,11 +10,14 @@
 namespace audioapi {
 using namespace facebook;
 
-class WaveShaperNode;
+struct WaveShaperOptions;
+class BaseAudioContext;
 
 class WaveShaperNodeHostObject : public AudioNodeHostObject {
  public:
-  explicit WaveShaperNodeHostObject(const std::shared_ptr<WaveShaperNode> &node);
+  explicit WaveShaperNodeHostObject(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const WaveShaperOptions &options);
 
   JSI_PROPERTY_GETTER_DECL(oversample);
   JSI_PROPERTY_GETTER_DECL(curve);

package/common/cpp/audioapi/HostObjects/events/AudioEventHandlerRegistryHostObject.cpp

@@ -1,6 +1,7 @@
 #include <audioapi/HostObjects/events/AudioEventHandlerRegistryHostObject.h>
 
 #include <audioapi/events/AudioEventHandlerRegistry.h>
+#include <audioapi/HostObjects/utils/JsEnumParser.h>
 #include <memory>
 
 namespace audioapi {
@@ -18,7 +19,7 @@ JSI_HOST_FUNCTION_IMPL(AudioEventHandlerRegistryHostObject, addAudioEventListene
   auto eventName = args[0].getString(runtime).utf8(runtime);
   auto callback = std::make_shared<jsi::Function>(args[1].getObject(runtime).getFunction(runtime));
 
-  auto listenerId = eventHandlerRegistry_->registerHandler(eventName, callback);
+  auto listenerId = eventHandlerRegistry_->registerHandler(js_enum_parser::audioEventFromString(eventName), callback);
 
   return jsi::String::createFromUtf8(runtime, std::to_string(listenerId));
 }
@@ -27,7 +28,7 @@ JSI_HOST_FUNCTION_IMPL(AudioEventHandlerRegistryHostObject, removeAudioEventList
   auto eventName = args[0].getString(runtime).utf8(runtime);
   uint64_t listenerId = std::stoull(args[1].getString(runtime).utf8(runtime));
 
-  eventHandlerRegistry_->unregisterHandler(eventName, listenerId);
+  eventHandlerRegistry_->unregisterHandler(js_enum_parser::audioEventFromString(eventName), listenerId);
 
   return jsi::Value::undefined();
 }

package/common/cpp/audioapi/HostObjects/inputs/AudioRecorderHostObject.cpp

@@ -6,6 +6,7 @@
 #include <audioapi/core/sources/AudioBuffer.h>
 #include <audioapi/events/AudioEventHandlerRegistry.h>
 #include <audioapi/utils/AudioFileProperties.h>
+#include <audioapi/jsi/JsiUtils.h>
 #ifdef ANDROID
 #include <audioapi/android/core/AndroidAudioRecorder.h>
 #else
@@ -41,7 +42,7 @@ AudioRecorderHostObject::AudioRecorderHostObject(
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioRecorderHostObject, start) {
-  auto fileNameOverride = count > 0 ? args[0].getString(runtime).utf8(runtime) : "";
+  auto fileNameOverride = jsiutils::argToString(runtime, args, count, 0, "");
   auto result = audioRecorder_->start(fileNameOverride);
   auto jsResult = jsi::Object(runtime);