react-native-reanimated 2.3.0-alpha.3 → 2.3.0-beta.4

package/Common/cpp/LayoutAnimations/LayoutAnimationsProxy.cpp

@@ -1,20 +1,27 @@
 #include "LayoutAnimationsProxy.h"
+#include "FrozenObject.h"
 #include "MutableValue.h"
-#include "ValueWrapper.h"
 #include "ShareableValue.h"
-#include "FrozenObject.h"
+#include "ValueWrapper.h"
 
 namespace reanimated {
 
 const long long idOffset = 1e9;
 
-LayoutAnimationsProxy::LayoutAnimationsProxy(std::function<void(int, jsi::Object newProps)> _notifyAboutProgress, std::function<void(int, bool)> _notifyAboutEnd): notifyAboutProgress(std::move(_notifyAboutProgress)), notifyAboutEnd(std::move(_notifyAboutEnd)) {
-}
+LayoutAnimationsProxy::LayoutAnimationsProxy(
+    std::function<void(int, jsi::Object newProps)> _notifyAboutProgress,
+    std::function<void(int, bool)> _notifyAboutEnd)
+    : notifyAboutProgress(std::move(_notifyAboutProgress)),
+      notifyAboutEnd(std::move(_notifyAboutEnd)) {}
 
-void LayoutAnimationsProxy::startObserving(int tag, std::shared_ptr<MutableValue> sv, jsi::Runtime &rt) {
+void LayoutAnimationsProxy::startObserving(
+    int tag,
+    std::shared_ptr<MutableValue> sv,
+    jsi::Runtime &rt) {
   observedValues[tag] = sv;
-  sv->addListener(tag + idOffset, [sv, tag, this, &rt](){
-    std::shared_ptr<FrozenObject> newValue = ValueWrapper::asFrozenObject(sv->value->valueContainer);
+  sv->addListener(tag + idOffset, [sv, tag, this, &rt]() {
+    std::shared_ptr<FrozenObject> newValue =
+        ValueWrapper::asFrozenObject(sv->value->valueContainer);
     this->notifyAboutProgress(tag, newValue->shallowClone(rt));
   });
 }
@@ -33,4 +40,4 @@ void LayoutAnimationsProxy::notifyAboutCancellation(int tag) {
   this->notifyAboutEnd(tag, false);
 }
 
-}
+} // namespace reanimated

package/Common/cpp/NativeModules/NativeReanimatedModule.cpp

@@ -1,77 +1,76 @@
 #include "NativeReanimatedModule.h"
-#include "ShareableValue.h"
-#include "MapperRegistry.h"
-#include "Mapper.h"
-#include "RuntimeDecorator.h"
-#include "EventHandlerRegistry.h"
-#include "WorkletEventHandler.h"
-#include "FrozenObject.h"
 #include <functional>
-#include <thread>
 #include <memory>
+#include <thread>
+#include "EventHandlerRegistry.h"
+#include "FeaturesConfig.h"
+#include "FrozenObject.h"
 #include "JSIStoreValueUser.h"
+#include "Mapper.h"
+#include "MapperRegistry.h"
 #include "ReanimatedHiddenHeaders.h"
+#include "RuntimeDecorator.h"
+#include "ShareableValue.h"
+#include "WorkletEventHandler.h"
 
 using namespace facebook;
 
-namespace reanimated
-{
-
-void extractMutables(jsi::Runtime &rt,
-                     std::shared_ptr<ShareableValue> sv,
-                     std::vector<std::shared_ptr<MutableValue>> &res)
-{
-  switch (sv->type)
-  {
-  case ValueType::MutableValueType: {
-    auto& mutableValue = ValueWrapper::asMutableValue(sv->valueContainer);
-    res.push_back(mutableValue);
-    break;
-  }
-  case ValueType::FrozenArrayType:
-    for (auto &it : ValueWrapper::asFrozenArray(sv->valueContainer))
-    {
-      extractMutables(rt, it, res);
+namespace reanimated {
+
+void extractMutables(
+    jsi::Runtime &rt,
+    std::shared_ptr<ShareableValue> sv,
+    std::vector<std::shared_ptr<MutableValue>> &res) {
+  switch (sv->type) {
+    case ValueType::MutableValueType: {
+      auto &mutableValue = ValueWrapper::asMutableValue(sv->valueContainer);
+      res.push_back(mutableValue);
+      break;
     }
-    break;
-  case ValueType::RemoteObjectType:
-  case ValueType::FrozenObjectType:
-    for (auto &it : ValueWrapper::asFrozenObject(sv->valueContainer)->map)
-    {
-      extractMutables(rt, it.second, res);
-    }
-    break;
-  default:
-    break;
+    case ValueType::FrozenArrayType:
+      for (auto &it : ValueWrapper::asFrozenArray(sv->valueContainer)) {
+        extractMutables(rt, it, res);
+      }
+      break;
+    case ValueType::RemoteObjectType:
+    case ValueType::FrozenObjectType:
+      for (auto &it : ValueWrapper::asFrozenObject(sv->valueContainer)->map) {
+        extractMutables(rt, it.second, res);
+      }
+      break;
+    default:
+      break;
   }
 }
 
-std::vector<std::shared_ptr<MutableValue>> extractMutablesFromArray(jsi::Runtime &rt, const jsi::Array &array, NativeReanimatedModule *module)
-{
+std::vector<std::shared_ptr<MutableValue>> extractMutablesFromArray(
+    jsi::Runtime &rt,
+    const jsi::Array &array,
+    NativeReanimatedModule *module) {
   std::vector<std::shared_ptr<MutableValue>> res;
-  for (size_t i = 0, size = array.size(rt); i < size; i++)
-  {
-    auto shareable = ShareableValue::adapt(rt, array.getValueAtIndex(rt, i), module);
+  for (size_t i = 0, size = array.size(rt); i < size; i++) {
+    auto shareable =
+        ShareableValue::adapt(rt, array.getValueAtIndex(rt, i), module);
     extractMutables(rt, shareable, res);
   }
   return res;
 }
 
-NativeReanimatedModule::NativeReanimatedModule(std::shared_ptr<CallInvoker> jsInvoker,
-                                               std::shared_ptr<Scheduler> scheduler,
-                                               std::shared_ptr<jsi::Runtime> rt,
-                                               std::shared_ptr<ErrorHandler> errorHandler,
-                                               std::function<jsi::Value(jsi::Runtime &, const int, const jsi::String &)> propObtainer,
-                                               std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy,
-                                               PlatformDepMethodsHolder platformDepMethodsHolder) :
-                                                  NativeReanimatedModuleSpec(jsInvoker),
-                                                  RuntimeManager(rt, errorHandler, scheduler, RuntimeType::UI),
-                                                  mapperRegistry(std::make_shared<MapperRegistry>()),
-                                                  eventHandlerRegistry(std::make_shared<EventHandlerRegistry>()),
-                                                  requestRender(platformDepMethodsHolder.requestRender),
-                                                  propObtainer(propObtainer)
-{
-
+NativeReanimatedModule::NativeReanimatedModule(
+    std::shared_ptr<CallInvoker> jsInvoker,
+    std::shared_ptr<Scheduler> scheduler,
+    std::shared_ptr<jsi::Runtime> rt,
+    std::shared_ptr<ErrorHandler> errorHandler,
+    std::function<jsi::Value(jsi::Runtime &, const int, const jsi::String &)>
+        propObtainer,
+    std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy,
+    PlatformDepMethodsHolder platformDepMethodsHolder)
+    : NativeReanimatedModuleSpec(jsInvoker),
+      RuntimeManager(rt, errorHandler, scheduler, RuntimeType::UI),
+      mapperRegistry(std::make_shared<MapperRegistry>()),
+      eventHandlerRegistry(std::make_shared<EventHandlerRegistry>()),
+      requestRender(platformDepMethodsHolder.requestRender),
+      propObtainer(propObtainer) {
   auto requestAnimationFrame = [=](FrameCallback callback) {
     frameCallbacks.push_back(callback);
     maybeRequestRender();
@@ -79,86 +78,100 @@ NativeReanimatedModule::NativeReanimatedModule(std::shared_ptr<CallInvoker> jsIn
 
   this->layoutAnimationsProxy = layoutAnimationsProxy;
 
-  RuntimeDecorator::decorateUIRuntime(*runtime,
-                                      platformDepMethodsHolder.updaterFunction,
-                                      requestAnimationFrame,
-                                      platformDepMethodsHolder.scrollToFunction,
-                                      platformDepMethodsHolder.measuringFunction,
-                                      platformDepMethodsHolder.getCurrentTime,
-                                      layoutAnimationsProxy);
-   onRenderCallback = [this](double timestampMs) {
+  RuntimeDecorator::decorateUIRuntime(
+      *runtime,
+      platformDepMethodsHolder.updaterFunction,
+      requestAnimationFrame,
+      platformDepMethodsHolder.scrollToFunction,
+      platformDepMethodsHolder.measuringFunction,
+      platformDepMethodsHolder.getCurrentTime,
+      platformDepMethodsHolder.setGestureStateFunction,
+      layoutAnimationsProxy);
+  onRenderCallback = [this](double timestampMs) {
     this->renderRequested = false;
     this->onRender(timestampMs);
   };
   updaterFunction = platformDepMethodsHolder.updaterFunction;
 }
 
-void NativeReanimatedModule::installCoreFunctions(jsi::Runtime &rt, const jsi::Value &valueSetter)
-{
+void NativeReanimatedModule::installCoreFunctions(
+    jsi::Runtime &rt,
+    const jsi::Value &valueSetter) {
   this->valueSetter = ShareableValue::adapt(rt, valueSetter, this);
 }
 
-jsi::Value NativeReanimatedModule::makeShareable(jsi::Runtime &rt, const jsi::Value &value)
-{
+jsi::Value NativeReanimatedModule::makeShareable(
+    jsi::Runtime &rt,
+    const jsi::Value &value) {
   return ShareableValue::adapt(rt, value, this)->getValue(rt);
 }
 
-jsi::Value NativeReanimatedModule::makeMutable(jsi::Runtime &rt, const jsi::Value &value)
-{
-  return ShareableValue::adapt(rt, value, this, ValueType::MutableValueType)->getValue(rt);
+jsi::Value NativeReanimatedModule::makeMutable(
+    jsi::Runtime &rt,
+    const jsi::Value &value) {
+  return ShareableValue::adapt(rt, value, this, ValueType::MutableValueType)
+      ->getValue(rt);
 }
 
-jsi::Value NativeReanimatedModule::makeRemote(jsi::Runtime &rt, const jsi::Value &value)
-{
-  return ShareableValue::adapt(rt, value, this, ValueType::RemoteObjectType)->getValue(rt);
+jsi::Value NativeReanimatedModule::makeRemote(
+    jsi::Runtime &rt,
+    const jsi::Value &value) {
+  return ShareableValue::adapt(rt, value, this, ValueType::RemoteObjectType)
+      ->getValue(rt);
 }
 
 jsi::Value NativeReanimatedModule::startMapper(
-                                               jsi::Runtime &rt,
-                                               const jsi::Value &worklet,
-                                               const jsi::Value &inputs,
-                                               const jsi::Value &outputs,
-                                               const jsi::Value &updater,
-                                               const jsi::Value &viewDescriptors)
-{
+    jsi::Runtime &rt,
+    const jsi::Value &worklet,
+    const jsi::Value &inputs,
+    const jsi::Value &outputs,
+    const jsi::Value &updater,
+    const jsi::Value &viewDescriptors) {
   static unsigned long MAPPER_ID = 1;
 
   unsigned long newMapperId = MAPPER_ID++;
   auto mapperShareable = ShareableValue::adapt(rt, worklet, this);
-  auto inputMutables = extractMutablesFromArray(rt, inputs.asObject(rt).asArray(rt), this);
-  auto outputMutables = extractMutablesFromArray(rt, outputs.asObject(rt).asArray(rt), this);
+  auto inputMutables =
+      extractMutablesFromArray(rt, inputs.asObject(rt).asArray(rt), this);
+  auto outputMutables =
+      extractMutablesFromArray(rt, outputs.asObject(rt).asArray(rt), this);
 
   int optimalizationLvl = 0;
-  auto optimalization = updater.asObject(rt).getProperty(rt, "__optimalization");
-  if(optimalization.isNumber()) {
+  auto optimalization =
+      updater.asObject(rt).getProperty(rt, "__optimalization");
+  if (optimalization.isNumber()) {
     optimalizationLvl = optimalization.asNumber();
   }
   auto updaterSV = ShareableValue::adapt(rt, updater, this);
   auto viewDescriptorsSV = ShareableValue::adapt(rt, viewDescriptors, this);
 
   scheduler->scheduleOnUI([=] {
-    auto mapperFunction = mapperShareable->getValue(*runtime).asObject(*runtime).asFunction(*runtime);
-    std::shared_ptr<jsi::Function> mapperFunctionPointer = std::make_shared<jsi::Function>(std::move(mapperFunction));
+    auto mapperFunction =
+        mapperShareable->getValue(*runtime).asObject(*runtime).asFunction(
+            *runtime);
+    std::shared_ptr<jsi::Function> mapperFunctionPointer =
+        std::make_shared<jsi::Function>(std::move(mapperFunction));
 
     std::shared_ptr<Mapper> mapperPointer = std::make_shared<Mapper>(
-                                                                     this,
-                                                                     newMapperId,
-                                                                     mapperFunctionPointer,
-                                                                     inputMutables,
-                                                                     outputMutables
-                                                                     );
-    if(optimalizationLvl > 0) {
-      mapperPointer->enableFastMode(optimalizationLvl, updaterSV, viewDescriptorsSV);
+        this,
+        newMapperId,
+        mapperFunctionPointer,
+        inputMutables,
+        outputMutables);
+    if (optimalizationLvl > 0) {
+      mapperPointer->enableFastMode(
+          optimalizationLvl, updaterSV, viewDescriptorsSV);
     }
     mapperRegistry->startMapper(mapperPointer);
     maybeRequestRender();
   });
 
-  return jsi::Value((double)newMapperId);
+  return jsi::Value(static_cast<double>(newMapperId));
 }
 
-void NativeReanimatedModule::stopMapper(jsi::Runtime &rt, const jsi::Value &mapperId)
-{
+void NativeReanimatedModule::stopMapper(
+    jsi::Runtime &rt,
+    const jsi::Value &mapperId) {
   unsigned long id = mapperId.asNumber();
   scheduler->scheduleOnUI([=] {
     mapperRegistry->stopMapper(id);
@@ -166,8 +179,10 @@ void NativeReanimatedModule::stopMapper(jsi::Runtime &rt, const jsi::Value &mapp
   });
 }
 
-jsi::Value NativeReanimatedModule::registerEventHandler(jsi::Runtime &rt, const jsi::Value &eventHash, const jsi::Value &worklet)
-{
+jsi::Value NativeReanimatedModule::registerEventHandler(
+    jsi::Runtime &rt,
+    const jsi::Value &eventHash,
+    const jsi::Value &worklet) {
   static unsigned long EVENT_HANDLER_ID = 1;
 
   unsigned long newRegistrationId = EVENT_HANDLER_ID++;
@@ -175,37 +190,45 @@ jsi::Value NativeReanimatedModule::registerEventHandler(jsi::Runtime &rt, const
   auto handlerShareable = ShareableValue::adapt(rt, worklet, this);
 
   scheduler->scheduleOnUI([=] {
-    auto handlerFunction = handlerShareable->getValue(*runtime).asObject(*runtime).asFunction(*runtime);
-    auto handler = std::make_shared<WorkletEventHandler>(newRegistrationId, eventName, std::move(handlerFunction));
+    auto handlerFunction =
+        handlerShareable->getValue(*runtime).asObject(*runtime).asFunction(
+            *runtime);
+    auto handler = std::make_shared<WorkletEventHandler>(
+        newRegistrationId, eventName, std::move(handlerFunction));
     eventHandlerRegistry->registerEventHandler(handler);
   });
 
-  return jsi::Value((double)newRegistrationId);
+  return jsi::Value(static_cast<double>(newRegistrationId));
 }
 
-void NativeReanimatedModule::unregisterEventHandler(jsi::Runtime &rt, const jsi::Value &registrationId)
-{
+void NativeReanimatedModule::unregisterEventHandler(
+    jsi::Runtime &rt,
+    const jsi::Value &registrationId) {
   unsigned long id = registrationId.asNumber();
-  scheduler->scheduleOnUI([=] {
-    eventHandlerRegistry->unregisterEventHandler(id);
-  });
+  scheduler->scheduleOnUI(
+      [=] { eventHandlerRegistry->unregisterEventHandler(id); });
 }
 
-jsi::Value NativeReanimatedModule::getViewProp(jsi::Runtime &rt, const jsi::Value &viewTag, const jsi::Value &propName, const jsi::Value &callback)
-{
-
-  const int viewTagInt = (int)viewTag.asNumber();
+jsi::Value NativeReanimatedModule::getViewProp(
+    jsi::Runtime &rt,
+    const jsi::Value &viewTag,
+    const jsi::Value &propName,
+    const jsi::Value &callback) {
+  const int viewTagInt = static_cast<int>(viewTag.asNumber());
   std::string propNameStr = propName.asString(rt).utf8(rt);
   jsi::Function fun = callback.getObject(rt).asFunction(rt);
-  std::shared_ptr<jsi::Function> funPtr = std::make_shared<jsi::Function>(std::move(fun));
+  std::shared_ptr<jsi::Function> funPtr =
+      std::make_shared<jsi::Function>(std::move(fun));
 
   scheduler->scheduleOnUI([&rt, viewTagInt, funPtr, this, propNameStr]() {
-    const jsi::String propNameValue = jsi::String::createFromUtf8(rt, propNameStr);
+    const jsi::String propNameValue =
+        jsi::String::createFromUtf8(rt, propNameStr);
     jsi::Value result = propObtainer(rt, viewTagInt, propNameValue);
     std::string resultStr = result.asString(rt).utf8(rt);
 
     scheduler->scheduleOnJS([&rt, resultStr, funPtr]() {
-      const jsi::String resultValue = jsi::String::createFromUtf8(rt, resultStr);
+      const jsi::String resultValue =
+          jsi::String::createFromUtf8(rt, resultStr);
       funPtr->call(rt, resultValue);
     });
   });
@@ -213,63 +236,62 @@ jsi::Value NativeReanimatedModule::getViewProp(jsi::Runtime &rt, const jsi::Valu
   return jsi::Value::undefined();
 }
 
-void NativeReanimatedModule::onEvent(std::string eventName, std::string eventAsString)
-{
-   try
-    {
-      eventHandlerRegistry->processEvent(*runtime, eventName, eventAsString);
-      mapperRegistry->execute(*runtime);
-      if (mapperRegistry->needRunOnRender())
-      {
-        maybeRequestRender();
-      }
+jsi::Value NativeReanimatedModule::enableLayoutAnimations(
+    jsi::Runtime &rt,
+    const jsi::Value &config) {
+  FeaturesConfig::setLayoutAnimationEnabled(config.getBool());
+  return jsi::Value::undefined();
+}
+
+void NativeReanimatedModule::onEvent(
+    std::string eventName,
+    std::string eventAsString) {
+  try {
+    eventHandlerRegistry->processEvent(*runtime, eventName, eventAsString);
+    mapperRegistry->execute(*runtime);
+    if (mapperRegistry->needRunOnRender()) {
+      maybeRequestRender();
     }
-    catch(std::exception &e) {
-     std::string str = e.what();
-     this->errorHandler->setError(str);
-     this->errorHandler->raise();
-   } catch(...) {
-     std::string str = "OnEvent error";
-     this->errorHandler->setError(str);
-     this->errorHandler->raise();
+  } catch (std::exception &e) {
+    std::string str = e.what();
+    this->errorHandler->setError(str);
+    this->errorHandler->raise();
+  } catch (...) {
+    std::string str = "OnEvent error";
+    this->errorHandler->setError(str);
+    this->errorHandler->raise();
   }
 }
 
-bool NativeReanimatedModule::isAnyHandlerWaitingForEvent(std::string eventName) {
+bool NativeReanimatedModule::isAnyHandlerWaitingForEvent(
+    std::string eventName) {
   return eventHandlerRegistry->isAnyHandlerWaitingForEvent(eventName);
 }
 
-
-void NativeReanimatedModule::maybeRequestRender()
-{
-  if (!renderRequested)
-  {
+void NativeReanimatedModule::maybeRequestRender() {
+  if (!renderRequested) {
     renderRequested = true;
     requestRender(onRenderCallback, *this->runtime);
   }
 }
 
-void NativeReanimatedModule::onRender(double timestampMs)
-{
-  try
-  {
-      std::vector<FrameCallback> callbacks = frameCallbacks;
-      frameCallbacks.clear();
-      for (auto& callback : callbacks)
-      {
-        callback(timestampMs);
-      }
-      mapperRegistry->execute(*runtime);
+void NativeReanimatedModule::onRender(double timestampMs) {
+  try {
+    std::vector<FrameCallback> callbacks = frameCallbacks;
+    frameCallbacks.clear();
+    for (auto &callback : callbacks) {
+      callback(timestampMs);
+    }
+    mapperRegistry->execute(*runtime);
 
-    if (mapperRegistry->needRunOnRender())
-    {
+    if (mapperRegistry->needRunOnRender()) {
       maybeRequestRender();
     }
-  } catch(std::exception &e) {
+  } catch (std::exception &e) {
     std::string str = e.what();
     this->errorHandler->setError(str);
     this->errorHandler->raise();
-  } catch(...) {
+  } catch (...) {
     std::string str = "OnRender error";
     this->errorHandler->setError(str);
     this->errorHandler->raise();

package/Common/cpp/NativeModules/NativeReanimatedModuleSpec.cpp

@@ -2,13 +2,14 @@
 
 namespace reanimated {
 
-static jsi::Value __hostFunction_NativeReanimatedModuleSpec_installCoreFunctions(
+static jsi::Value
+__hostFunction_NativeReanimatedModuleSpec_installCoreFunctions(
     jsi::Runtime &rt,
     TurboModule &turboModule,
     const jsi::Value *args,
     size_t count) {
   static_cast<NativeReanimatedModuleSpec *>(&turboModule)
-    ->installCoreFunctions(rt, std::move(args[0]));
+      ->installCoreFunctions(rt, std::move(args[0]));
   return jsi::Value::undefined();
 }
 
@@ -20,7 +21,7 @@ static jsi::Value __hostFunction_NativeReanimatedModuleSpec_makeShareable(
     const jsi::Value *args,
     size_t count) {
   return static_cast<NativeReanimatedModuleSpec *>(&turboModule)
-    ->makeShareable(rt, std::move(args[0]));
+      ->makeShareable(rt, std::move(args[0]));
 }
 
 static jsi::Value __hostFunction_NativeReanimatedModuleSpec_makeMutable(
@@ -29,7 +30,7 @@ static jsi::Value __hostFunction_NativeReanimatedModuleSpec_makeMutable(
     const jsi::Value *args,
     size_t count) {
   return static_cast<NativeReanimatedModuleSpec *>(&turboModule)
-    ->makeMutable(rt, std::move(args[0]));
+      ->makeMutable(rt, std::move(args[0]));
 }
 
 static jsi::Value __hostFunction_NativeReanimatedModuleSpec_makeRemote(
@@ -38,7 +39,7 @@ static jsi::Value __hostFunction_NativeReanimatedModuleSpec_makeRemote(
     const jsi::Value *args,
     size_t count) {
   return static_cast<NativeReanimatedModuleSpec *>(&turboModule)
-    ->makeRemote(rt, std::move(args[0]));
+      ->makeRemote(rt, std::move(args[0]));
 }
 
 static jsi::Value __hostFunction_NativeReanimatedModuleSpec_startMapper(
@@ -47,12 +48,13 @@ static jsi::Value __hostFunction_NativeReanimatedModuleSpec_startMapper(
     const jsi::Value *args,
     size_t count) {
   return static_cast<NativeReanimatedModuleSpec *>(&turboModule)
-      ->startMapper(rt,
-                    std::move(args[0]),
-                    std::move(args[1]),
-                    std::move(args[2]),
-                    std::move(args[3]),
-                    std::move(args[4]));
+      ->startMapper(
+          rt,
+          std::move(args[0]),
+          std::move(args[1]),
+          std::move(args[2]),
+          std::move(args[3]),
+          std::move(args[4]));
 }
 
 static jsi::Value __hostFunction_NativeReanimatedModuleSpec_stopMapper(
@@ -65,7 +67,8 @@ static jsi::Value __hostFunction_NativeReanimatedModuleSpec_stopMapper(
   return jsi::Value::undefined();
 }
 
-static jsi::Value __hostFunction_NativeReanimatedModuleSpec_registerEventHandler(
+static jsi::Value
+__hostFunction_NativeReanimatedModuleSpec_registerEventHandler(
     jsi::Runtime &rt,
     TurboModule &turboModule,
     const jsi::Value *args,
@@ -74,7 +77,8 @@ static jsi::Value __hostFunction_NativeReanimatedModuleSpec_registerEventHandler
       ->registerEventHandler(rt, std::move(args[0]), std::move(args[1]));
 }
 
-static jsi::Value __hostFunction_NativeReanimatedModuleSpec_unregisterEventHandler(
+static jsi::Value
+__hostFunction_NativeReanimatedModuleSpec_unregisterEventHandler(
     jsi::Runtime &rt,
     TurboModule &turboModule,
     const jsi::Value *args,
@@ -90,37 +94,49 @@ static jsi::Value __hostFunction_NativeReanimatedModuleSpec_getViewProp(
     const jsi::Value *args,
     size_t count) {
   static_cast<NativeReanimatedModuleSpec *>(&turboModule)
-        ->getViewProp(rt, std::move(args[0]), std::move(args[1]), std::move(args[2]));
-    return jsi::Value::undefined();
+      ->getViewProp(
+          rt, std::move(args[0]), std::move(args[1]), std::move(args[2]));
+  return jsi::Value::undefined();
+}
+
+static jsi::Value
+__hostFunction_NativeReanimatedModuleSpec_enableLayoutAnimations(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t count) {
+  static_cast<NativeReanimatedModuleSpec *>(&turboModule)
+      ->enableLayoutAnimations(rt, std::move(args[0]));
+  return jsi::Value::undefined();
 }
 
-NativeReanimatedModuleSpec::NativeReanimatedModuleSpec(std::shared_ptr<CallInvoker> jsInvoker)
+NativeReanimatedModuleSpec::NativeReanimatedModuleSpec(
+    std::shared_ptr<CallInvoker> jsInvoker)
     : TurboModule("NativeReanimated", jsInvoker) {
   methodMap_["installCoreFunctions"] = MethodMetadata{
-    1, __hostFunction_NativeReanimatedModuleSpec_installCoreFunctions};
-
+      1, __hostFunction_NativeReanimatedModuleSpec_installCoreFunctions};
 
   methodMap_["makeShareable"] = MethodMetadata{
       1, __hostFunction_NativeReanimatedModuleSpec_makeShareable};
-  methodMap_["makeMutable"] = MethodMetadata{
-      1, __hostFunction_NativeReanimatedModuleSpec_makeMutable};
-  methodMap_["makeRemote"] = MethodMetadata{
-      1, __hostFunction_NativeReanimatedModuleSpec_makeRemote};
-      
+  methodMap_["makeMutable"] =
+      MethodMetadata{1, __hostFunction_NativeReanimatedModuleSpec_makeMutable};
+  methodMap_["makeRemote"] =
+      MethodMetadata{1, __hostFunction_NativeReanimatedModuleSpec_makeRemote};
 
-  methodMap_["startMapper"] = MethodMetadata{
-    5, __hostFunction_NativeReanimatedModuleSpec_startMapper};
-  methodMap_["stopMapper"] = MethodMetadata{
-    1, __hostFunction_NativeReanimatedModuleSpec_stopMapper};
+  methodMap_["startMapper"] =
+      MethodMetadata{5, __hostFunction_NativeReanimatedModuleSpec_startMapper};
+  methodMap_["stopMapper"] =
+      MethodMetadata{1, __hostFunction_NativeReanimatedModuleSpec_stopMapper};
 
   methodMap_["registerEventHandler"] = MethodMetadata{
-    2, __hostFunction_NativeReanimatedModuleSpec_registerEventHandler};
+      2, __hostFunction_NativeReanimatedModuleSpec_registerEventHandler};
   methodMap_["unregisterEventHandler"] = MethodMetadata{
-    1, __hostFunction_NativeReanimatedModuleSpec_unregisterEventHandler};
-
-  methodMap_["getViewProp"] = MethodMetadata{
-    3, __hostFunction_NativeReanimatedModuleSpec_getViewProp};
-}
+      1, __hostFunction_NativeReanimatedModuleSpec_unregisterEventHandler};
 
+  methodMap_["getViewProp"] =
+      MethodMetadata{3, __hostFunction_NativeReanimatedModuleSpec_getViewProp};
+  methodMap_["enableLayoutAnimations"] = MethodMetadata{
+      2, __hostFunction_NativeReanimatedModuleSpec_enableLayoutAnimations};
 }
 
+} // namespace reanimated