@react-native-ohos/react-native-reanimated 3.18.1-rc.6 → 4.0.0-rc.1

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.h

@@ -1,29 +1,39 @@
 #pragma once
 
 #include <reanimated/AnimatedSensor/AnimatedSensorModule.h>
+#include <reanimated/CSS/core/CSSAnimation.h>
+#include <reanimated/CSS/core/CSSTransition.h>
+#include <reanimated/CSS/misc/ViewStylesRepository.h>
+#include <reanimated/CSS/registries/CSSAnimationsRegistry.h>
+#include <reanimated/CSS/registries/CSSKeyframesRegistry.h>
+#include <reanimated/CSS/registries/CSSTransitionsRegistry.h>
+#include <reanimated/CSS/registries/StaticPropsRegistry.h>
+#include <reanimated/Fabric/ReanimatedCommitHook.h>
+#include <reanimated/Fabric/ReanimatedCommitShadowNode.h>
+#include <reanimated/Fabric/ReanimatedMountHook.h>
+#include <reanimated/Fabric/ShadowTreeCloner.h>
+#include <reanimated/Fabric/updates/AnimatedPropsRegistry.h>
+#include <reanimated/Fabric/updates/UpdatesRegistryManager.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationsManager.h>
+#include <reanimated/LayoutAnimations/LayoutAnimationsProxyCommon.h>
+#include <reanimated/NativeModules/PropValueProcessor.h>
 #include <reanimated/NativeModules/ReanimatedModuleProxySpec.h>
 #include <reanimated/Tools/PlatformDepMethodsHolder.h>
 
-#ifdef RCT_NEW_ARCH_ENABLED
-#include <reanimated/Fabric/PropsRegistry.h>
-#include <reanimated/Fabric/ReanimatedCommitHook.h>
-#include <reanimated/Fabric/ReanimatedMountHook.h>
-#include <reanimated/LayoutAnimations/LayoutAnimationsProxy.h>
-#endif // RCT_NEW_ARCH_ENABLED
-
 #include <worklets/NativeModules/WorkletsModuleProxy.h>
 #include <worklets/Registries/EventHandlerRegistry.h>
 #include <worklets/Tools/JSScheduler.h>
 #include <worklets/Tools/SingleInstanceChecker.h>
 #include <worklets/Tools/UIScheduler.h>
 
-#ifdef RCT_NEW_ARCH_ENABLED
+#include <react/renderer/componentregistry/componentNameByReactViewName.h>
+#include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/uimanager/UIManager.h>
-#endif // RCT_NEW_ARCH_ENABLED
 
 #include <memory>
+#include <set>
 #include <string>
+#include <unordered_map>
 #include <unordered_set>
 #include <utility>
 #include <vector>
@@ -31,17 +41,18 @@
 namespace reanimated {
 
 using namespace facebook;
+using namespace css;
+
+using UpdatesBatch = std::vector<std::pair<std::shared_ptr<const ShadowNode>, folly::dynamic>>;
 
-class ReanimatedModuleProxy
-    : public ReanimatedModuleProxySpec,
-      public std::enable_shared_from_this<ReanimatedModuleProxy> {
+class ReanimatedModuleProxy : public ReanimatedModuleProxySpec,
+                              public std::enable_shared_from_this<ReanimatedModuleProxy> {
  public:
   ReanimatedModuleProxy(
       const std::shared_ptr<WorkletsModuleProxy> &workletsModuleProxy,
       jsi::Runtime &rnRuntime,
       const std::shared_ptr<CallInvoker> &jsCallInvoker,
       const PlatformDepMethodsHolder &platformDepMethodsHolder,
-      const bool isBridgeless,
       const bool isReducedMotion);
 
   // We need this init method to initialize callbacks with
@@ -49,86 +60,71 @@ class ReanimatedModuleProxy
   // is fully constructed.
   void init(const PlatformDepMethodsHolder &platformDepMethodsHolder);
 
-  void scheduleOnUI(jsi::Runtime &rt, const jsi::Value &worklet) override;
-  jsi::Value executeOnUIRuntimeSync(jsi::Runtime &rt, const jsi::Value &worklet)
-      override;
-
-  jsi::Value createWorkletRuntime(
-      jsi::Runtime &rt,
-      const jsi::Value &name,
-      const jsi::Value &initializer) override;
-  jsi::Value scheduleOnRuntime(
-      jsi::Runtime &rt,
-      const jsi::Value &workletRuntimeValue,
-      const jsi::Value &shareableWorkletValue) override;
-
-  ~ReanimatedModuleProxy();
+  ~ReanimatedModuleProxy() override;
 
   jsi::Value registerEventHandler(
       jsi::Runtime &rt,
       const jsi::Value &worklet,
       const jsi::Value &eventName,
       const jsi::Value &emitterReactTag) override;
-  void unregisterEventHandler(
-      jsi::Runtime &rt,
-      const jsi::Value &registrationId) override;
+  void unregisterEventHandler(jsi::Runtime &rt, const jsi::Value &registrationId) override;
 
   jsi::Value getViewProp(
       jsi::Runtime &rt,
-#ifdef RCT_NEW_ARCH_ENABLED
       const jsi::Value &shadowNodeWrapper,
-#else
-      const jsi::Value &viewTag,
-#endif
       const jsi::Value &propName,
       const jsi::Value &callback) override;
 
-  jsi::Value enableLayoutAnimations(jsi::Runtime &rt, const jsi::Value &config)
-      override;
-  jsi::Value configureProps(
-      jsi::Runtime &rt,
-      const jsi::Value &uiProps,
-      const jsi::Value &nativeProps) override;
-  jsi::Value configureLayoutAnimationBatch(
-      jsi::Runtime &rt,
-      const jsi::Value &layoutAnimationsBatch) override;
-  void setShouldAnimateExiting(
-      jsi::Runtime &rt,
-      const jsi::Value &viewTag,
-      const jsi::Value &shouldAnimate) override;
+  jsi::Value getStaticFeatureFlag(jsi::Runtime &rt, const jsi::Value &name) override;
+  jsi::Value setDynamicFeatureFlag(jsi::Runtime &rt, const jsi::Value &name, const jsi::Value &value) override;
+
+  jsi::Value configureLayoutAnimationBatch(jsi::Runtime &rt, const jsi::Value &layoutAnimationsBatch) override;
+  void setShouldAnimateExiting(jsi::Runtime &rt, const jsi::Value &viewTag, const jsi::Value &shouldAnimate) override;
 
   void onRender(double timestampMs);
 
-  bool isAnyHandlerWaitingForEvent(
-      const std::string &eventName,
-      const int emitterReactTag);
+  bool isAnyHandlerWaitingForEvent(const std::string &eventName, const int emitterReactTag);
 
   void maybeRequestRender();
 
-  bool handleEvent(
-      const std::string &eventName,
-      const int emitterReactTag,
-      const jsi::Value &payload,
-      double currentTime);
+  bool
+  handleEvent(const std::string &eventName, const int emitterReactTag, const jsi::Value &payload, double currentTime);
 
   inline std::shared_ptr<JSLogger> getJSLogger() const {
     return jsLogger_;
   }
 
-#ifdef RCT_NEW_ARCH_ENABLED
   bool handleRawEvent(const RawEvent &rawEvent, double currentTime);
 
-  void updateProps(jsi::Runtime &rt, const jsi::Value &operations);
+  void maybeRunCSSLoop();
+  double getCssTimestamp();
+
+  void performOperations(const bool isTriggeredByEvent);
 
-  void removeFromPropsRegistry(jsi::Runtime &rt, const jsi::Value &viewTags);
+  void setViewStyle(jsi::Runtime &rt, const jsi::Value &viewTag, const jsi::Value &viewStyle) override;
 
-  void performOperations();
+  void markNodeAsRemovable(jsi::Runtime &rt, const jsi::Value &shadowNodeWrapper) override;
+  void unmarkNodeAsRemovable(jsi::Runtime &rt, const jsi::Value &viewTag) override;
 
-  void markNodeAsRemovable(
+  void registerCSSKeyframes(
       jsi::Runtime &rt,
-      const jsi::Value &shadowNodeWrapper) override;
-  void unmarkNodeAsRemovable(jsi::Runtime &rt, const jsi::Value &viewTag)
+      const jsi::Value &animationName,
+      const jsi::Value &viewName,
+      const jsi::Value &keyframesConfig) override;
+  void unregisterCSSKeyframes(jsi::Runtime &rt, const jsi::Value &animationName, const jsi::Value &viewName) override;
+
+  void applyCSSAnimations(jsi::Runtime &rt, const jsi::Value &shadowNodeWrapper, const jsi::Value &animationUpdates)
+      override;
+  void unregisterCSSAnimations(const jsi::Value &viewTag) override;
+
+  void registerCSSTransition(jsi::Runtime &rt, const jsi::Value &shadowNodeWrapper, const jsi::Value &transitionConfig)
       override;
+  void updateCSSTransition(jsi::Runtime &rt, const jsi::Value &viewTag, const jsi::Value &configUpdates) override;
+  void unregisterCSSTransition(jsi::Runtime &rt, const jsi::Value &viewTag) override;
+
+  jsi::Value getSettledUpdates(jsi::Runtime &rt) override;
+
+  void cssLoopCallback(const double /*timestampMs*/);
 
   void dispatchCommand(
       jsi::Runtime &rt,
@@ -136,10 +132,7 @@ class ReanimatedModuleProxy
       const jsi::Value &commandNameValue,
       const jsi::Value &argsValue);
 
-  jsi::String obtainProp(
-      jsi::Runtime &rt,
-      const jsi::Value &shadowNodeWrapper,
-      const jsi::Value &propName);
+  jsi::String obtainProp(jsi::Runtime &rt, const jsi::Value &shadowNodeWrapper, const jsi::Value &propName);
 
   jsi::Value measure(jsi::Runtime &rt, const jsi::Value &shadowNodeValue);
 
@@ -150,12 +143,7 @@ class ReanimatedModuleProxy
   std::string obtainPropFromShadowNode(
       jsi::Runtime &rt,
       const std::string &propName,
-      const ShadowNode::Shared &shadowNode);
-
-#ifdef IS_REANIMATED_EXAMPLE_APP
-  std::function<std::string()> createRegistriesLeakCheck();
-#endif // IS_REANIMATED_EXAMPLE_APP
-#endif
+      const std::shared_ptr<const ShadowNode> &shadowNode);
 
   jsi::Value registerSensor(
       jsi::Runtime &rt,
@@ -172,74 +160,62 @@ class ReanimatedModuleProxy
       const jsi::Value &keyboardEventContainer,
       const jsi::Value &isStatusBarTranslucent,
       const jsi::Value &isNavigationBarTranslucent) override;
-  void unsubscribeFromKeyboardEvents(
-      jsi::Runtime &rt,
-      const jsi::Value &listenerId) override;
+  void unsubscribeFromKeyboardEvents(jsi::Runtime &rt, const jsi::Value &listenerId) override;
 
   inline LayoutAnimationsManager &layoutAnimationsManager() {
     return *layoutAnimationsManager_;
   }
 
-  [[nodiscard]] inline jsi::Runtime &getUIRuntime() const {
-    return uiWorkletRuntime_->getJSIRuntime();
-  }
-
-  [[nodiscard]] inline bool isBridgeless() const {
-    return isBridgeless_;
-  }
-
   [[nodiscard]] inline bool isReducedMotion() const {
     return isReducedMotion_;
   }
 
-  [[nodiscard]] inline std::shared_ptr<WorkletsModuleProxy>
-  getWorkletsModuleProxy() const {
+  [[nodiscard]] inline std::shared_ptr<WorkletsModuleProxy> getWorkletsModuleProxy() const {
     return workletsModuleProxy_;
   }
 
- private:
-  void requestAnimationFrame(jsi::Runtime &rt, const jsi::Value &callback);
+  void requestFlushRegistry();
+  std::function<std::string()> createRegistriesLeakCheck();
 
-#ifdef RCT_NEW_ARCH_ENABLED
-  jsi::Value filterNonAnimatableProps(
-      jsi::Runtime &rt,
-      const jsi::Value &props);
-#endif // RCT_NEW_ARCH_ENABLED
+ private:
+  void commitUpdates(jsi::Runtime &rt, const UpdatesBatch &updatesBatch);
 
-  const bool isBridgeless_;
   const bool isReducedMotion_;
+  bool shouldFlushRegistry_ = false;
   std::shared_ptr<WorkletsModuleProxy> workletsModuleProxy_;
-  const std::string valueUnpackerCode_;
-  std::shared_ptr<WorkletRuntime> uiWorkletRuntime_;
 
   std::unique_ptr<EventHandlerRegistry> eventHandlerRegistry_;
   const RequestRenderFunction requestRender_;
-  std::vector<std::shared_ptr<jsi::Value>> frameCallbacks_;
   volatile bool renderRequested_{false};
   std::function<void(const double)> onRenderCallback_;
   AnimatedSensorModule animatedSensorModule_;
   const std::shared_ptr<JSLogger> jsLogger_;
   std::shared_ptr<LayoutAnimationsManager> layoutAnimationsManager_;
+  GetAnimationTimestampFunction getAnimationTimestamp_;
+#ifdef __APPLE__
+  ForceScreenSnapshotFunction forceScreenSnapshot_;
+#endif
+  bool cssLoopRunning_{false};
+  bool shouldUpdateCssAnimations_{true};
+  double currentCssTimestamp_{0};
 
-#ifdef RCT_NEW_ARCH_ENABLED
-  std::unordered_set<std::string>
-      animatablePropNames_; // filled by configureProps
-  std::shared_ptr<UIManager> uiManager_;
-  std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy_;
+  const std::shared_ptr<AnimatedPropsRegistry> animatedPropsRegistry_;
+  const std::shared_ptr<StaticPropsRegistry> staticPropsRegistry_;
+  const std::shared_ptr<UpdatesRegistryManager> updatesRegistryManager_;
+  const std::shared_ptr<ViewStylesRepository> viewStylesRepository_;
+  const std::shared_ptr<CSSKeyframesRegistry> cssAnimationKeyframesRegistry_;
+  const std::shared_ptr<CSSAnimationsRegistry> cssAnimationsRegistry_;
+  const std::shared_ptr<CSSTransitionsRegistry> cssTransitionsRegistry_;
 
-  std::vector<std::pair<ShadowNode::Shared, std::unique_ptr<jsi::Value>>>
-      operationsInBatch_; // TODO: refactor std::pair to custom struct
+  const SynchronouslyUpdateUIPropsFunction synchronouslyUpdateUIPropsFunction_;
+  const PreserveMountedTagsFunction filterUnmountedTagsFunction_;
 
-  std::shared_ptr<PropsRegistry> propsRegistry_;
+  std::shared_ptr<UIManager> uiManager_;
+  std::shared_ptr<LayoutAnimationsProxyCommon> layoutAnimationsProxy_;
   std::shared_ptr<ReanimatedCommitHook> commitHook_;
   std::shared_ptr<ReanimatedMountHook> mountHook_;
-
-  std::vector<Tag> tagsToRemove_; // from `propsRegistry_`
-#else
-  const ObtainPropFunction obtainPropFunction_;
-  const ConfigurePropsFunction configurePropsPlatformFunction_;
-  const UpdatePropsFunction updatePropsFunction_;
-#endif
+  std::set<SurfaceId> layoutAnimationFlushRequests_;
+  bool layoutAnimationRenderRequested_;
 
   const KeyboardEventSubscribeFunction subscribeForKeyboardEventsFunction_;
   const KeyboardEventUnsubscribeFunction unsubscribeFromKeyboardEventsFunction_;

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxySpec.cpp

@@ -1,231 +1,183 @@
 #include <reanimated/NativeModules/ReanimatedModuleProxySpec.h>
 
+#include <memory>
 #include <utility>
 
-#define REANIMATED_SPEC_PREFIX(FN_NAME) \
-  __hostFunction_ReanimatedModuleProxySpec_##FN_NAME
+#define REANIMATED_SPEC_PREFIX(FN_NAME) __hostFunction_ReanimatedModuleProxySpec_##FN_NAME
 
 namespace reanimated {
 
-// scheduler
+static jsi::Value REANIMATED_SPEC_PREFIX(
+    registerEventHandler)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t) {
+  return static_cast<ReanimatedModuleProxySpec *>(&turboModule)
+      ->registerEventHandler(rt, std::move(args[0]), std::move(args[1]), std::move(args[2]));
+}
 
-static jsi::Value REANIMATED_SPEC_PREFIX(scheduleOnUI)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  static_cast<ReanimatedModuleProxySpec *>(&turboModule)
-      ->scheduleOnUI(rt, std::move(args[0]));
+static jsi::Value REANIMATED_SPEC_PREFIX(
+    unregisterEventHandler)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t) {
+  static_cast<ReanimatedModuleProxySpec *>(&turboModule)->unregisterEventHandler(rt, std::move(args[0]));
   return jsi::Value::undefined();
 }
 
-static jsi::Value REANIMATED_SPEC_PREFIX(executeOnUIRuntimeSync)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  return static_cast<ReanimatedModuleProxySpec *>(&turboModule)
-      ->executeOnUIRuntimeSync(rt, std::move(args[0]));
+static jsi::Value REANIMATED_SPEC_PREFIX(
+    getViewProp)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t) {
+  static_cast<ReanimatedModuleProxySpec *>(&turboModule)
+      ->getViewProp(rt, std::move(args[0]), std::move(args[1]), std::move(args[2]));
+  return jsi::Value::undefined();
 }
 
-static jsi::Value REANIMATED_SPEC_PREFIX(createWorkletRuntime)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
+static jsi::Value REANIMATED_SPEC_PREFIX(
+    registerSensor)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t) {
   return static_cast<ReanimatedModuleProxySpec *>(&turboModule)
-      ->createWorkletRuntime(rt, std::move(args[0]), std::move(args[1]));
+      ->registerSensor(rt, std::move(args[0]), std::move(args[1]), std::move(args[2]), std::move(args[3]));
 }
 
-static jsi::Value REANIMATED_SPEC_PREFIX(scheduleOnRuntime)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  return static_cast<ReanimatedModuleProxySpec *>(&turboModule)
-      ->scheduleOnRuntime(rt, std::move(args[0]), std::move(args[1]));
+static jsi::Value REANIMATED_SPEC_PREFIX(
+    unregisterSensor)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t) {
+  static_cast<ReanimatedModuleProxySpec *>(&turboModule)->unregisterSensor(rt, std::move(args[0]));
+  return jsi::Value::undefined();
 }
 
-static jsi::Value REANIMATED_SPEC_PREFIX(registerEventHandler)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  return static_cast<ReanimatedModuleProxySpec *>(&turboModule)
-      ->registerEventHandler(
-          rt, std::move(args[0]), std::move(args[1]), std::move(args[2]));
+static jsi::Value REANIMATED_SPEC_PREFIX(
+    getStaticFeatureFlag)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t) {
+  return static_cast<ReanimatedModuleProxySpec *>(&turboModule)->getStaticFeatureFlag(rt, std::move(args[0]));
 }
 
-static jsi::Value REANIMATED_SPEC_PREFIX(unregisterEventHandler)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
+static jsi::Value REANIMATED_SPEC_PREFIX(
+    setDynamicFeatureFlag)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t) {
   static_cast<ReanimatedModuleProxySpec *>(&turboModule)
-      ->unregisterEventHandler(rt, std::move(args[0]));
+      ->setDynamicFeatureFlag(rt, std::move(args[0]), std::move(args[1]));
   return jsi::Value::undefined();
 }
 
-static jsi::Value REANIMATED_SPEC_PREFIX(getViewProp)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  static_cast<ReanimatedModuleProxySpec *>(&turboModule)
-      ->getViewProp(
-          rt, std::move(args[0]), std::move(args[1]), std::move(args[2]));
+static jsi::Value REANIMATED_SPEC_PREFIX(
+    subscribeForKeyboardEvents)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t) {
+  return static_cast<ReanimatedModuleProxySpec *>(&turboModule)
+      ->subscribeForKeyboardEvents(rt, std::move(args[0]), std::move(args[1]), std::move(args[2]));
+}
+
+static jsi::Value REANIMATED_SPEC_PREFIX(
+    unsubscribeFromKeyboardEvents)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t) {
+  static_cast<ReanimatedModuleProxySpec *>(&turboModule)->unsubscribeFromKeyboardEvents(rt, std::move(args[0]));
   return jsi::Value::undefined();
 }
 
-static jsi::Value REANIMATED_SPEC_PREFIX(enableLayoutAnimations)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
+static jsi::Value REANIMATED_SPEC_PREFIX(
+    configureLayoutAnimationBatch)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t) {
+  return static_cast<ReanimatedModuleProxySpec *>(&turboModule)->configureLayoutAnimationBatch(rt, std::move(args[0]));
+}
+
+static jsi::Value REANIMATED_SPEC_PREFIX(
+    setShouldAnimateExiting)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t) {
   static_cast<ReanimatedModuleProxySpec *>(&turboModule)
-      ->enableLayoutAnimations(rt, std::move(args[0]));
+      ->setShouldAnimateExiting(rt, std::move(args[0]), std::move(args[1]));
   return jsi::Value::undefined();
 }
 
-static jsi::Value REANIMATED_SPEC_PREFIX(registerSensor)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  return static_cast<ReanimatedModuleProxySpec *>(&turboModule)
-      ->registerSensor(
-          rt,
-          std::move(args[0]),
-          std::move(args[1]),
-          std::move(args[2]),
-          std::move(args[3]));
-}
-
-static jsi::Value REANIMATED_SPEC_PREFIX(unregisterSensor)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  static_cast<ReanimatedModuleProxySpec *>(&turboModule)
-      ->unregisterSensor(rt, std::move(args[0]));
+static jsi::Value REANIMATED_SPEC_PREFIX(
+    setViewStyle)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t) {
+  static_cast<ReanimatedModuleProxySpec *>(&turboModule)->setViewStyle(rt, std::move(args[0]), std::move(args[1]));
   return jsi::Value::undefined();
 }
 
-static jsi::Value REANIMATED_SPEC_PREFIX(configureProps)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  static_cast<ReanimatedModuleProxySpec *>(&turboModule)
-      ->configureProps(rt, std::move(args[0]), std::move(args[1]));
+static jsi::Value REANIMATED_SPEC_PREFIX(
+    markNodeAsRemovable)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t) {
+  static_cast<ReanimatedModuleProxySpec *>(&turboModule)->markNodeAsRemovable(rt, std::move(args[0]));
   return jsi::Value::undefined();
 }
 
-static jsi::Value REANIMATED_SPEC_PREFIX(subscribeForKeyboardEvents)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  return static_cast<ReanimatedModuleProxySpec *>(&turboModule)
-      ->subscribeForKeyboardEvents(
-          rt, std::move(args[0]), std::move(args[1]), std::move(args[2]));
+static jsi::Value REANIMATED_SPEC_PREFIX(
+    unmarkNodeAsRemovable)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t) {
+  static_cast<ReanimatedModuleProxySpec *>(&turboModule)->unmarkNodeAsRemovable(rt, std::move(args[0]));
+  return jsi::Value::undefined();
 }
 
-static jsi::Value REANIMATED_SPEC_PREFIX(unsubscribeFromKeyboardEvents)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
+static jsi::Value REANIMATED_SPEC_PREFIX(
+    registerCSSKeyframes)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t) {
   static_cast<ReanimatedModuleProxySpec *>(&turboModule)
-      ->unsubscribeFromKeyboardEvents(rt, std::move(args[0]));
+      ->registerCSSKeyframes(rt, std::move(args[0]), std::move(args[1]), std::move(args[2]));
   return jsi::Value::undefined();
 }
 
-static jsi::Value REANIMATED_SPEC_PREFIX(configureLayoutAnimationBatch)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
-  return static_cast<ReanimatedModuleProxySpec *>(&turboModule)
-      ->configureLayoutAnimationBatch(rt, std::move(args[0]));
+static jsi::Value REANIMATED_SPEC_PREFIX(
+    unregisterCSSKeyframes)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t) {
+  static_cast<ReanimatedModuleProxySpec *>(&turboModule)
+      ->unregisterCSSKeyframes(rt, std::move(args[0]), std::move(args[1]));
+  return jsi::Value::undefined();
 }
 
-static jsi::Value REANIMATED_SPEC_PREFIX(setShouldAnimateExiting)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
+static jsi::Value REANIMATED_SPEC_PREFIX(
+    applyCSSAnimations)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t) {
   static_cast<ReanimatedModuleProxySpec *>(&turboModule)
-      ->setShouldAnimateExiting(rt, std::move(args[0]), std::move(args[1]));
+      ->applyCSSAnimations(rt, std::move(args[0]), std::move(args[1]));
   return jsi::Value::undefined();
 }
 
-#ifdef RCT_NEW_ARCH_ENABLED
+static jsi::Value REANIMATED_SPEC_PREFIX(
+    unregisterCSSAnimations)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t) {
+  static_cast<ReanimatedModuleProxySpec *>(&turboModule)->unregisterCSSAnimations(std::move(args[0]));
+  return jsi::Value::undefined();
+}
 
-static jsi::Value REANIMATED_SPEC_PREFIX(markNodeAsRemovable)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
+static jsi::Value REANIMATED_SPEC_PREFIX(
+    registerCSSTransition)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t) {
   static_cast<ReanimatedModuleProxySpec *>(&turboModule)
-      ->markNodeAsRemovable(rt, std::move(args[0]));
+      ->registerCSSTransition(rt, std::move(args[0]), std::move(args[1]));
   return jsi::Value::undefined();
 }
 
-static jsi::Value REANIMATED_SPEC_PREFIX(unmarkNodeAsRemovable)(
-    jsi::Runtime &rt,
-    TurboModule &turboModule,
-    const jsi::Value *args,
-    size_t) {
+static jsi::Value REANIMATED_SPEC_PREFIX(
+    updateCSSTransition)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t) {
   static_cast<ReanimatedModuleProxySpec *>(&turboModule)
-      ->unmarkNodeAsRemovable(rt, std::move(args[0]));
+      ->updateCSSTransition(rt, std::move(args[0]), std::move(args[1]));
+  return jsi::Value::undefined();
+}
+
+static jsi::Value REANIMATED_SPEC_PREFIX(
+    unregisterCSSTransition)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t) {
+  static_cast<ReanimatedModuleProxySpec *>(&turboModule)->unregisterCSSTransition(rt, std::move(args[0]));
   return jsi::Value::undefined();
 }
 
-#endif // RCT_NEW_ARCH_ENABLED
+static jsi::Value REANIMATED_SPEC_PREFIX(
+    getSettledUpdates)(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value *args, size_t) {
+  return static_cast<ReanimatedModuleProxySpec *>(&turboModule)->getSettledUpdates(rt);
+}
 
-ReanimatedModuleProxySpec::ReanimatedModuleProxySpec(
-    const std::shared_ptr<CallInvoker> &jsInvoker)
+ReanimatedModuleProxySpec::ReanimatedModuleProxySpec(const std::shared_ptr<CallInvoker> &jsInvoker)
     : TurboModule("NativeReanimated", jsInvoker) {
-  methodMap_["scheduleOnUI"] =
-      MethodMetadata{1, REANIMATED_SPEC_PREFIX(scheduleOnUI)};
-  methodMap_["executeOnUIRuntimeSync"] =
-      MethodMetadata{1, REANIMATED_SPEC_PREFIX(executeOnUIRuntimeSync)};
-  methodMap_["createWorkletRuntime"] =
-      MethodMetadata{2, REANIMATED_SPEC_PREFIX(createWorkletRuntime)};
-  methodMap_["scheduleOnRuntime"] =
-      MethodMetadata{2, REANIMATED_SPEC_PREFIX(scheduleOnRuntime)};
-
-  methodMap_["registerEventHandler"] =
-      MethodMetadata{3, REANIMATED_SPEC_PREFIX(registerEventHandler)};
-  methodMap_["unregisterEventHandler"] =
-      MethodMetadata{1, REANIMATED_SPEC_PREFIX(unregisterEventHandler)};
-
-  methodMap_["getViewProp"] =
-      MethodMetadata{3, REANIMATED_SPEC_PREFIX(getViewProp)};
-  methodMap_["enableLayoutAnimations"] =
-      MethodMetadata{2, REANIMATED_SPEC_PREFIX(enableLayoutAnimations)};
-  methodMap_["registerSensor"] =
-      MethodMetadata{4, REANIMATED_SPEC_PREFIX(registerSensor)};
-  methodMap_["unregisterSensor"] =
-      MethodMetadata{1, REANIMATED_SPEC_PREFIX(unregisterSensor)};
-  methodMap_["configureProps"] =
-      MethodMetadata{2, REANIMATED_SPEC_PREFIX(configureProps)};
-  methodMap_["subscribeForKeyboardEvents"] =
-      MethodMetadata{2, REANIMATED_SPEC_PREFIX(subscribeForKeyboardEvents)};
+  methodMap_["registerEventHandler"] = MethodMetadata{3, REANIMATED_SPEC_PREFIX(registerEventHandler)};
+  methodMap_["unregisterEventHandler"] = MethodMetadata{1, REANIMATED_SPEC_PREFIX(unregisterEventHandler)};
+
+  methodMap_["getViewProp"] = MethodMetadata{3, REANIMATED_SPEC_PREFIX(getViewProp)};
+  methodMap_["registerSensor"] = MethodMetadata{4, REANIMATED_SPEC_PREFIX(registerSensor)};
+  methodMap_["getStaticFeatureFlag"] = MethodMetadata{1, REANIMATED_SPEC_PREFIX(getStaticFeatureFlag)};
+  methodMap_["unregisterSensor"] = MethodMetadata{1, REANIMATED_SPEC_PREFIX(unregisterSensor)};
+  methodMap_["setDynamicFeatureFlag"] = MethodMetadata{2, REANIMATED_SPEC_PREFIX(setDynamicFeatureFlag)};
+  methodMap_["subscribeForKeyboardEvents"] = MethodMetadata{2, REANIMATED_SPEC_PREFIX(subscribeForKeyboardEvents)};
   methodMap_["unsubscribeFromKeyboardEvents"] =
       MethodMetadata{1, REANIMATED_SPEC_PREFIX(unsubscribeFromKeyboardEvents)};
 
   methodMap_["configureLayoutAnimationBatch"] =
       MethodMetadata{1, REANIMATED_SPEC_PREFIX(configureLayoutAnimationBatch)};
-  methodMap_["setShouldAnimateExitingForTag"] =
-      MethodMetadata{2, REANIMATED_SPEC_PREFIX(setShouldAnimateExiting)};
+  methodMap_["setShouldAnimateExitingForTag"] = MethodMetadata{2, REANIMATED_SPEC_PREFIX(setShouldAnimateExiting)};
+
+  methodMap_["setViewStyle"] = MethodMetadata{2, REANIMATED_SPEC_PREFIX(setViewStyle)};
+
+  methodMap_["markNodeAsRemovable"] = MethodMetadata{1, REANIMATED_SPEC_PREFIX(markNodeAsRemovable)};
+  methodMap_["unmarkNodeAsRemovable"] = MethodMetadata{1, REANIMATED_SPEC_PREFIX(unmarkNodeAsRemovable)};
 
-#ifdef RCT_NEW_ARCH_ENABLED
-  methodMap_["markNodeAsRemovable"] =
-      MethodMetadata{1, REANIMATED_SPEC_PREFIX(markNodeAsRemovable)};
-  methodMap_["unmarkNodeAsRemovable"] =
-      MethodMetadata{1, REANIMATED_SPEC_PREFIX(unmarkNodeAsRemovable)};
-#endif // RCT_NEW_ARCH_ENABLED
+  methodMap_["registerCSSKeyframes"] = MethodMetadata{3, REANIMATED_SPEC_PREFIX(registerCSSKeyframes)};
+  methodMap_["unregisterCSSKeyframes"] = MethodMetadata{2, REANIMATED_SPEC_PREFIX(unregisterCSSKeyframes)};
+
+  methodMap_["applyCSSAnimations"] = MethodMetadata{2, REANIMATED_SPEC_PREFIX(applyCSSAnimations)};
+  methodMap_["unregisterCSSAnimations"] = MethodMetadata{1, REANIMATED_SPEC_PREFIX(unregisterCSSAnimations)};
+
+  methodMap_["registerCSSTransition"] = MethodMetadata{2, REANIMATED_SPEC_PREFIX(registerCSSTransition)};
+  methodMap_["updateCSSTransition"] = MethodMetadata{2, REANIMATED_SPEC_PREFIX(updateCSSTransition)};
+  methodMap_["unregisterCSSTransition"] = MethodMetadata{1, REANIMATED_SPEC_PREFIX(unregisterCSSTransition)};
+
+  methodMap_["getSettledUpdates"] = MethodMetadata{1, REANIMATED_SPEC_PREFIX(getSettledUpdates)};
 }
+
 } // namespace reanimated