@react-native-ohos/react-native-reanimated 4.0.2-beta.1 → 4.1.0-beta.1

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ShadowTreeCloner.cpp

@@ -7,10 +7,11 @@
 
 namespace reanimated {
 
-Props::Shared mergeProps(const ShadowNode &shadowNode, const PropsMap &propsMap, const ShadowNodeFamily &family) {
+Props::Shared
+mergeProps(const ShadowNode &shadowNode, const PropsMap &propsMap, const ShadowNodeFamily::Shared &family) {
   ReanimatedSystraceSection s("ShadowTreeCloner::mergeProps");
 
-  const auto it = propsMap.find(&family);
+  const auto it = propsMap.find(family);
 
   if (it == propsMap.end()) {
     return ShadowNodeFragment::propsPlaceholder();
@@ -41,7 +42,7 @@ std::shared_ptr<ShadowNode> cloneShadowTreeWithNewPropsRecursive(
     const ShadowNode &shadowNode,
     const ChildrenMap &childrenMap,
     const PropsMap &propsMap) {
-  const auto family = &shadowNode.getFamily();
+  const auto family = shadowNode.getFamilyShared();
   const auto affectedChildrenIt = childrenMap.find(family);
   auto children = shadowNode.getChildren();
 
@@ -52,7 +53,7 @@ std::shared_ptr<ShadowNode> cloneShadowTreeWithNewPropsRecursive(
   }
 
   return shadowNode.clone(
-      {mergeProps(shadowNode, propsMap, *family),
+      {mergeProps(shadowNode, propsMap, family),
        std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>(children),
        shadowNode.getState(),
        false});
@@ -66,32 +67,19 @@ RootShadowNode::Unshared cloneShadowTreeWithNewProps(const RootShadowNode &oldRo
   {
     ReanimatedSystraceSection s("ShadowTreeCloner::prepareChildrenMap");
 
-    for (auto &[family, _] : propsMap) {
+    for (const auto &[family, _] : propsMap) {
       const auto ancestors = family->getAncestors(oldRootNode);
 
-//      for (const auto &[parentNode, index] : std::ranges::reverse_view(ancestors)) {
-//        const auto parentFamily = &parentNode.get().getFamily();
-//        auto &affectedChildren = childrenMap[parentFamily];
-//
-//        if (affectedChildren.contains(index)) {
-//          continue;
-//        }
-//
-//        affectedChildren.insert(index);
-//      }
-       //TODO     
-       for (auto it = ancestors.rbegin(); it != ancestors.rend(); ++it) {
-          const auto &[parentNode, index] = *it;
-          
-          const auto parentFamily = &parentNode.get().getFamily();
-          auto &affectedChildren = childrenMap[parentFamily];
-        
-          if (affectedChildren.find(index) != affectedChildren.end()) {
-            continue;
-          }
-        
-          affectedChildren.insert(index);
-       }          
+      for (const auto &[parentNode, index] : std::ranges::reverse_view(ancestors)) {
+        const auto parentFamily = parentNode.get().getFamilyShared();
+        auto &affectedChildren = childrenMap[parentFamily];
+
+        if (affectedChildren.contains(index)) {
+          continue;
+        }
+
+        affectedChildren.insert(index);
+      }
     }
   }
 

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/ShadowTreeCloner.h

@@ -1,10 +1,9 @@
 #pragma once
 
 #include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/ShadowNodeFamily.h>
 #include <react/renderer/uimanager/UIManager.h>
 
-#include <memory>
-#include <type_traits>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
@@ -14,8 +13,8 @@ using namespace react;
 
 namespace reanimated {
 
-using PropsMap = std::unordered_map<const ShadowNodeFamily *, std::vector<RawProps>>;
-using ChildrenMap = std::unordered_map<const ShadowNodeFamily *, std::unordered_set<int>>;
+using PropsMap = std::unordered_map<ShadowNodeFamily::Shared, std::vector<RawProps>>;
+using ChildrenMap = std::unordered_map<ShadowNodeFamily::Shared, std::unordered_set<int>>;
 
 RootShadowNode::Unshared cloneShadowTreeWithNewProps(const RootShadowNode &oldRootNode, const PropsMap &propsMap);
 

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/updates/AnimatedPropsRegistry.cpp

@@ -1,20 +1,25 @@
+#include <cxxreact/ReactNativeVersion.h>
 #include <reanimated/Fabric/updates/AnimatedPropsRegistry.h>
+#include <reanimated/Fabric/updates/UpdatesRegistryManager.h>
 #include <reanimated/Tools/FeatureFlags.h>
 
+#include <react/debug/react_native_assert.h>
+
+#include <functional>
 #include <memory>
 #include <utility>
+#include <vector>
 
 namespace reanimated {
 
-#if REACT_NATIVE_MINOR_VERSION >= 81
 static inline std::shared_ptr<const ShadowNode> shadowNodeFromValue(
     jsi::Runtime &rt,
     const jsi::Value &shadowNodeWrapper) {
   return Bridging<std::shared_ptr<const ShadowNode>>::fromJs(rt, shadowNodeWrapper);
 }
-#endif
 
 void AnimatedPropsRegistry::update(jsi::Runtime &rt, const jsi::Value &operations, const double timestamp) {
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
   auto operationsArray = operations.asObject(rt).asArray(rt);
 
   for (size_t i = 0, length = operationsArray.size(rt); i < length; ++i) {
@@ -22,26 +27,75 @@ void AnimatedPropsRegistry::update(jsi::Runtime &rt, const jsi::Value &operation
     auto shadowNodeWrapper = item.getProperty(rt, "shadowNodeWrapper");
     auto shadowNode = shadowNodeFromValue(rt, shadowNodeWrapper);
 
-    const jsi::Value &updates = item.getProperty(rt, "updates");
-    addUpdatesToBatch(shadowNode, jsi::dynamicFromValue(rt, updates));
+    jsi::Value updates = item.getProperty(rt, "updates");
 
-    if constexpr (StaticFeatureFlags::getFlag("FORCE_REACT_RENDER_FOR_SETTLED_ANIMATIONS")) {
-      timestampMap_[shadowNode->getTag()] = timestamp;
+    if constexpr (StaticFeatureFlags::getFlag("USE_ANIMATION_BACKEND")) {
+#if REACT_NATIVE_VERSION_MINOR >= 85
+      addJSIPropsToAnimatedPropsBatch(shadowNode->getFamilyShared(), rt, updates);
+#endif
+    } else {
+      addUpdatesToBatch(shadowNode->getFamilyShared(), jsi::dynamicFromValue(rt, updates));
+    }
+
+    // When USE_ANIMATION_BACKEND is enabled, updates bypass `updatesRegistry_`,
+    // so entries added to `timestampMap_` would never be synced and thus never
+    // evicted, leaking until view unmount.
+    if constexpr (
+        StaticFeatureFlags::getFlag("FORCE_REACT_RENDER_FOR_SETTLED_ANIMATIONS") &&
+        !StaticFeatureFlags::getFlag("USE_ANIMATION_BACKEND")) {
+      const auto tag = shadowNode->getTag();
+      timestampMap_[tag] = timestamp;
+      // If JS already has a `settledProps` snapshot for this tag, it is now
+      // stale — schedule a refresh on the next `collectSettledUpdates`.
+      if (syncedTags_.erase(tag) > 0) {
+        invalidatedTags_.insert(tag);
+      }
     }
   }
 }
 
-void AnimatedPropsRegistry::remove(const Tag tag) {
-  updatesRegistry_.erase(tag);
-}
+jsi::Value AnimatedPropsRegistry::collectSettledUpdates(jsi::Runtime &rt, const double settledTimestamp) {
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
 
-jsi::Value AnimatedPropsRegistry::getUpdatesOlderThanTimestamp(jsi::Runtime &rt, const double timestamp) {
   std::vector<std::pair<Tag, std::reference_wrapper<const folly::dynamic>>> updates;
 
-  for (const auto &[viewTag, pair] : updatesRegistry_) {
-    if (timestampMap_.at(viewTag) < timestamp) {
-      updates.emplace_back(viewTag, std::cref(pair.second));
+  for (auto it = updatesRegistry_.begin(); it != updatesRegistry_.end();) {
+    const auto viewTag = it->first;
+
+    if (syncedTags_.contains(viewTag)) {
+      // React already has the latest value for this tag (synced on a previous
+      // call, so the `settledProps` state is committed by now) — the registry
+      // entry is redundant. `syncedTags_` is intentionally retained to detect
+      // re-animation staleness. Note that `syncedTags_` and `invalidatedTags_`
+      // are disjoint — `update()` moves tags from the former to the latter.
+      timestampMap_.erase(viewTag);
+      it = updatesRegistry_.erase(it);
+      continue;
+    }
+
+    const auto timestampIt = timestampMap_.find(viewTag);
+    if (timestampIt == timestampMap_.end()) {
+      ++it;
+      continue;
     }
+    const bool isSettled = timestampIt->second < settledTimestamp;
+    const auto invalidatedIt = invalidatedTags_.find(viewTag);
+    const bool isInvalidated = invalidatedIt != invalidatedTags_.end();
+    if (isSettled || isInvalidated) {
+      updates.emplace_back(viewTag, std::cref(it->second.second));
+      if (isSettled) {
+        // Only settled-path tags are tracked as "synced" so that an ongoing
+        // animation doesn't re-trigger an invalidation/sync on every GC tick.
+        syncedTags_.insert(viewTag);
+      }
+      if (isInvalidated) {
+        // Only erase serviced invalidations; if a tag was invalidated but the
+        // matching update batch hasn't been flushed into updatesRegistry_ yet,
+        // we leave the entry so the next sync picks it up.
+        invalidatedTags_.erase(invalidatedIt);
+      }
+    }
+    ++it;
   }
 
   const jsi::Array array(rt, updates.size());
@@ -56,17 +110,11 @@ jsi::Value AnimatedPropsRegistry::getUpdatesOlderThanTimestamp(jsi::Runtime &rt,
   return jsi::Value(rt, array);
 }
 
-void AnimatedPropsRegistry::removeUpdatesOlderThanTimestamp(const double timestamp) {
-  for (auto it = timestampMap_.begin(); it != timestampMap_.end();) {
-    const auto viewTag = it->first;
-    const auto viewTimestamp = it->second;
-    if (viewTimestamp < timestamp) {
-      it = timestampMap_.erase(it);
-      updatesRegistry_.erase(viewTag);
-    } else {
-      it++;
-    }
-  }
+void AnimatedPropsRegistry::removeTag(const Tag tag) {
+  updatesRegistry_.erase(tag);
+  timestampMap_.erase(tag);
+  syncedTags_.erase(tag);
+  invalidatedTags_.erase(tag);
 }
 
 } // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/updates/AnimatedPropsRegistry.h

@@ -4,22 +4,32 @@
 
 #include <react/renderer/uimanager/UIManager.h>
 
-#include <memory>
-#include <string>
 #include <unordered_map>
-#include <vector>
+#include <unordered_set>
 
 namespace reanimated {
 
 class AnimatedPropsRegistry : public UpdatesRegistry {
  public:
   void update(jsi::Runtime &rt, const jsi::Value &operations, double timestamp);
-  void remove(Tag tag) override;
-  jsi::Value getUpdatesOlderThanTimestamp(jsi::Runtime &rt, double timestamp);
-  void removeUpdatesOlderThanTimestamp(double timestamp);
+
+  /// Returns updates that settled (received no update since `settledTimestamp`)
+  /// or whose synced `settledProps` snapshot was invalidated by a fresh update.
+  /// Also evicts entries that have already been synced to React — by the time
+  /// of the next call, the corresponding `settledProps` state is guaranteed to
+  /// be committed, so the registry entries are redundant.
+  jsi::Value collectSettledUpdates(jsi::Runtime &rt, double settledTimestamp);
 
  private:
-  std::unordered_map<Tag, double> timestampMap_; // viewTag -> timestamp, protected by `mutex_`
+  std::unordered_map<Tag, double> timestampMap_;
+  // Tags whose latest values have already been pushed to React `settledProps`.
+  // Intentionally retained after eviction to detect re-animation staleness.
+  std::unordered_set<Tag> syncedTags_;
+  // Tags that were synced to React but received a fresh worklet update since;
+  // their `settledProps` are stale and need to be refreshed on the next sync.
+  std::unordered_set<Tag> invalidatedTags_;
+
+  void removeTag(Tag tag) override;
 };
 
 } // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/updates/OperationsLoop.cpp

@@ -0,0 +1,152 @@
+#include <reanimated/Fabric/updates/OperationsLoop.h>
+#include <reanimated/Fabric/updates/UpdatesRegistryManager.h>
+
+#include <utility>
+
+namespace reanimated {
+
+OperationsLoop::OperationsLoop(
+    const std::shared_ptr<worklets::UIScheduler> &uiScheduler,
+    const RequestRenderFunction &requestRender,
+    const GetAnimationTimestampFunction &getTimestamp,
+    const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager)
+    : uiScheduler_(uiScheduler),
+      requestRender_(requestRender),
+      getTimestamp_(getTimestamp),
+      updatesRegistryManager_(updatesRegistryManager) {}
+
+double OperationsLoop::resolveTimestamp() {
+  // Fast path: cache hit is lock-free.
+  if (const double cached = currentTimestamp_.load(std::memory_order_acquire); cached > 0) {
+    return cached;
+  }
+
+  // Slow path: try to win the cache fill. If someone else already filled it, use theirs.
+  const double fresh = getTimestamp_();
+  double expected = 0;
+  if (!currentTimestamp_.compare_exchange_strong(expected, fresh, std::memory_order_acq_rel)) {
+    return expected;
+  }
+
+  // We filled the cache - make sure a frame is scheduled to invalidate it.
+  maybeScheduleFrame();
+  return fresh;
+}
+
+bool OperationsLoop::hasOngoingOperations() const {
+  std::lock_guard<std::mutex> lock(queueMutex_);
+  return !scheduledOperations_.empty() || !activeOps_.empty() || !delayedOps_.empty();
+}
+
+void OperationsLoop::schedule(std::shared_ptr<LoopOperation> operation, double startTimestamp) {
+  enqueue({std::move(operation), startTimestamp});
+}
+
+void OperationsLoop::remove(const std::shared_ptr<LoopOperation> &operation) {
+  enqueue({operation, std::nullopt});
+}
+
+void OperationsLoop::update() {
+  auto [operations, timestamp] = beginFrame();
+  applyScheduledOperations(std::move(operations), timestamp);
+  activateDelayedOperations(timestamp);
+  updateActiveOperations(timestamp);
+  endFrame();
+}
+
+void OperationsLoop::enqueue(ScheduledOperation operation) {
+  {
+    std::lock_guard<std::mutex> lock(queueMutex_);
+    scheduledOperations_.emplace_back(std::move(operation));
+  }
+
+  maybeScheduleFrame();
+}
+
+void OperationsLoop::maybeScheduleFrame() {
+  // No-op if a frame is already scheduled - flips the flag and returns true if so.
+  if (frameRequested_.exchange(true, std::memory_order_acq_rel)) {
+    return;
+  }
+
+  worklets::scheduleOnUI(uiScheduler_, [weakThis = weak_from_this()]() {
+    auto strongThis = weakThis.lock();
+    if (!strongThis) {
+      return;
+    }
+    strongThis->requestRender_([weakThis](double /*frameTimestamp*/) {
+      if (auto strongThis = weakThis.lock()) {
+        strongThis->update();
+      }
+    });
+  });
+}
+
+std::pair<std::vector<OperationsLoop::ScheduledOperation>, double> OperationsLoop::beginFrame() {
+  const double freshTimestamp = getTimestamp_();
+
+  std::vector<ScheduledOperation> drained;
+  {
+    // Reset frameRequested_ together with the drain so an enqueue() can't slip a push
+    // in between (which would see the flag still true and skip scheduling).
+    std::lock_guard<std::mutex> lock(queueMutex_);
+    drained = std::exchange(scheduledOperations_, {});
+    frameRequested_.store(false, std::memory_order_release);
+  }
+
+  currentTimestamp_.store(freshTimestamp, std::memory_order_release);
+
+  return {std::move(drained), freshTimestamp};
+}
+
+void OperationsLoop::endFrame() {
+  // activeOps_ / delayedOps_ are touched only on the UI thread, so we can read them lock-free.
+  // We don't check the scheduledOperations_ queue: enqueue() schedules its own frame, so any
+  // pushes that arrived during update() have already requested a frame on their own.
+  const bool hasOngoingOperations = !activeOps_.empty() || !delayedOps_.empty();
+
+  currentTimestamp_.store(0, std::memory_order_release);
+
+  if (hasOngoingOperations) {
+    maybeScheduleFrame();
+  }
+}
+
+void OperationsLoop::applyScheduledOperations(std::vector<ScheduledOperation> operations, double timestamp) {
+  for (auto &op : operations) {
+    // Remove any prior scheduling for this operation.
+    activeOps_.erase(op.operation);
+    if (auto it = delayedLookup_.find(op.operation); it != delayedLookup_.end()) {
+      delayedOps_.erase(it->second);
+      delayedLookup_.erase(it);
+    }
+
+    if (!op.insertAt) {
+      continue;
+    }
+
+    const double insertAt = *op.insertAt;
+    if (insertAt <= timestamp) {
+      activeOps_.insert(std::move(op.operation));
+    } else {
+      auto it = delayedOps_.insert({insertAt, op.operation}).first;
+      delayedLookup_.emplace(std::move(op.operation), it);
+    }
+  }
+}
+
+void OperationsLoop::activateDelayedOperations(double timestamp) {
+  while (!delayedOps_.empty() && delayedOps_.begin()->activateAt <= timestamp) {
+    auto it = delayedOps_.begin();
+    delayedLookup_.erase(it->operation);
+    activeOps_.insert(it->operation);
+    delayedOps_.erase(it);
+  }
+}
+
+void OperationsLoop::updateActiveOperations(double timestamp) {
+  auto lock = updatesRegistryManager_->lock();
+  std::erase_if(activeOps_, [&](auto &op) { return !op->update(timestamp, *this); });
+}
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/updates/OperationsLoop.h

@@ -0,0 +1,86 @@
+#pragma once
+
+#include <reanimated/Tools/PlatformDepMethodsHolder.h>
+
+#include <worklets/Compat/StableApi.h>
+
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <set>
+#include <tuple>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+namespace reanimated {
+
+class UpdatesRegistryManager;
+
+class OperationsLoop : public std::enable_shared_from_this<OperationsLoop> {
+ public:
+  class LoopOperation {
+   public:
+    virtual ~LoopOperation() = default;
+    virtual bool update(double timestamp, OperationsLoop &loop) = 0;
+  };
+
+  OperationsLoop(
+      const std::shared_ptr<worklets::UIScheduler> &uiScheduler,
+      const RequestRenderFunction &requestRender,
+      const GetAnimationTimestampFunction &getTimestamp,
+      const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager);
+
+  double resolveTimestamp();
+
+  // True if anything is queued, active, or delayed in the loop.
+  bool hasOngoingOperations() const;
+
+  void schedule(std::shared_ptr<LoopOperation> operation, double startTimestamp);
+  void remove(const std::shared_ptr<LoopOperation> &operation);
+
+ private:
+  struct ScheduledOperation {
+    std::shared_ptr<LoopOperation> operation;
+    std::optional<double> insertAt; // nullopt means remove
+  };
+
+  struct DelayedEntry {
+    double activateAt;
+    std::shared_ptr<LoopOperation> operation;
+
+    bool operator<(const DelayedEntry &other) const {
+      return std::tie(activateAt, operation) < std::tie(other.activateAt, other.operation);
+    }
+  };
+
+  const std::shared_ptr<worklets::UIScheduler> uiScheduler_;
+  const RequestRenderFunction requestRender_;
+  const GetAnimationTimestampFunction getTimestamp_;
+  const std::shared_ptr<UpdatesRegistryManager> updatesRegistryManager_;
+
+  mutable std::mutex queueMutex_;
+  std::vector<ScheduledOperation> scheduledOperations_;
+
+  std::atomic<bool> frameRequested_{false};
+  std::atomic<double> currentTimestamp_{0};
+
+  std::unordered_set<std::shared_ptr<LoopOperation>> activeOps_;
+  std::set<DelayedEntry> delayedOps_;
+  std::unordered_map<std::shared_ptr<LoopOperation>, std::set<DelayedEntry>::iterator> delayedLookup_;
+
+  void update();
+  void enqueue(ScheduledOperation operation);
+
+  void maybeScheduleFrame();
+
+  std::pair<std::vector<ScheduledOperation>, double> beginFrame();
+  void endFrame();
+  void applyScheduledOperations(std::vector<ScheduledOperation> operations, double timestamp);
+  void activateDelayedOperations(double timestamp);
+  void updateActiveOperations(double timestamp);
+};
+
+} // namespace reanimated

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/updates/PropsLayoutFilter.h

@@ -0,0 +1,98 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <cxxreact/ReactNativeVersion.h>
+
+#if REACT_NATIVE_VERSION_MINOR >= 85
+#include <react/featureflags/ReactNativeFeatureFlags.h>
+#include <reanimated/Fabric/updates/propNameFromString.h>
+
+#include <react/renderer/animationbackend/AnimatedProps.h>
+
+#include <set>
+
+namespace reanimated {
+
+// On Android, non-layout props need to be packed into the rawProps unless props 2.0 are enabled.
+inline bool shouldFilterNonLayoutProps() {
+#ifdef ANDROID
+  return !facebook::react::ReactNativeFeatureFlags::enablePropsUpdateReconciliationAndroid();
+#else
+  return false;
+#endif
+}
+
+inline bool isLayoutProp(facebook::react::PropName propName) {
+  static const std::set<facebook::react::PropName> layoutPropNames = {
+      facebook::react::WIDTH,        facebook::react::HEIGHT,         facebook::react::FLEX,
+      facebook::react::MARGIN,       facebook::react::PADDING,        facebook::react::POSITION,
+      facebook::react::BORDER_WIDTH, facebook::react::ALIGN_CONTENT,  facebook::react::ALIGN_ITEMS,
+      facebook::react::ALIGN_SELF,   facebook::react::ASPECT_RATIO,   facebook::react::BOX_SIZING,
+      facebook::react::DISPLAY,      facebook::react::FLEX_BASIS,     facebook::react::FLEX_DIRECTION,
+      facebook::react::ROW_GAP,      facebook::react::COLUMN_GAP,     facebook::react::FLEX_GROW,
+      facebook::react::FLEX_SHRINK,  facebook::react::FLEX_WRAP,      facebook::react::JUSTIFY_CONTENT,
+      facebook::react::MAX_HEIGHT,   facebook::react::MAX_WIDTH,      facebook::react::MIN_HEIGHT,
+      facebook::react::MIN_WIDTH,    facebook::react::STYLE_OVERFLOW, facebook::react::POSITION_TYPE,
+      facebook::react::DIRECTION,    facebook::react::Z_INDEX,
+  };
+  return layoutPropNames.contains(propName);
+}
+
+inline bool shouldSkipNonLayoutProp(facebook::react::PropName propName) {
+  if (shouldFilterNonLayoutProps()) {
+    return !isLayoutProp(propName);
+  }
+  return false;
+}
+
+inline bool animatedPropsContainLayoutProps(const facebook::react::AnimatedProps &animatedProps) {
+  for (const auto &prop : animatedProps.props) {
+    if (isLayoutProp(prop->propName)) {
+      return true;
+    }
+  }
+
+  if (!animatedProps.rawProps) {
+    return false;
+  }
+
+  const auto rawPropsDynamic = animatedProps.rawProps->toDynamic();
+  for (const auto &key : rawPropsDynamic.keys()) {
+    const auto propName = propNameFromString(key.asString());
+    if (propName.has_value() && isLayoutProp(propName.value())) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+inline bool hasLayoutProps(const folly::dynamic &props) {
+  for (const auto &key : props.keys()) {
+    const auto propName = propNameFromString(key.asString());
+    if (propName.has_value() && isLayoutProp(propName.value())) {
+      return true;
+    }
+  }
+  return false;
+}
+
+inline bool hasLayoutProps(facebook::jsi::Runtime &rt, const facebook::jsi::Value &value) {
+  facebook::jsi::Object obj = value.asObject(rt);
+  facebook::jsi::Array names = obj.getPropertyNames(rt);
+  const size_t n = names.size(rt);
+  for (size_t ki = 0; ki < n; ++ki) {
+    facebook::jsi::Value keyVal = names.getValueAtIndex(rt, ki);
+    const auto keyStr = keyVal.asString(rt).utf8(rt);
+    const auto propName = propNameFromString(keyStr);
+    if (propName.has_value() && isLayoutProp(propName.value())) {
+      return true;
+    }
+  }
+  return false;
+}
+
+} // namespace reanimated
+
+#endif