@depup/react-native 0.86.0-depup.49 → 0.87.0-depup.0

package/ReactCommon/react/renderer/core/ConcreteComponentDescriptor.h

@@ -48,7 +48,18 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
       RawPropsParser &&rawPropsParser = {})
       : ComponentDescriptor(parameters, std::move(rawPropsParser))
   {
-    rawPropsParser_.prepare<ConcreteProps>();
+    // The parser's `keys_` / `nameToIndex_` are only consumed by
+    // `RawProps::at()`, which is reached exclusively through the classic
+    // per-field `convertRawProp` path. When `ConcreteProps` opts into the
+    // iterator-setter path and the runtime flag is on, `parse()` is never
+    // called, so the O(n²) preparation here is wasted. Skip it.
+    if constexpr (HasIteratorSetterCtor<ConcreteProps>) {
+      if (!ReactNativeFeatureFlags::enableCppPropsIteratorSetter()) {
+        rawPropsParser_.prepare<ConcreteProps>();
+      }
+    } else {
+      rawPropsParser_.prepare<ConcreteProps>();
+    }
   }
 
   ComponentHandle getComponentHandle() const override
@@ -112,9 +123,30 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
       ShadowNodeT::filterRawProps(rawProps);
     }
 
-    rawProps.parse(rawPropsParser_);
+    // Two construction paths:
+    //  - Iterator-setter (only available when `ConcreteProps` satisfies
+    //    `HasIteratorSetterCtor` AND the runtime flag is on): copy-construct
+    //    from sourceProps, then walk rawProps in-place via `forEachItem` and
+    //    route each entry through `setProp`. Skips both
+    //    `RawProps::parse(parser)` and the `folly::dynamic` materialization
+    //    that the legacy path needed.
+    //  - Classic (the fallback for any `ConcreteProps` that doesn't opt in,
+    //    and the only path when the flag is off): parse + per-field
+    //    `convertRawProp` via the 3-arg ctor.
+    constexpr bool kSupportsIteratorSetter = HasIteratorSetterCtor<ConcreteProps>;
+    const bool useIteratorSetter = kSupportsIteratorSetter && ReactNativeFeatureFlags::enableCppPropsIteratorSetter();
+
+    std::shared_ptr<ConcreteProps> shadowNodeProps;
+    if constexpr (kSupportsIteratorSetter) {
+      if (useIteratorSetter) {
+        shadowNodeProps = ShadowNodeT::Props(props);
+      }
+    }
+    if (!useIteratorSetter) {
+      rawProps.parse(rawPropsParser_);
+      shadowNodeProps = ShadowNodeT::Props(context, rawProps, props);
+    }
 
-    auto shadowNodeProps = ShadowNodeT::Props(context, rawProps, props);
 #ifdef RN_SERIALIZABLE_STATE
     bool fallbackToDynamicRawPropsAccumulation = true;
     if (ReactNativeFeatureFlags::enableExclusivePropsUpdateAndroid() &&
@@ -134,19 +166,12 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
       ShadowNodeT::initializeDynamicProps(shadowNodeProps, rawProps, props);
     }
 #endif
-    // Use the new-style iterator
-    // Note that we just check if `Props` has this flag set, no matter
-    // the type of ShadowNode; it acts as the single global flag.
-    if (ReactNativeFeatureFlags::enableCppPropsIteratorSetter()) {
-#ifdef RN_SERIALIZABLE_STATE
-      const auto &dynamic =
-          fallbackToDynamicRawPropsAccumulation ? shadowNodeProps->rawProps : static_cast<folly::dynamic>(rawProps);
-#else
-      const auto &dynamic = static_cast<folly::dynamic>(rawProps);
-#endif
-      for (const auto &pair : dynamic.items()) {
-        const auto &name = pair.first.getString();
-        shadowNodeProps->setProp(context, RAW_PROPS_KEY_HASH(name), name.c_str(), RawValue(pair.second));
+
+    if constexpr (kSupportsIteratorSetter) {
+      if (useIteratorSetter) {
+        rawProps.forEachItem([&](std::string_view name, const RawValue &value) {
+          shadowNodeProps->setProp(context, RAW_PROPS_KEY_HASH(name), name.data(), value);
+        });
       }
     }
     return shadowNodeProps;

package/ReactCommon/react/renderer/core/ConcreteShadowNode.h

@@ -71,6 +71,13 @@ class ConcreteShadowNode : public BaseShadowNodeT {
     return BaseShadowNodeT::BaseTraits();
   }
 
+  /*
+   * Classic / parse path: construct `PropsT` by parsing `rawProps` field-by-
+   * field via the 3-arg `(context, sourceProps, rawProps)` constructor.
+   * `ConcreteComponentDescriptor::cloneProps` calls this when the
+   * iterator-setter path is disabled (per-class via the
+   * `HasIteratorSetterCtor` concept, or globally via the runtime flag).
+   */
   static UnsharedConcreteProps
   Props(const PropsParserContext &context, const RawProps &rawProps, const Props::Shared &baseProps = nullptr)
   {
@@ -78,6 +85,18 @@ class ConcreteShadowNode : public BaseShadowNodeT {
         context, baseProps ? static_cast<const PropsT &>(*baseProps) : *defaultSharedProps(), rawProps);
   }
 
+  /*
+   * Iterator-setter path: copy-construct `PropsT` from `baseProps` only.
+   * `ConcreteComponentDescriptor::cloneProps` then walks `rawProps` via
+   * `RawProps::forEachItem` and overwrites individual fields through
+   * `PropsT::setProp`. Available when `PropsT` satisfies
+   * `HasIteratorSetterCtor`.
+   */
+  static UnsharedConcreteProps Props(const Props::Shared &baseProps)
+  {
+    return std::make_shared<PropsT>(baseProps ? static_cast<const PropsT &>(*baseProps) : *defaultSharedProps());
+  }
+
 #ifdef RN_SERIALIZABLE_STATE
   static void initializeDynamicProps(
       UnsharedConcreteProps props,

package/ReactCommon/react/renderer/core/EventEmitter.cpp

@@ -134,11 +134,19 @@ void EventEmitter::dispatchEvent(
     return;
   }
 
+  SharedEventTarget eventTarget;
+  std::weak_ptr<const ShadowNodeFamily> shadowNodeFamily;
+  {
+    std::scoped_lock lock(DispatchMutex());
+    eventTarget = eventTarget_;
+    shadowNodeFamily = shadowNodeFamily_;
+  }
+
   eventDispatcher->dispatchEvent(RawEvent(
       normalizeEventType(std::move(type)),
       std::move(payload),
-      eventTarget_,
-      shadowNodeFamily_,
+      std::move(eventTarget),
+      std::move(shadowNodeFamily),
       category,
       false,
       eventTimestamp));
@@ -180,11 +188,19 @@ void EventEmitter::dispatchUniqueEvent(
     return;
   }
 
+  SharedEventTarget eventTarget;
+  std::weak_ptr<const ShadowNodeFamily> shadowNodeFamily;
+  {
+    std::scoped_lock lock(DispatchMutex());
+    eventTarget = eventTarget_;
+    shadowNodeFamily = shadowNodeFamily_;
+  }
+
   eventDispatcher->dispatchUniqueEvent(RawEvent(
       normalizeEventType(std::move(type)),
       std::move(payload),
-      eventTarget_,
-      shadowNodeFamily_,
+      std::move(eventTarget),
+      std::move(shadowNodeFamily),
       RawEvent::Category::Continuous,
       true,
       eventTimestamp));

package/ReactCommon/react/renderer/core/LayoutMetrics.h

@@ -40,6 +40,8 @@ struct LayoutMetrics {
   bool wasLeftAndRightSwapped{false};
   // Pixel density. Number of device pixels per density-independent pixel.
   Float pointScaleFactor{1.0};
+  // Surface font scale this node was last laid out with.
+  Float fontSizeMultiplier{1.0};
   // How much the children of the node actually overflow in each direction.
   // Positive values indicate that children are overflowing outside of the node.
   // Negative values indicate that children are clipped inside the node
@@ -120,6 +122,7 @@ struct hash<facebook::react::LayoutMetrics> {
         layoutMetrics.displayType,
         layoutMetrics.layoutDirection,
         layoutMetrics.pointScaleFactor,
+        layoutMetrics.fontSizeMultiplier,
         layoutMetrics.overflowInset);
   }
 };

package/ReactCommon/react/renderer/core/Props.cpp

@@ -10,48 +10,23 @@
 #include <react/renderer/core/propsConversions.h>
 
 #include <react/featureflags/ReactNativeFeatureFlags.h>
+#include <react/renderer/core/DynamicPropsUtilities.h>
 #include <react/renderer/debug/debugStringConvertibleUtils.h>
-#include "DynamicPropsUtilities.h"
 
 namespace facebook::react {
 
 Props::Props(
-    const PropsParserContext& context,
-    const Props& sourceProps,
-    const RawProps& rawProps,
-    const std::function<bool(const std::string&)>& filterObjectKeys) {
-  initialize(context, sourceProps, rawProps, filterObjectKeys);
-}
-
-void Props::initialize(
     const PropsParserContext& context,
     const Props& sourceProps,
     const RawProps& rawProps,
     [[maybe_unused]] const std::function<bool(const std::string&)>&
-        filterObjectKeys) {
-  nativeId = ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
-      ? sourceProps.nativeId
-      : convertRawProp(context, rawProps, "nativeID", sourceProps.nativeId, {});
-
-  if (!ReactNativeFeatureFlags::enableCppPropsIteratorSetter()) {
-    if (ReactNativeFeatureFlags::enableNativeViewPropTransformations()) {
-      // id -> nativeId
-      auto* idValue = rawProps.at("id", nullptr, nullptr);
-      if (idValue != nullptr) {
-        if (idValue->hasValue()) {
-          fromRawValue(context, *idValue, nativeId);
-        } else {
-          nativeId = {};
-        }
-      }
-    }
-  }
-#ifdef RN_SERIALIZABLE_STATE
-  if (!ReactNativeFeatureFlags::enableExclusivePropsUpdateAndroid()) {
-    initializeDynamicProps(sourceProps, rawProps, filterObjectKeys);
-  }
-#endif
-}
+        filterObjectKeys)
+    : nativeId(convertRawProp(
+          context,
+          rawProps,
+          "nativeID",
+          sourceProps.nativeId,
+          {})) {}
 
 void Props::setProp(
     const PropsParserContext& context,
@@ -62,12 +37,6 @@ void Props::setProp(
     case CONSTEXPR_RAW_PROPS_KEY_HASH("nativeID"):
       fromRawValue(context, value, nativeId, {});
       return;
-    case CONSTEXPR_RAW_PROPS_KEY_HASH("id"):
-      if (!ReactNativeFeatureFlags::enableNativeViewPropTransformations()) {
-        return;
-      }
-      fromRawValue(context, value, nativeId, {});
-      return;
   }
 }
 

package/ReactCommon/react/renderer/core/Props.h

@@ -41,7 +41,7 @@ class Props : public virtual Sealable, public virtual DebugStringConvertible {
   virtual ~Props() = default;
 #endif
 
-  Props(const Props &other) = delete;
+  Props(const Props &other) = default;
   Props &operator=(const Props &other) = delete;
 
   /**
@@ -82,18 +82,68 @@ class Props : public virtual Sealable, public virtual DebugStringConvertible {
   SharedDebugStringConvertibleList getDebugProps() const override;
 
 #endif
-
- protected:
-  /** Initialize member variables of Props instance */
-  void initialize(
-      const PropsParserContext &context,
-      const Props &sourceProps,
-      const RawProps &rawProps,
-      /**
-       * Filter object keys to be excluded when converting the RawProps to
-       * folly::dynamic (android only)
-       */
-      const std::function<bool(const std::string &)> &filterObjectKeys = nullptr);
 };
 
+namespace detail {
+
+/*
+ * Extracts the class type from a pointer-to-member-function expression.
+ * Used in unevaluated context only.
+ */
+template <typename T, typename C>
+auto memberFunctionClass(T C::*) -> C;
+
+} // namespace detail
+
+/*
+ * Internal: `T` declares its OWN `setProp` (not just inherits one from a
+ * base class). `&T::setProp` resolves to a pointer-to-member-function whose
+ * class part is the level where `setProp` was actually declared — if `T`
+ * inherits without overriding, that class is some base, not `T`.
+ *
+ * Distinguishing own-declaration from inherited-declaration matters because
+ * `setProp` is non-virtual. A subclass that adds fields but forgets to
+ * override `setProp` would silently inherit its parent's switch — and the new
+ * fields would never be reached by the iterator-setter dispatch.
+ */
+template <typename T>
+concept DeclaresOwnSetProp = std::is_same_v<decltype(detail::memberFunctionClass(&T::setProp)), T>;
+
+/*
+ * Internal: `T` exposes a `setProp(ctx, hash, name, value) -> void` callable
+ * with the canonical Props signature, declared on `T` itself.
+ */
+template <typename T>
+concept HasSetProp = DeclaresOwnSetProp<T> &&
+    requires(T &t, const PropsParserContext &ctx, RawPropsPropNameHash hash, const char *name, const RawValue &value) {
+      { t.setProp(ctx, hash, name, value) } -> std::same_as<void>;
+    };
+
+/*
+ * Marks a Props type as supporting the iterator-setter construction path used
+ * by `ConcreteComponentDescriptor::cloneProps` when
+ * `enableCppPropsIteratorSetter` is on. The contract is:
+ *
+ *   1. The type is copy-constructible from a source Props (so `cloneProps`
+ *      can build the new Props by copy and then overwrite individual fields).
+ *   2. The type descends from `Props`, anchoring the `setProp` chain in the
+ *      `Props::setProp` base case.
+ *   3. The type declares its OWN `setProp` with the canonical signature —
+ *      not inherited — so the iterator dispatch reaches every field that the
+ *      type adds beyond its base.
+ *
+ * `setProp` is non-virtual; subclasses chain explicitly via
+ * `Parent::setProp(...)`. The chain integrity beyond `T` is enforced by the
+ * compiler at each level's `setProp` body — if a subclass calls
+ * `Parent::setProp(...)` and `Parent` does not define one, the build fails
+ * at that call site. This concept guards the entry point (`T` itself) and
+ * relies on those per-level calls to keep the chain whole.
+ *
+ * When the concept is NOT satisfied for some `ConcreteProps`,
+ * `cloneProps` falls through to the classic per-field `convertRawProp` path
+ * for that component regardless of the runtime flag.
+ */
+template <typename T>
+concept HasIteratorSetterCtor = std::copy_constructible<T> && std::derived_from<T, Props> && HasSetProp<T>;
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/core/RawProps.cpp

@@ -9,7 +9,6 @@
 
 #include <cxxreact/TraceSection.h>
 #include <react/debug/react_native_assert.h>
-#include <react/renderer/core/RawPropsKey.h>
 #include <react/renderer/core/RawPropsParser.h>
 
 namespace facebook::react {
@@ -110,15 +109,33 @@ bool RawProps::isEmpty() const noexcept {
  * Returns a const unowning pointer to `RawValue` of a prop with a given name.
  * Returns `nullptr` if a prop with the given name does not exist.
  */
+const RawValue* RawProps::at(const char* name) const noexcept {
+  react_native_assert(
+      parser_ &&
+      "The object is not parsed. `parse` must be called before `at`.");
+  return parser_->at(*this, name);
+}
+
 const RawValue* RawProps::at(
     const char* name,
     const char* prefix,
     const char* suffix) const noexcept {
+  if (prefix == nullptr && suffix == nullptr) {
+    return at(name);
+  }
+
+  std::string concatenated;
+  if (prefix != nullptr) {
+    concatenated += prefix;
+  }
+  concatenated += name;
+  if (suffix != nullptr) {
+    concatenated += suffix;
+  }
   react_native_assert(
       parser_ &&
       "The object is not parsed. `parse` must be called before `at`.");
-  return parser_->at(
-      *this, RawPropsKey{.prefix = prefix, .name = name, .suffix = suffix});
+  return parser_->at(*this, concatenated);
 }
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/core/RawProps.h

@@ -9,6 +9,7 @@
 
 #include <limits>
 #include <optional>
+#include <string>
 
 #include <folly/dynamic.h>
 #include <jsi/JSIDynamic.h>
@@ -90,8 +91,51 @@ class RawProps final {
    * Returns a const unowning pointer to `RawValue` of a prop with a given name.
    * Returns `nullptr` if a prop with the given name does not exist.
    */
+  const RawValue *at(const char *name) const noexcept;
+
+  // Deprecated: Use at(name) instead. This overload exists for backwards
+  // compatibility with callers that pass prefix/suffix separately.
   const RawValue *at(const char *name, const char *prefix, const char *suffix) const noexcept;
 
+  /*
+   * Iterates the underlying source object and invokes `fn(name, value)` for
+   * each entry, in source order. Skips parsing — does NOT require a prior
+   * `parse(parser)` call. For `Mode::JSI` this walks the JSI object in-place
+   * (no `folly::dynamic` materialization). For `Mode::Dynamic` it walks
+   * `dynamic_.items()`. For `Mode::Empty` it is a no-op.
+   *
+   * The callback signature is `void(std::string_view name, const RawValue &value)`.
+   * The view points into storage owned by `forEachItem` for the duration of
+   * the call and is null-terminated (i.e. `name.data()` is a valid C string).
+   */
+  template <typename Fn>
+  void forEachItem(Fn fn) const
+  {
+    switch (mode_) {
+      case Mode::Empty:
+        return;
+      case Mode::JSI: {
+        auto object = value_.asObject(*runtime_);
+        auto names = object.getPropertyNames(*runtime_);
+        auto count = names.size(*runtime_);
+        for (size_t i = 0; i < count; ++i) {
+          auto name = names.getValueAtIndex(*runtime_, i).getString(*runtime_);
+          auto propValue = object.getProperty(*runtime_, name);
+          auto nameUtf8 = name.utf8(*runtime_);
+          fn(std::string_view{nameUtf8}, RawValue{*runtime_, std::move(propValue)});
+        }
+        return;
+      }
+      case Mode::Dynamic:
+        for (const auto &pair : dynamic_.items()) {
+          fn(std::string_view{pair.first.getString()}, RawValue{pair.second});
+        }
+        return;
+      default:
+        return;
+    }
+  }
+
  private:
   friend class RawPropsParser;
 

package/ReactCommon/react/renderer/core/RawPropsKeyMap.cpp

@@ -9,7 +9,6 @@
 
 #include <react/debug/react_native_assert.h>
 
-#include <glog/logging.h>
 #include <algorithm>
 #include <cassert>
 #include <cstdlib>
@@ -33,11 +32,14 @@ bool RawPropsKeyMap::shouldFirstOneBeBeforeSecondOne(
 }
 
 void RawPropsKeyMap::insert(
-    const RawPropsKey& key,
+    std::string_view key,
     RawPropsValueIndex value) noexcept {
   auto item = Item{};
   item.value = value;
-  key.render(item.name, &item.length);
+  auto length =
+      std::min(key.size(), static_cast<size_t>(kPropNameLengthHardCap - 1));
+  std::copy_n(key.data(), length, item.name);
+  item.length = static_cast<RawPropsPropNameLength>(length);
   items_.push_back(item);
   react_native_assert(
       items_.size() < std::numeric_limits<RawPropsPropNameLength>::max());
@@ -52,26 +54,9 @@ void RawPropsKeyMap::reindex() noexcept {
       &RawPropsKeyMap::shouldFirstOneBeBeforeSecondOne);
 
   // Filtering out duplicating keys.
-  // Accessing the same key twice is supported by RawPropsPorser, but the
-  // RawPropsKey used must be identical, and if not, lookup will be
-  // inconsistent.
-  auto it = items_.begin();
-  auto end = items_.end();
-  // Implements std::unique with additional logging
-  if (it != end) {
-    auto result = it;
-    while (++it != end) {
-      if (hasSameName(*result, *it)) {
-        LOG(WARNING)
-            << "Component property map contains multiple entries for '"
-            << std::string_view(it->name, it->length)
-            << "'. Ensure all calls to convertRawProp use a consistent prefix, name and suffix.";
-      } else if (++result != it) {
-        *result = *it;
-      }
-    }
-    items_.erase(++result, items_.end());
-  }
+  items_.erase(
+      std::unique(items_.begin(), items_.end(), &RawPropsKeyMap::hasSameName),
+      items_.end());
 
   buckets_.resize(kPropNameLengthHardCap);
 
@@ -91,9 +76,8 @@ void RawPropsKeyMap::reindex() noexcept {
   }
 }
 
-RawPropsValueIndex RawPropsKeyMap::at(
-    const char* name,
-    RawPropsPropNameLength length) noexcept {
+RawPropsValueIndex RawPropsKeyMap::at(std::string_view name) noexcept {
+  auto length = static_cast<RawPropsPropNameLength>(name.size());
   react_native_assert(length > 0);
   react_native_assert(length < kPropNameLengthHardCap);
   if (length == 0 || length >= kPropNameLengthHardCap) [[unlikely]] {
@@ -107,7 +91,7 @@ RawPropsValueIndex RawPropsKeyMap::at(
   // 2. Binary search in the bucket.
   while (lower <= upper) {
     auto median = (lower + upper) / 2;
-    auto condition = std::memcmp(items_[median].name, name, length);
+    auto condition = std::memcmp(items_[median].name, name.data(), length);
     if (condition < 0) {
       lower = median + 1;
     } else if (condition == 0) {

package/ReactCommon/react/renderer/core/RawPropsKeyMap.h

@@ -7,8 +7,8 @@
 
 #pragma once
 
-#include <react/renderer/core/RawPropsKey.h>
 #include <react/renderer/core/RawPropsPrimitives.h>
+#include <string_view>
 #include <vector>
 
 namespace facebook::react {
@@ -25,7 +25,7 @@ class RawPropsKeyMap final {
   /*
    * Stores `value` with by given `key`.
    */
-  void insert(const RawPropsKey &key, RawPropsValueIndex value) noexcept;
+  void insert(std::string_view key, RawPropsValueIndex value) noexcept;
 
   /*
    * Reindexes the stored data.
@@ -37,7 +37,7 @@ class RawPropsKeyMap final {
    * Finds and returns the `value` (some index) by given `key`.
    * Returns `kRawPropsValueIndexEmpty` if the value wan't found.
    */
-  RawPropsValueIndex at(const char *name, RawPropsPropNameLength length) noexcept;
+  RawPropsValueIndex at(std::string_view name) noexcept;
 
  private:
   struct Item {

package/ReactCommon/react/renderer/core/RawPropsParser.cpp

@@ -19,7 +19,7 @@ namespace facebook::react {
 // which props are accessed during parsing, and in which order.
 const RawValue* RawPropsParser::at(
     const RawProps& rawProps,
-    const RawPropsKey& key) const noexcept {
+    std::string_view key) const noexcept {
   if (!ready_) [[unlikely]] {
     // Check against the same key being inserted more than once.
     // This happens commonly with nested Props structs, where the higher-level
@@ -74,7 +74,7 @@ const RawValue* RawPropsParser::at(
       if (resetLoop) {
         LOG(ERROR)
             << "Looked up property name which was not seen when preparing: "
-            << (std::string)key;
+            << key;
         return nullptr;
       }
       resetLoop = true;
@@ -126,8 +126,7 @@ void RawPropsParser::preparse(const RawProps& rawProps) const noexcept {
       for (size_t i = 0; i < count; i++) {
         auto nameValue = names.getValueAtIndex(runtime, i).getString(runtime);
         auto name = nameValue.utf8(runtime);
-        auto keyIndex = nameToIndex_.at(
-            name.data(), static_cast<RawPropsPropNameLength>(name.size()));
+        auto keyIndex = nameToIndex_.at(name);
 
         if (keyIndex == kRawPropsValueIndexEmpty) {
           continue;
@@ -150,8 +149,7 @@ void RawPropsParser::preparse(const RawProps& rawProps) const noexcept {
       for (const auto& pair : dynamic.items()) {
         auto name = pair.first.getString();
 
-        auto keyIndex = nameToIndex_.at(
-            name.data(), static_cast<RawPropsPropNameLength>(name.size()));
+        auto keyIndex = nameToIndex_.at(name);
 
         if (keyIndex == kRawPropsValueIndexEmpty) {
           continue;

package/ReactCommon/react/renderer/core/RawPropsParser.h

@@ -10,10 +10,10 @@
 #include <react/renderer/core/Props.h>
 #include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/RawProps.h>
-#include <react/renderer/core/RawPropsKey.h>
 #include <react/renderer/core/RawPropsKeyMap.h>
 #include <react/renderer/core/RawPropsPrimitives.h>
 #include <react/renderer/core/RawValue.h>
+#include <string_view>
 
 namespace facebook::react {
 
@@ -70,9 +70,9 @@ class RawPropsParser final {
   /*
    * To be used by `RawProps` only.
    */
-  const RawValue *at(const RawProps &rawProps, const RawPropsKey &key) const noexcept;
+  const RawValue *at(const RawProps &rawProps, std::string_view key) const noexcept;
 
-  mutable std::vector<RawPropsKey> keys_{};
+  mutable std::vector<std::string_view> keys_{};
   mutable RawPropsKeyMap nameToIndex_{};
   mutable bool ready_{false};
 };

package/ReactCommon/react/renderer/core/ShadowNode.cpp

@@ -137,27 +137,35 @@ std::shared_ptr<ShadowNode> ShadowNode::clone(
     const ShadowNodeFragment& fragment) const {
   const auto& family = *family_;
   const auto& componentDescriptor = family.componentDescriptor_;
-  if (family.nativeProps_DEPRECATED != nullptr) {
-    auto propsParserContext = PropsParserContext{family_->getSurfaceId(), {}};
-    if (fragment.props == ShadowNodeFragment::propsPlaceholder()) {
-      // Clone existing `props_` with `family.nativeProps_DEPRECATED` to apply
-      // previously set props via `setNativeProps` API.
-      auto props = componentDescriptor.cloneProps(
-          propsParserContext, props_, RawProps(*family.nativeProps_DEPRECATED));
-      auto clonedNode = componentDescriptor.cloneShadowNode(
-          *this,
-          {.props = props,
-           .children = fragment.children,
-           .state = fragment.state});
-      return clonedNode;
-    } else {
-      // TODO: We might need to merge fragment.props with
-      // `family.nativeProps_DEPRECATED`.
-      return componentDescriptor.cloneShadowNode(*this, fragment);
+
+  std::optional<RawProps> propsOverride;
+  {
+    std::lock_guard<std::mutex> lock(family.nativePropsMutex);
+    if (family.nativeProps_DEPRECATED != nullptr) {
+      if (fragment.props == ShadowNodeFragment::propsPlaceholder()) {
+        propsOverride.emplace(*family.nativeProps_DEPRECATED);
+      } else {
+        // TODO: We might need to merge fragment.props with
+        // `family.nativeProps_DEPRECATED`.
+      }
     }
-  } else {
-    return componentDescriptor.cloneShadowNode(*this, fragment);
   }
+
+  if (propsOverride) {
+    // Clone existing `props_` with `family.nativeProps_DEPRECATED` to
+    // apply previously set props via `setNativeProps` API. The parsed
+    // result escapes the lock so the rest of the clone work runs
+    // unblocked.
+    auto propsParserContext = PropsParserContext{family_->getSurfaceId(), {}};
+    return componentDescriptor.cloneShadowNode(
+        *this,
+        {.props = componentDescriptor.cloneProps(
+             propsParserContext, props_, std::move(*propsOverride)),
+         .children = fragment.children,
+         .state = fragment.state});
+  }
+
+  return componentDescriptor.cloneShadowNode(*this, fragment);
 }
 
 std::shared_ptr<const ContextContainer> ShadowNode::getContextContainer()

package/ReactCommon/react/renderer/core/ShadowNodeFamily.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <memory>
+#include <mutex>
 #include <shared_mutex>
 
 #include <react/renderer/core/EventEmitter.h>
@@ -114,6 +115,7 @@ class ShadowNodeFamily final : public jsi::NativeState {
    * architecture and will be removed in the future.
    */
   mutable std::unique_ptr<folly::dynamic> nativeProps_DEPRECATED;
+  mutable std::mutex nativePropsMutex;
 
   /**
    * @return tag for the ShadowNodeFamily.