react-native-audio-api 0.11.0-nightly-141c86f-20251118 → 0.11.0-nightly-4e6f25c-20251119

package/common/cpp/audioapi/HostObjects/AudioParamHostObject.cpp

@@ -1,11 +1,12 @@
 #include <audioapi/HostObjects/AudioParamHostObject.h>
 
 #include <audioapi/core/AudioParam.h>
+#include <memory>
+#include <utility>
 
 namespace audioapi {
 
-AudioParamHostObject::AudioParamHostObject(
-    const std::shared_ptr<AudioParam> &param)
+AudioParamHostObject::AudioParamHostObject(const std::shared_ptr<AudioParam> &param)
     : param_(param) {
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(AudioParamHostObject, value),
@@ -75,14 +76,11 @@ JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, setTargetAtTime) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AudioParamHostObject, setValueCurveAtTime) {
-  auto arrayBuffer = args[0]
-                         .getObject(runtime)
-                         .getPropertyAsObject(runtime, "buffer")
-                         .getArrayBuffer(runtime);
+  auto arrayBuffer =
+      args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
   auto rawValues = reinterpret_cast<float *>(arrayBuffer.data(runtime));
   auto length = static_cast<int>(arrayBuffer.size(runtime));
-  auto values =
-      std::make_unique<std::vector<float>>(rawValues, rawValues + length);
+  auto values = std::make_unique<std::vector<float>>(rawValues, rawValues + length);
 
   double startTime = args[1].getNumber();
   double duration = args[2].getNumber();

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

@@ -3,10 +3,10 @@
 #include <audioapi/jsi/JsiHostObject.h>
 
 #include <jsi/jsi.h>
-#include <utility>
+#include <cstddef>
 #include <memory>
+#include <utility>
 #include <vector>
-#include <cstddef>
 
 namespace audioapi {
 using namespace facebook;

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

@@ -19,6 +19,9 @@
 #include <audioapi/HostObjects/sources/WorkletSourceNodeHostObject.h>
 #include <audioapi/core/BaseAudioContext.h>
 
+#include <memory>
+#include <vector>
+
 namespace audioapi {
 
 BaseAudioContextHostObject::BaseAudioContextHostObject(
@@ -37,8 +40,7 @@ BaseAudioContextHostObject::BaseAudioContextHostObject(
   addFunctions(
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createWorkletSourceNode),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createWorkletNode),
-      JSI_EXPORT_FUNCTION(
-          BaseAudioContextHostObject, createWorkletProcessingNode),
+      JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createWorkletProcessingNode),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createRecorderAdapter),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createOscillator),
       JSI_EXPORT_FUNCTION(BaseAudioContextHostObject, createStreamer),
@@ -55,8 +57,7 @@ BaseAudioContextHostObject::BaseAudioContextHostObject(
 }
 
 JSI_PROPERTY_GETTER_IMPL(BaseAudioContextHostObject, destination) {
-  auto destination = std::make_shared<AudioDestinationNodeHostObject>(
-      context_->getDestination());
+  auto destination = std::make_shared<AudioDestinationNodeHostObject>(context_->getDestination());
   return jsi::Object::createFromHostObject(runtime, destination);
 }
 
@@ -75,8 +76,7 @@ JSI_PROPERTY_GETTER_IMPL(BaseAudioContextHostObject, currentTime) {
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletSourceNode) {
 #if RN_AUDIO_API_ENABLE_WORKLETS
   auto shareableWorklet =
-      worklets::extractSerializableOrThrow<worklets::SerializableWorklet>(
-          runtime, args[0]);
+      worklets::extractSerializableOrThrow<worklets::SerializableWorklet>(runtime, args[0]);
   std::weak_ptr<worklets::WorkletRuntime> workletRuntime;
   auto shouldUseUiRuntime = args[1].getBool();
   auto shouldLockRuntime = shouldUseUiRuntime;
@@ -86,12 +86,11 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletSourceNode) {
     workletRuntime = context_->runtimeRegistry_.audioRuntime;
   }
 
-  auto workletSourceNode = context_->createWorkletSourceNode(
-      shareableWorklet, workletRuntime, shouldLockRuntime);
+  auto workletSourceNode =
+      context_->createWorkletSourceNode(shareableWorklet, workletRuntime, shouldLockRuntime);
   auto workletSourceNodeHostObject =
       std::make_shared<WorkletSourceNodeHostObject>(workletSourceNode);
-  return jsi::Object::createFromHostObject(
-      runtime, workletSourceNodeHostObject);
+  return jsi::Object::createFromHostObject(runtime, workletSourceNodeHostObject);
 #endif
   return jsi::Value::undefined();
 }
@@ -99,8 +98,7 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletSourceNode) {
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletNode) {
 #if RN_AUDIO_API_ENABLE_WORKLETS
   auto shareableWorklet =
-      worklets::extractSerializableOrThrow<worklets::SerializableWorklet>(
-          runtime, args[0]);
+      worklets::extractSerializableOrThrow<worklets::SerializableWorklet>(runtime, args[0]);
 
   std::weak_ptr<worklets::WorkletRuntime> workletRuntime;
   auto shouldUseUiRuntime = args[1].getBool();
@@ -114,31 +112,21 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletNode) {
   auto inputChannelCount = static_cast<size_t>(args[3].getNumber());
 
   auto workletNode = context_->createWorkletNode(
-      shareableWorklet,
-      workletRuntime,
-      bufferLength,
-      inputChannelCount,
-      shouldLockRuntime);
-  auto workletNodeHostObject =
-      std::make_shared<WorkletNodeHostObject>(workletNode);
-  auto jsiObject =
-      jsi::Object::createFromHostObject(runtime, workletNodeHostObject);
+      shareableWorklet, workletRuntime, bufferLength, inputChannelCount, shouldLockRuntime);
+  auto workletNodeHostObject = std::make_shared<WorkletNodeHostObject>(workletNode);
+  auto jsiObject = jsi::Object::createFromHostObject(runtime, workletNodeHostObject);
   jsiObject.setExternalMemoryPressure(
       runtime,
-      sizeof(float) * bufferLength *
-          inputChannelCount); // rough estimate of underlying buffer
+      sizeof(float) * bufferLength * inputChannelCount); // rough estimate of underlying buffer
   return jsiObject;
 #endif
   return jsi::Value::undefined();
 }
 
-JSI_HOST_FUNCTION_IMPL(
-    BaseAudioContextHostObject,
-    createWorkletProcessingNode) {
+JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createWorkletProcessingNode) {
 #if RN_AUDIO_API_ENABLE_WORKLETS
   auto shareableWorklet =
-      worklets::extractSerializableOrThrow<worklets::SerializableWorklet>(
-          runtime, args[0]);
+      worklets::extractSerializableOrThrow<worklets::SerializableWorklet>(runtime, args[0]);
 
   std::weak_ptr<worklets::WorkletRuntime> workletRuntime;
   auto shouldUseUiRuntime = args[1].getBool();
@@ -149,27 +137,24 @@ JSI_HOST_FUNCTION_IMPL(
     workletRuntime = context_->runtimeRegistry_.audioRuntime;
   }
 
-  auto workletProcessingNode = context_->createWorkletProcessingNode(
-      shareableWorklet, workletRuntime, shouldLockRuntime);
+  auto workletProcessingNode =
+      context_->createWorkletProcessingNode(shareableWorklet, workletRuntime, shouldLockRuntime);
   auto workletProcessingNodeHostObject =
       std::make_shared<WorkletProcessingNodeHostObject>(workletProcessingNode);
-  return jsi::Object::createFromHostObject(
-      runtime, workletProcessingNodeHostObject);
+  return jsi::Object::createFromHostObject(runtime, workletProcessingNodeHostObject);
 #endif
   return jsi::Value::undefined();
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createRecorderAdapter) {
   auto recorderAdapter = context_->createRecorderAdapter();
-  auto recorderAdapterHostObject =
-      std::make_shared<RecorderAdapterNodeHostObject>(recorderAdapter);
+  auto recorderAdapterHostObject = std::make_shared<RecorderAdapterNodeHostObject>(recorderAdapter);
   return jsi::Object::createFromHostObject(runtime, recorderAdapterHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createOscillator) {
   auto oscillator = context_->createOscillator();
-  auto oscillatorHostObject =
-      std::make_shared<OscillatorNodeHostObject>(oscillator);
+  auto oscillatorHostObject = std::make_shared<OscillatorNodeHostObject>(oscillator);
   return jsi::Object::createFromHostObject(runtime, oscillatorHostObject);
 }
 
@@ -177,15 +162,13 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createStreamer) {
   auto streamer = context_->createStreamer();
   auto streamerHostObject = std::make_shared<StreamerNodeHostObject>(streamer);
   auto object = jsi::Object::createFromHostObject(runtime, streamerHostObject);
-  object.setExternalMemoryPressure(
-      runtime, StreamerNodeHostObject::getSizeInBytes());
+  object.setExternalMemoryPressure(runtime, StreamerNodeHostObject::getSizeInBytes());
   return object;
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createConstantSource) {
   auto constantSource = context_->createConstantSource();
-  auto constantSourceHostObject =
-      std::make_shared<ConstantSourceNodeHostObject>(constantSource);
+  auto constantSourceHostObject = std::make_shared<ConstantSourceNodeHostObject>(constantSource);
   return jsi::Object::createFromHostObject(runtime, constantSourceHostObject);
 }
 
@@ -197,23 +180,20 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createGain) {
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createStereoPanner) {
   auto stereoPanner = context_->createStereoPanner();
-  auto stereoPannerHostObject =
-      std::make_shared<StereoPannerNodeHostObject>(stereoPanner);
+  auto stereoPannerHostObject = std::make_shared<StereoPannerNodeHostObject>(stereoPanner);
   return jsi::Object::createFromHostObject(runtime, stereoPannerHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBiquadFilter) {
   auto biquadFilter = context_->createBiquadFilter();
-  auto biquadFilterHostObject =
-      std::make_shared<BiquadFilterNodeHostObject>(biquadFilter);
+  auto biquadFilterHostObject = std::make_shared<BiquadFilterNodeHostObject>(biquadFilter);
   return jsi::Object::createFromHostObject(runtime, biquadFilterHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBufferSource) {
   auto pitchCorrection = args[0].asBool();
   auto bufferSource = context_->createBufferSource(pitchCorrection);
-  auto bufferSourceHostObject =
-      std::make_shared<AudioBufferSourceNodeHostObject>(bufferSource);
+  auto bufferSourceHostObject = std::make_shared<AudioBufferSourceNodeHostObject>(bufferSource);
   return jsi::Object::createFromHostObject(runtime, bufferSourceHostObject);
 }
 
@@ -222,37 +202,30 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBufferQueueSource) {
   auto bufferSource = context_->createBufferQueueSource(pitchCorrection);
   auto bufferStreamSourceHostObject =
       std::make_shared<AudioBufferQueueSourceNodeHostObject>(bufferSource);
-  return jsi::Object::createFromHostObject(
-      runtime, bufferStreamSourceHostObject);
+  return jsi::Object::createFromHostObject(runtime, bufferStreamSourceHostObject);
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createBuffer) {
   auto numberOfChannels = static_cast<int>(args[0].getNumber());
   auto length = static_cast<size_t>(args[1].getNumber());
   auto sampleRate = static_cast<float>(args[2].getNumber());
-  auto buffer =
-      BaseAudioContext::createBuffer(numberOfChannels, length, sampleRate);
+  auto buffer = BaseAudioContext::createBuffer(numberOfChannels, length, sampleRate);
   auto bufferHostObject = std::make_shared<AudioBufferHostObject>(buffer);
 
   auto jsiObject = jsi::Object::createFromHostObject(runtime, bufferHostObject);
-  jsiObject.setExternalMemoryPressure(
-      runtime, bufferHostObject->getSizeInBytes());
+  jsiObject.setExternalMemoryPressure(runtime, bufferHostObject->getSizeInBytes());
 
   return jsiObject;
 }
 
 JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createPeriodicWave) {
-  auto arrayBufferReal = args[0]
-                             .getObject(runtime)
-                             .getPropertyAsObject(runtime, "buffer")
-                             .getArrayBuffer(runtime);
+  auto arrayBufferReal =
+      args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
   auto real = reinterpret_cast<float *>(arrayBufferReal.data(runtime));
   auto length = static_cast<int>(arrayBufferReal.size(runtime));
 
-  auto arrayBufferImag = args[1]
-                             .getObject(runtime)
-                             .getPropertyAsObject(runtime, "buffer")
-                             .getArrayBuffer(runtime);
+  auto arrayBufferImag =
+      args[1].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
   auto imag = reinterpret_cast<float *>(arrayBufferImag.data(runtime));
 
   auto disableNormalization = args[2].getBool();
@@ -260,14 +233,11 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createPeriodicWave) {
   auto complexData = std::vector<std::complex<float>>(length);
 
   for (size_t i = 0; i < length; i++) {
-    complexData[i] = std::complex<float>(
-        static_cast<float>(real[i]), static_cast<float>(imag[i]));
+    complexData[i] = std::complex<float>(static_cast<float>(real[i]), static_cast<float>(imag[i]));
   }
 
-  auto periodicWave =
-      context_->createPeriodicWave(complexData, disableNormalization, length);
-  auto periodicWaveHostObject =
-      std::make_shared<PeriodicWaveHostObject>(periodicWave);
+  auto periodicWave = context_->createPeriodicWave(complexData, disableNormalization, length);
+  auto periodicWaveHostObject = std::make_shared<PeriodicWaveHostObject>(periodicWave);
 
   return jsi::Object::createFromHostObject(runtime, periodicWaveHostObject);
 }
@@ -284,20 +254,14 @@ JSI_HOST_FUNCTION_IMPL(BaseAudioContextHostObject, createConvolver) {
   if (args[0].isUndefined()) {
     convolver = context_->createConvolver(nullptr, disableNormalization);
   } else {
-    auto bufferHostObject =
-        args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
-    convolver = context_->createConvolver(
-        bufferHostObject->audioBuffer_, disableNormalization);
+    auto bufferHostObject = args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
+    convolver = context_->createConvolver(bufferHostObject->audioBuffer_, disableNormalization);
   }
-  auto convolverHostObject =
-      std::make_shared<ConvolverNodeHostObject>(convolver);
-  auto jsiObject =
-      jsi::Object::createFromHostObject(runtime, convolverHostObject);
+  auto convolverHostObject = std::make_shared<ConvolverNodeHostObject>(convolver);
+  auto jsiObject = jsi::Object::createFromHostObject(runtime, convolverHostObject);
   if (!args[0].isUndefined()) {
-    auto bufferHostObject =
-        args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
-    jsiObject.setExternalMemoryPressure(
-        runtime, bufferHostObject->getSizeInBytes());
+    auto bufferHostObject = args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
+    jsiObject.setExternalMemoryPressure(runtime, bufferHostObject->getSizeInBytes());
   }
   return jsiObject;
 }

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

@@ -4,10 +4,10 @@
 #include <audioapi/jsi/JsiPromise.h>
 
 #include <jsi/jsi.h>
+#include <cstddef>
 #include <memory>
 #include <utility>
 #include <vector>
-#include <cstddef>
 
 namespace audioapi {
 using namespace facebook;

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

@@ -2,6 +2,8 @@
 
 #include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
 #include <audioapi/core/OfflineAudioContext.h>
+#include <memory>
+#include <utility>
 
 namespace audioapi {
 
@@ -33,10 +35,8 @@ JSI_HOST_FUNCTION_IMPL(OfflineAudioContextHostObject, suspend) {
   auto audioContext = std::static_pointer_cast<OfflineAudioContext>(context_);
 
   auto promise = promiseVendor_->createAsyncPromise([=](Promise &&promise) {
-    OfflineAudioContextSuspendCallback callback = [promise =
-                                                       std::move(promise)]() {
-      promise.resolve(
-          [](jsi::Runtime &runtime) { return jsi::Value::undefined(); });
+    OfflineAudioContextSuspendCallback callback = [promise = std::move(promise)]() {
+      promise.resolve([](jsi::Runtime &runtime) { return jsi::Value::undefined(); });
     };
     audioContext->suspend(when, callback);
   });
@@ -46,21 +46,17 @@ JSI_HOST_FUNCTION_IMPL(OfflineAudioContextHostObject, suspend) {
 
 JSI_HOST_FUNCTION_IMPL(OfflineAudioContextHostObject, startRendering) {
   auto audioContext = std::static_pointer_cast<OfflineAudioContext>(context_);
-  auto promise =
-      promiseVendor_->createAsyncPromise([audioContext](Promise &&promise) {
-        OfflineAudioContextResultCallback callback =
-            [promise = std::move(promise)](
-                const std::shared_ptr<AudioBuffer> &audioBuffer) {
-              auto audioBufferHostObject =
-                  std::make_shared<AudioBufferHostObject>(audioBuffer);
-              promise.resolve([audioBufferHostObject](jsi::Runtime &runtime) {
-                return jsi::Object::createFromHostObject(
-                    runtime, audioBufferHostObject);
-              });
-            };
+  auto promise = promiseVendor_->createAsyncPromise([audioContext](Promise &&promise) {
+    OfflineAudioContextResultCallback callback =
+        [promise = std::move(promise)](const std::shared_ptr<AudioBuffer> &audioBuffer) {
+          auto audioBufferHostObject = std::make_shared<AudioBufferHostObject>(audioBuffer);
+          promise.resolve([audioBufferHostObject](jsi::Runtime &runtime) {
+            return jsi::Object::createFromHostObject(runtime, audioBufferHostObject);
+          });
+        };
 
-        audioContext->startRendering(callback);
-      });
+    audioContext->startRendering(callback);
+  });
 
   return promise;
 }

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

@@ -15,9 +15,9 @@ class OfflineAudioContext;
 class OfflineAudioContextHostObject : public BaseAudioContextHostObject {
  public:
   explicit OfflineAudioContextHostObject(
-          const std::shared_ptr<OfflineAudioContext> &offlineAudioContext,
-          jsi::Runtime *runtime,
-          const std::shared_ptr<react::CallInvoker> &callInvoker);
+      const std::shared_ptr<OfflineAudioContext> &offlineAudioContext,
+      jsi::Runtime *runtime,
+      const std::shared_ptr<react::CallInvoker> &callInvoker);
 
   JSI_HOST_FUNCTION_DECL(resume);
   JSI_HOST_FUNCTION_DECL(suspend);

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

@@ -12,7 +12,6 @@ using namespace facebook;
 class WorkletNodeHostObject : public AudioNodeHostObject {
  public:
   explicit WorkletNodeHostObject(const std::shared_ptr<WorkletNode> &node)
-      : AudioNodeHostObject(node) {
-  }
+      : AudioNodeHostObject(node) {}
 };
 } // namespace audioapi

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

@@ -12,7 +12,6 @@ using namespace facebook;
 class WorkletProcessingNodeHostObject : public AudioNodeHostObject {
  public:
   explicit WorkletProcessingNodeHostObject(const std::shared_ptr<WorkletProcessingNode> &node)
-      : AudioNodeHostObject(node) {
-  }
+      : AudioNodeHostObject(node) {}
 };
 } // namespace audioapi

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

@@ -1,11 +1,11 @@
 #include <audioapi/HostObjects/analysis/AnalyserNodeHostObject.h>
 
 #include <audioapi/core/analysis/AnalyserNode.h>
+#include <memory>
 
 namespace audioapi {
 
-AnalyserNodeHostObject::AnalyserNodeHostObject(
-    const std::shared_ptr<AnalyserNode> &node)
+AnalyserNodeHostObject::AnalyserNodeHostObject(const std::shared_ptr<AnalyserNode> &node)
     : AudioNodeHostObject(node) {
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, fftSize),
@@ -90,10 +90,8 @@ JSI_PROPERTY_SETTER_IMPL(AnalyserNodeHostObject, window) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getFloatFrequencyData) {
-  auto arrayBuffer = args[0]
-                         .getObject(runtime)
-                         .getPropertyAsObject(runtime, "buffer")
-                         .getArrayBuffer(runtime);
+  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));
 
@@ -104,10 +102,8 @@ JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getFloatFrequencyData) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getByteFrequencyData) {
-  auto arrayBuffer = args[0]
-                         .getObject(runtime)
-                         .getPropertyAsObject(runtime, "buffer")
-                         .getArrayBuffer(runtime);
+  auto arrayBuffer =
+      args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
   auto data = arrayBuffer.data(runtime);
   auto length = static_cast<int>(arrayBuffer.size(runtime));
 
@@ -118,10 +114,8 @@ JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getByteFrequencyData) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getFloatTimeDomainData) {
-  auto arrayBuffer = args[0]
-                         .getObject(runtime)
-                         .getPropertyAsObject(runtime, "buffer")
-                         .getArrayBuffer(runtime);
+  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));
 
@@ -132,10 +126,8 @@ JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getFloatTimeDomainData) {
 }
 
 JSI_HOST_FUNCTION_IMPL(AnalyserNodeHostObject, getByteTimeDomainData) {
-  auto arrayBuffer = args[0]
-                         .getObject(runtime)
-                         .getPropertyAsObject(runtime, "buffer")
-                         .getArrayBuffer(runtime);
+  auto arrayBuffer =
+      args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
   auto data = arrayBuffer.data(runtime);
   auto length = static_cast<int>(arrayBuffer.size(runtime));
 

package/common/cpp/audioapi/HostObjects/destinations/AudioDestinationNodeHostObject.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <audioapi/core/destinations/AudioDestinationNode.h>
 #include <audioapi/HostObjects/AudioNodeHostObject.h>
+#include <audioapi/core/destinations/AudioDestinationNode.h>
 
 #include <memory>
 #include <vector>
@@ -11,8 +11,7 @@ using namespace facebook;
 
 class AudioDestinationNodeHostObject : public AudioNodeHostObject {
  public:
-  explicit AudioDestinationNodeHostObject(
-      const std::shared_ptr<AudioDestinationNode> &node)
+  explicit AudioDestinationNodeHostObject(const std::shared_ptr<AudioDestinationNode> &node)
       : AudioNodeHostObject(node) {}
 };
 } // namespace audioapi

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

@@ -2,6 +2,7 @@
 
 #include <audioapi/HostObjects/AudioParamHostObject.h>
 #include <audioapi/core/effects/BiquadFilterNode.h>
+#include <memory>
 
 namespace audioapi {
 
@@ -17,35 +18,31 @@ BiquadFilterNodeHostObject::BiquadFilterNodeHostObject(
 
   addSetters(JSI_EXPORT_PROPERTY_SETTER(BiquadFilterNodeHostObject, type));
 
-  addFunctions(
-      JSI_EXPORT_FUNCTION(BiquadFilterNodeHostObject, getFrequencyResponse));
+  addFunctions(JSI_EXPORT_FUNCTION(BiquadFilterNodeHostObject, getFrequencyResponse));
 }
 
 JSI_PROPERTY_GETTER_IMPL(BiquadFilterNodeHostObject, frequency) {
   auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
-  auto frequencyParam_ = std::make_shared<AudioParamHostObject>(
-      biquadFilterNode->getFrequencyParam());
+  auto frequencyParam_ =
+      std::make_shared<AudioParamHostObject>(biquadFilterNode->getFrequencyParam());
   return jsi::Object::createFromHostObject(runtime, frequencyParam_);
 }
 
 JSI_PROPERTY_GETTER_IMPL(BiquadFilterNodeHostObject, detune) {
   auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
-  auto detuneParam_ = std::make_shared<AudioParamHostObject>(
-      biquadFilterNode->getDetuneParam());
+  auto detuneParam_ = std::make_shared<AudioParamHostObject>(biquadFilterNode->getDetuneParam());
   return jsi::Object::createFromHostObject(runtime, detuneParam_);
 }
 
 JSI_PROPERTY_GETTER_IMPL(BiquadFilterNodeHostObject, Q) {
   auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
-  auto QParam_ =
-      std::make_shared<AudioParamHostObject>(biquadFilterNode->getQParam());
+  auto QParam_ = std::make_shared<AudioParamHostObject>(biquadFilterNode->getQParam());
   return jsi::Object::createFromHostObject(runtime, QParam_);
 }
 
 JSI_PROPERTY_GETTER_IMPL(BiquadFilterNodeHostObject, gain) {
   auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
-  auto gainParam_ =
-      std::make_shared<AudioParamHostObject>(biquadFilterNode->getGainParam());
+  auto gainParam_ = std::make_shared<AudioParamHostObject>(biquadFilterNode->getGainParam());
   return jsi::Object::createFromHostObject(runtime, gainParam_);
 }
 
@@ -61,30 +58,21 @@ JSI_PROPERTY_SETTER_IMPL(BiquadFilterNodeHostObject, type) {
 }
 
 JSI_HOST_FUNCTION_IMPL(BiquadFilterNodeHostObject, getFrequencyResponse) {
-  auto arrayBufferFrequency = args[0]
-                                  .getObject(runtime)
-                                  .getPropertyAsObject(runtime, "buffer")
-                                  .getArrayBuffer(runtime);
-  auto frequencyArray =
-      reinterpret_cast<float *>(arrayBufferFrequency.data(runtime));
+  auto arrayBufferFrequency =
+      args[0].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+  auto frequencyArray = reinterpret_cast<float *>(arrayBufferFrequency.data(runtime));
   auto length = static_cast<size_t>(arrayBufferFrequency.size(runtime));
 
-  auto arrayBufferMag = args[1]
-                            .getObject(runtime)
-                            .getPropertyAsObject(runtime, "buffer")
-                            .getArrayBuffer(runtime);
+  auto arrayBufferMag =
+      args[1].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
   auto magResponseOut = reinterpret_cast<float *>(arrayBufferMag.data(runtime));
 
-  auto arrayBufferPhase = args[2]
-                              .getObject(runtime)
-                              .getPropertyAsObject(runtime, "buffer")
-                              .getArrayBuffer(runtime);
-  auto phaseResponseOut =
-      reinterpret_cast<float *>(arrayBufferPhase.data(runtime));
+  auto arrayBufferPhase =
+      args[2].getObject(runtime).getPropertyAsObject(runtime, "buffer").getArrayBuffer(runtime);
+  auto phaseResponseOut = reinterpret_cast<float *>(arrayBufferPhase.data(runtime));
 
   auto biquadFilterNode = std::static_pointer_cast<BiquadFilterNode>(node_);
-  biquadFilterNode->getFrequencyResponse(
-      frequencyArray, magResponseOut, phaseResponseOut, length);
+  biquadFilterNode->getFrequencyResponse(frequencyArray, magResponseOut, phaseResponseOut, length);
 
   return jsi::Value::undefined();
 }

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

@@ -13,8 +13,7 @@ class BiquadFilterNode;
 
 class BiquadFilterNodeHostObject : public AudioNodeHostObject {
  public:
-  explicit BiquadFilterNodeHostObject(
-      const std::shared_ptr<BiquadFilterNode> &node);
+  explicit BiquadFilterNodeHostObject(const std::shared_ptr<BiquadFilterNode> &node);
 
   JSI_PROPERTY_GETTER_DECL(frequency);
   JSI_PROPERTY_GETTER_DECL(detune);

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

@@ -2,11 +2,11 @@
 
 #include <audioapi/HostObjects/sources/AudioBufferHostObject.h>
 #include <audioapi/core/effects/ConvolverNode.h>
+#include <memory>
 
 namespace audioapi {
 
-ConvolverNodeHostObject::ConvolverNodeHostObject(
-    const std::shared_ptr<ConvolverNode> &node)
+ConvolverNodeHostObject::ConvolverNodeHostObject(const std::shared_ptr<ConvolverNode> &node)
     : AudioNodeHostObject(node) {
   addGetters(
       JSI_EXPORT_PROPERTY_GETTER(ConvolverNodeHostObject, normalize),
@@ -25,8 +25,7 @@ JSI_PROPERTY_GETTER_IMPL(ConvolverNodeHostObject, buffer) {
   auto buffer = convolverNode->getBuffer();
   auto bufferHostObject = std::make_shared<AudioBufferHostObject>(buffer);
   auto jsiObject = jsi::Object::createFromHostObject(runtime, bufferHostObject);
-  jsiObject.setExternalMemoryPressure(
-      runtime, bufferHostObject->getSizeInBytes() + 16);
+  jsiObject.setExternalMemoryPressure(runtime, bufferHostObject->getSizeInBytes() + 16);
   return jsiObject;
 }
 
@@ -42,8 +41,7 @@ JSI_HOST_FUNCTION_IMPL(ConvolverNodeHostObject, setBuffer) {
     return jsi::Value::undefined();
   }
 
-  auto bufferHostObject =
-      args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
+  auto bufferHostObject = args[0].getObject(runtime).asHostObject<AudioBufferHostObject>(runtime);
   convolverNode->setBuffer(bufferHostObject->audioBuffer_);
   thisValue.asObject(runtime).setExternalMemoryPressure(
       runtime, bufferHostObject->getSizeInBytes() + 16);

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

@@ -2,6 +2,7 @@
 
 #include <audioapi/HostObjects/AudioParamHostObject.h>
 #include <audioapi/core/effects/GainNode.h>
+#include <memory>
 
 namespace audioapi {
 
@@ -12,8 +13,7 @@ GainNodeHostObject::GainNodeHostObject(const std::shared_ptr<GainNode> &node)
 
 JSI_PROPERTY_GETTER_IMPL(GainNodeHostObject, gain) {
   auto gainNode = std::static_pointer_cast<GainNode>(node_);
-  auto gainParam =
-      std::make_shared<AudioParamHostObject>(gainNode->getGainParam());
+  auto gainParam = std::make_shared<AudioParamHostObject>(gainNode->getGainParam());
   return jsi::Object::createFromHostObject(runtime, gainParam);
 }