react-native-tvos 0.84.1-0 → 0.85.0-0

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

@@ -7,7 +7,6 @@
 
 #include "ShadowNode.h"
 #include "DynamicPropsUtilities.h"
-#include "ShadowNodeFragment.h"
 
 #include <react/debug/react_native_assert.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
@@ -24,7 +23,7 @@ namespace facebook::react {
  * Runtime shadow node reference updates should only run from one thread at all
  * times to avoid having more than one shadow tree updating the current fiber
  * tree simultaneously. This thread_local flag allows enabling the updates for
- * choses threads.
+ * chosen threads.
  */
 thread_local bool useRuntimeShadowNodeReferenceUpdateOnThread{false}; // NOLINT
 
@@ -33,7 +32,12 @@ thread_local bool useRuntimeShadowNodeReferenceUpdateOnThread{false}; // NOLINT
   useRuntimeShadowNodeReferenceUpdateOnThread = isEnabled;
 }
 
-ShadowNode::SharedListOfShared ShadowNode::emptySharedShadowNodeSharedList() {
+/* static */ bool ShadowNode::getUseRuntimeShadowNodeReferenceUpdateOnThread() {
+  return useRuntimeShadowNodeReferenceUpdateOnThread;
+}
+
+std::shared_ptr<const std::vector<std::shared_ptr<const ShadowNode>>>
+ShadowNode::emptySharedShadowNodeSharedList() {
   static const auto emptySharedShadowNodeSharedList =
       std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>();
   return emptySharedShadowNodeSharedList;
@@ -96,7 +100,7 @@ ShadowNode::ShadowNode(
     child->family_->setParent(family_);
   }
 
-  updateTraitsIfNeccessary();
+  propagateUncullableTraitsFromChildren();
 
   // The first node of the family gets its state committed automatically.
   family_->setMostRecentState(state_);
@@ -112,27 +116,20 @@ ShadowNode::ShadowNode(
       props_(propsForClonedShadowNode(sourceShadowNode, fragment.props)),
       children_(
           fragment.children ? fragment.children : sourceShadowNode.children_),
-      state_(
-          fragment.state ? fragment.state
-                         : (ReactNativeFeatureFlags::useShadowNodeStateOnClone()
-                                ? sourceShadowNode.state_
-                                : sourceShadowNode.getMostRecentState())),
+      state_(fragment.state ? fragment.state : sourceShadowNode.state_),
       orderIndex_(sourceShadowNode.orderIndex_),
       family_(sourceShadowNode.family_),
       traits_(sourceShadowNode.traits_) {
 
   react_native_assert(props_);
   react_native_assert(children_);
-
-  // State could have been progressed above by checking
-  // `sourceShadowNode.getMostRecentState()`.
   traits_.set(ShadowNodeTraits::Trait::ChildrenAreShared);
 
   if (fragment.children) {
     for (const auto& child : *children_) {
       child->family_->setParent(family_);
     }
-    updateTraitsIfNeccessary();
+    propagateUncullableTraitsFromChildren();
   }
 }
 
@@ -154,7 +151,7 @@ std::shared_ptr<ShadowNode> ShadowNode::clone(
            .state = fragment.state});
       return clonedNode;
     } else {
-      // TODO: We might need to merge fragment.priops with
+      // TODO: We might need to merge fragment.props with
       // `family.nativeProps_DEPRECATED`.
       return componentDescriptor.cloneShadowNode(*this, fragment);
     }
@@ -248,7 +245,7 @@ void ShadowNode::appendChild(const std::shared_ptr<const ShadowNode>& child) {
   children.push_back(child);
 
   child->family_->setParent(family_);
-  updateTraitsIfNeccessary();
+  propagateUncullableTraitsFromChildren();
 }
 
 void ShadowNode::replaceChild(
@@ -282,7 +279,7 @@ void ShadowNode::replaceChild(
   }
 
   react_native_assert(false && "Child to replace was not found.");
-  updateTraitsIfNeccessary();
+  propagateUncullableTraitsFromChildren();
 }
 
 void ShadowNode::cloneChildrenIfShared() {
@@ -295,7 +292,7 @@ void ShadowNode::cloneChildrenIfShared() {
       *children_);
 }
 
-void ShadowNode::updateTraitsIfNeccessary() {
+void ShadowNode::propagateUncullableTraitsFromChildren() {
   if (ReactNativeFeatureFlags::enableViewCulling()) {
     if (traits_.check(ShadowNodeTraits::Trait::Unstable_uncullableView)) {
       return;
@@ -346,7 +343,9 @@ void ShadowNode::transferRuntimeShadowNodeReference(
   destinationShadowNode->runtimeShadowNodeReference_ =
       runtimeShadowNodeReference_;
 
-  if (!ReactNativeFeatureFlags::updateRuntimeShadowNodeReferencesOnCommit()) {
+  if (!ReactNativeFeatureFlags::updateRuntimeShadowNodeReferencesOnCommit() &&
+      !ReactNativeFeatureFlags::
+          updateRuntimeShadowNodeReferencesOnCommitThread()) {
     updateRuntimeShadowNodeReference(destinationShadowNode);
   }
 }
@@ -355,6 +354,8 @@ void ShadowNode::transferRuntimeShadowNodeReference(
     const std::shared_ptr<const ShadowNode>& destinationShadowNode,
     const ShadowNodeFragment& fragment) const {
   if ((ReactNativeFeatureFlags::updateRuntimeShadowNodeReferencesOnCommit() ||
+       ReactNativeFeatureFlags::
+           updateRuntimeShadowNodeReferencesOnCommitThread() ||
        useRuntimeShadowNodeReferenceUpdateOnThread) &&
       fragment.runtimeShadowNodeReference) {
     transferRuntimeShadowNodeReference(destinationShadowNode);
@@ -412,17 +413,16 @@ namespace {
 
 std::shared_ptr<ShadowNode> cloneMultipleRecursive(
     const ShadowNode& shadowNode,
-    const std::unordered_map<const ShadowNodeFamily*, int>& childrenCount,
+    const std::unordered_map<Tag, int>& childrenCount,
     const std::function<std::shared_ptr<
         ShadowNode>(const ShadowNode&, const ShadowNodeFragment&)>& callback) {
-  const auto* family = &shadowNode.getFamily();
   auto& children = shadowNode.getChildren();
   std::shared_ptr<std::vector<std::shared_ptr<const ShadowNode>>> newChildren;
-  auto count = childrenCount.at(family);
+  auto count = childrenCount.at(shadowNode.getTag());
 
   for (size_t i = 0; count > 0 && i < children.size(); i++) {
-    const auto childFamily = &children[i]->getFamily();
-    if (childrenCount.contains(childFamily)) {
+    const auto childTag = children[i]->getTag();
+    if (childrenCount.contains(childTag)) {
       count--;
       if (!newChildren) {
         newChildren =
@@ -440,37 +440,39 @@ std::shared_ptr<ShadowNode> cloneMultipleRecursive(
 } // namespace
 
 std::shared_ptr<ShadowNode> ShadowNode::cloneMultiple(
-    const std::unordered_set<const ShadowNodeFamily*>& familiesToUpdate,
+    const std::unordered_set<std::shared_ptr<const ShadowNodeFamily>>&
+        familiesToUpdate,
     const std::function<std::shared_ptr<ShadowNode>(
         const ShadowNode& oldShadowNode,
         const ShadowNodeFragment& fragment)>& callback) const {
-  std::unordered_map<const ShadowNodeFamily*, int> childrenCount;
+  std::unordered_map<Tag, int> childrenCount;
 
   for (const auto& family : familiesToUpdate) {
-    if (childrenCount.contains(family)) {
+    if (childrenCount.contains(family->getTag())) {
       continue;
     }
 
-    childrenCount[family] = 0;
+    childrenCount[family->getTag()] = 0;
 
     auto ancestor = family->parent_.lock();
     while ((ancestor != nullptr) && ancestor != family_) {
-      auto ancestorIt = childrenCount.find(ancestor.get());
+      auto ancestorTag = ancestor->getTag();
+      auto ancestorIt = childrenCount.find(ancestorTag);
       if (ancestorIt != childrenCount.end()) {
         ancestorIt->second++;
         break;
       }
-      childrenCount[ancestor.get()] = 1;
+      childrenCount[ancestorTag] = 1;
 
       ancestor = ancestor->parent_.lock();
     }
 
     if (ancestor == family_) {
-      childrenCount[ancestor.get()]++;
+      childrenCount[ancestor->getTag()]++;
     }
   }
 
-  if (childrenCount.empty()) {
+  if (!childrenCount.contains(getTag())) {
     return nullptr;
   }
 

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

@@ -30,26 +30,19 @@ struct ShadowNodeWrapper;
 
 class ShadowNode : public Sealable, public DebugStringConvertible, public jsi::NativeState {
  public:
-  // TODO(T223558094): delete this in the next version.
-  using Shared [[deprecated("Use std::shared_ptr<const ShadowNode> instead")]] = std::shared_ptr<const ShadowNode>;
-  // TODO(T223558094): delete this in the next version.
-  using Weak [[deprecated("Use std::weak_ptr<const ShadowNode> instead")]] = std::weak_ptr<const ShadowNode>;
-  // TODO(T223558094): delete this in the next version.
-  using Unshared [[deprecated("Use std::shared_ptr<ShadowNode> instead")]] = std::shared_ptr<ShadowNode>;
-  // TODO(T223558094): delete this in the next version.
-  using ListOfShared [[deprecated("Use std::vector<std::shared_ptr<const ShadowNode>> instead")]] =
-      std::vector<std::shared_ptr<const ShadowNode>>;
-  // TODO(T223558094): delete this in the next version.
-  using ListOfWeak [[deprecated("Use std::vector<std::weak_ptr<const ShadowNode>> instead")]] =
-      std::vector<std::weak_ptr<const ShadowNode>>;
-  using SharedListOfShared = std::shared_ptr<const std::vector<std::shared_ptr<const ShadowNode>>>;
-  using UnsharedListOfShared = std::shared_ptr<std::vector<std::shared_ptr<const ShadowNode>>>;
-  using UnsharedListOfWeak = std::shared_ptr<std::vector<std::weak_ptr<const ShadowNode>>>;
+  using SharedListOfShared
+      [[deprecated("Use std::shared_ptr<const std::vector<std::shared_ptr<const ShadowNode>>> instead")]] =
+          std::shared_ptr<const std::vector<std::shared_ptr<const ShadowNode>>>;
+  using UnsharedListOfShared
+      [[deprecated("Use std::shared_ptr<std::vector<std::shared_ptr<const ShadowNode>>> instead")]] =
+          std::shared_ptr<std::vector<std::shared_ptr<const ShadowNode>>>;
+  using UnsharedListOfWeak [[deprecated("Use std::shared_ptr<std::vector<std::weak_ptr<const ShadowNode>>> instead")]] =
+      std::shared_ptr<std::vector<std::weak_ptr<const ShadowNode>>>;
 
   using AncestorList =
       std::vector<std::pair<std::reference_wrapper<const ShadowNode> /* parentNode */, int /* childIndex */>>;
 
-  static SharedListOfShared emptySharedShadowNodeSharedList();
+  static std::shared_ptr<const std::vector<std::shared_ptr<const ShadowNode>>> emptySharedShadowNodeSharedList();
 
   /*
    * Returns `true` if nodes belong to the same family (they were cloned one
@@ -68,6 +61,8 @@ class ShadowNode : public Sealable, public DebugStringConvertible, public jsi::N
 
   static void setUseRuntimeShadowNodeReferenceUpdateOnThread(bool isEnabled);
 
+  static bool getUseRuntimeShadowNodeReferenceUpdateOnThread();
+
 #pragma mark - Constructors
 
   /*
@@ -114,7 +109,7 @@ class ShadowNode : public Sealable, public DebugStringConvertible, public jsi::N
    * Returns `nullptr` if the operation cannot be performed successfully.
    */
   std::shared_ptr<ShadowNode> cloneMultiple(
-      const std::unordered_set<const ShadowNodeFamily *> &familiesToUpdate,
+      const std::unordered_set<std::shared_ptr<const ShadowNodeFamily>> &familiesToUpdate,
       const std::function<
           std::shared_ptr<ShadowNode>(const ShadowNode &oldShadowNode, const ShadowNodeFragment &fragment)> &callback)
       const;
@@ -236,7 +231,7 @@ class ShadowNode : public Sealable, public DebugStringConvertible, public jsi::N
 
  protected:
   Props::Shared props_;
-  SharedListOfShared children_;
+  std::shared_ptr<const std::vector<std::shared_ptr<const ShadowNode>>> children_;
   State::Shared state_;
   int orderIndex_;
 
@@ -250,13 +245,13 @@ class ShadowNode : public Sealable, public DebugStringConvertible, public jsi::N
   void cloneChildrenIfShared();
 
   /*
-   * Updates the node's traits based on its children's traits.
-   * Specifically, if view culling is enabled and any child has the
-   * Unstable_uncullableView or Unstable_uncullableTrace trait, this node will
-   * also be marked as uncullable. This ensures that if a child needs to be
-   * rendered, its parent will be too.
+   * Propagates uncullable traits from children to this node.
+   * If view culling is enabled and any child has the Unstable_uncullableView
+   * or Unstable_uncullableTrace trait, this node will also be marked as
+   * uncullable. This ensures that if a child needs to be rendered, its parent
+   * will be too.
    */
-  void updateTraitsIfNeccessary();
+  void propagateUncullableTraitsFromChildren();
 
   /*
    * Transfer the runtime reference to this `ShadowNode` to a new instance,
@@ -275,11 +270,6 @@ class ShadowNode : public Sealable, public DebugStringConvertible, public jsi::N
    */
   mutable std::atomic<bool> hasBeenMounted_{false};
 
-  /*
-   * True if shadow node has been promoted to be the next mounted tree.
-   */
-  mutable bool hasBeenPromoted_{false};
-
   static Props::Shared propsForClonedShadowNode(const ShadowNode &sourceShadowNode, const Props::Shared &props);
 
  protected:

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

@@ -33,7 +33,7 @@ ShadowNodeFamily::ShadowNodeFamily(
       componentHandle_(componentDescriptor.getComponentHandle()),
       componentName_(componentDescriptor.getComponentName()) {}
 
-void ShadowNodeFamily::setParent(const ShadowNodeFamily::Shared& parent) const {
+void ShadowNodeFamily::setParent(const ShadowNodeFamily::Shared& parent) {
   react_native_assert(parent_.lock() == nullptr || parent_.lock() == parent);
   if (hasParent_) {
     return;
@@ -59,7 +59,7 @@ ComponentName ShadowNodeFamily::getComponentName() const {
   return componentName_;
 }
 
-void ShadowNodeFamily::setMounted() const {
+void ShadowNodeFamily::setMounted() {
   hasBeenMounted_ = true;
 }
 
@@ -68,7 +68,7 @@ const ComponentDescriptor& ShadowNodeFamily::getComponentDescriptor() const {
 }
 
 void ShadowNodeFamily::onUnmountedFamilyDestroyed(
-    std::function<void(const ShadowNodeFamily& family)> callback) const {
+    std::function<void(const ShadowNodeFamily& family)> callback) {
   onUnmountedFamilyDestroyedCallback_ = std::move(callback);
 }
 
@@ -89,7 +89,7 @@ InstanceHandle::Shared ShadowNodeFamily::getInstanceHandle() const {
 }
 
 void ShadowNodeFamily::setInstanceHandle(
-    InstanceHandle::Shared& instanceHandle) const {
+    InstanceHandle::Shared& instanceHandle) {
   instanceHandle_ = instanceHandle;
 }
 
@@ -144,7 +144,7 @@ State::Shared ShadowNodeFamily::getMostRecentState() const {
   return mostRecentState_;
 }
 
-void ShadowNodeFamily::setMostRecentState(const State::Shared& state) const {
+void ShadowNodeFamily::setMostRecentState(const State::Shared& state) {
   std::unique_lock lock(mutex_);
 
   /*
@@ -175,7 +175,7 @@ std::shared_ptr<const State> ShadowNodeFamily::getMostRecentStateIfObsolete(
 
 void ShadowNodeFamily::dispatchRawState(
     StateUpdate&& stateUpdate,
-    EventQueue::UpdateMode updateMode) const {
+    EventQueue::UpdateMode updateMode) {
   auto eventDispatcher = eventDispatcher_.lock();
   if (!eventDispatcher) {
     return;

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

@@ -41,8 +41,8 @@ struct ShadowNodeFamilyFragment {
  */
 class ShadowNodeFamily final : public jsi::NativeState {
  public:
-  using Shared = std::shared_ptr<const ShadowNodeFamily>;
-  using Weak = std::weak_ptr<const ShadowNodeFamily>;
+  using Shared = std::shared_ptr<ShadowNodeFamily>;
+  using Weak = std::weak_ptr<ShadowNodeFamily>;
 
   using AncestorList =
       std::vector<std::pair<std::reference_wrapper<const ShadowNode> /* parentNode */, int /* childIndex */>>;
@@ -58,7 +58,7 @@ class ShadowNodeFamily final : public jsi::NativeState {
    * This is not technically thread-safe, but practically it mutates the object
    * only once (and the model enforces that this first call is not concurrent).
    */
-  void setParent(const ShadowNodeFamily::Shared &parent) const;
+  void setParent(const ShadowNodeFamily::Shared &parent);
 
   /*
    * Returns a handle (or name) associated with the component.
@@ -90,23 +90,23 @@ class ShadowNodeFamily final : public jsi::NativeState {
    * @param callback will be executed when an unmounted instance of
    * ShadowNodeFamily is destroyed.
    */
-  void onUnmountedFamilyDestroyed(std::function<void(const ShadowNodeFamily &family)> callback) const;
+  void onUnmountedFamilyDestroyed(std::function<void(const ShadowNodeFamily &family)> callback);
 
   /*
    * Sets and gets the most recent state.
    */
   std::shared_ptr<const State> getMostRecentState() const;
-  void setMostRecentState(const std::shared_ptr<const State> &state) const;
+  void setMostRecentState(const std::shared_ptr<const State> &state);
 
   /**
    * Mark this ShadowNodeFamily as mounted.
    */
-  void setMounted() const;
+  void setMounted();
 
   /*
    * Dispatches a state update with given priority.
    */
-  void dispatchRawState(StateUpdate &&stateUpdate, EventQueue::UpdateMode updateMode) const;
+  void dispatchRawState(StateUpdate &&stateUpdate, EventQueue::UpdateMode updateMode);
 
   /*
    * Holds currently applied native props. `nullptr` if setNativeProps API is
@@ -122,7 +122,7 @@ class ShadowNodeFamily final : public jsi::NativeState {
 
   jsi::Value getInstanceHandle(jsi::Runtime &runtime) const;
   InstanceHandle::Shared getInstanceHandle() const;
-  void setInstanceHandle(InstanceHandle::Shared &instanceHandle) const;
+  void setInstanceHandle(InstanceHandle::Shared &instanceHandle);
 
   /**
    * Override destructor to call onUnmountedFamilyDestroyedCallback() for
@@ -142,10 +142,10 @@ class ShadowNodeFamily final : public jsi::NativeState {
   std::shared_ptr<const State> getMostRecentStateIfObsolete(const State &state) const;
 
   EventDispatcher::Weak eventDispatcher_;
-  mutable std::shared_ptr<const State> mostRecentState_;
+  std::shared_ptr<const State> mostRecentState_;
   mutable std::shared_mutex mutex_;
 
-  mutable std::function<void(ShadowNodeFamily &family)> onUnmountedFamilyDestroyedCallback_ = nullptr;
+  std::function<void(ShadowNodeFamily &family)> onUnmountedFamilyDestroyedCallback_ = nullptr;
 
   /*
    * Deprecated.
@@ -160,7 +160,7 @@ class ShadowNodeFamily final : public jsi::NativeState {
   /*
    * Weak reference to the React instance handle
    */
-  mutable InstanceHandle::Shared instanceHandle_;
+  InstanceHandle::Shared instanceHandle_;
 
   /*
    * `EventEmitter` associated with all nodes of the family.
@@ -184,18 +184,18 @@ class ShadowNodeFamily final : public jsi::NativeState {
   /*
    * Points to a family of all parent nodes of all nodes of the family.
    */
-  mutable ShadowNodeFamily::Weak parent_{};
+  ShadowNodeFamily::Weak parent_{};
 
   /*
    * Represents a case where `parent_` is `nullptr`.
    * For optimization purposes only.
    */
-  mutable bool hasParent_{false};
+  bool hasParent_{false};
 
   /*
    * Determines if the ShadowNodeFamily was ever mounted on the screen.
    */
-  mutable bool hasBeenMounted_{false};
+  bool hasBeenMounted_{false};
 };
 
 } // namespace facebook::react

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

@@ -20,9 +20,11 @@ const Props::Shared& ShadowNodeFragment::propsPlaceholder() {
   return instance;
 }
 
-const ShadowNode::SharedListOfShared&
+const std::shared_ptr<const std::vector<std::shared_ptr<const ShadowNode>>>&
 ShadowNodeFragment::childrenPlaceholder() {
-  NO_DESTROY static ShadowNode::SharedListOfShared instance;
+  NO_DESTROY static std::shared_ptr<
+      const std::vector<std::shared_ptr<const ShadowNode>>>
+      instance;
   return instance;
 }
 

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

@@ -24,7 +24,7 @@ namespace facebook::react {
  */
 struct ShadowNodeFragment {
   const Props::Shared &props = propsPlaceholder();
-  const ShadowNode::SharedListOfShared &children = childrenPlaceholder();
+  const std::shared_ptr<const std::vector<std::shared_ptr<const ShadowNode>>> &children = childrenPlaceholder();
   const State::Shared &state = statePlaceholder();
   const bool runtimeShadowNodeReference = true;
 
@@ -34,7 +34,7 @@ struct ShadowNodeFragment {
    * be changed.
    */
   static const Props::Shared &propsPlaceholder();
-  static const ShadowNode::SharedListOfShared &childrenPlaceholder();
+  static const std::shared_ptr<const std::vector<std::shared_ptr<const ShadowNode>>> &childrenPlaceholder();
   static const State::Shared &statePlaceholder();
 };
 

package/ReactCommon/react/renderer/core/tests/ShadowNodeTest.cpp

@@ -316,7 +316,7 @@ TEST_F(ShadowNodeTest, handleRuntimeReferenceTransferOnClone) {
 TEST_F(ShadowNodeTest, cloneMultiple) {
   auto newProps = std::make_shared<const TestProps>();
   auto newRoot = nodeA_->cloneMultiple(
-      {&nodeA_->getFamily(), &nodeAB_->getFamily()},
+      {nodeA_->getFamilyShared(), nodeAB_->getFamilyShared()},
       [&](const ShadowNode& oldShadowNode, const ShadowNodeFragment& fragment) {
         return oldShadowNode.clone({
             .props = newProps,
@@ -346,7 +346,7 @@ TEST_F(ShadowNodeTest, cloneMultiple) {
 TEST_F(ShadowNodeTest, cloneMultipleWithSingleFamily) {
   auto newProps = std::make_shared<const TestProps>();
   auto newRoot = nodeA_->cloneMultiple(
-      {&nodeAB_->getFamily()},
+      {nodeAB_->getFamilyShared()},
       [&](const ShadowNode& oldShadowNode, const ShadowNodeFragment& fragment) {
         return oldShadowNode.clone({
             .props = newProps,
@@ -374,3 +374,58 @@ TEST_F(ShadowNodeTest, cloneMultipleWithSingleFamily) {
   EXPECT_EQ(newNodeABA->getTag(), nodeABA_->getTag());
   EXPECT_EQ(newNodeABA.get(), nodeABA_.get());
 }
+
+TEST_F(ShadowNodeTest, cloneMultipleReturnsNullptrWhenFamilyHasNoPathToRoot) {
+  auto newProps = std::make_shared<const TestProps>();
+  // nodeZ_ is not part of nodeA_'s tree
+  auto result = nodeA_->cloneMultiple(
+      {nodeZ_->getFamilyShared()},
+      [&](const ShadowNode& oldShadowNode, const ShadowNodeFragment& fragment) {
+        return oldShadowNode.clone({
+            .props = newProps,
+            .children = fragment.children,
+            .state = fragment.state,
+        });
+      });
+
+  // cloneMultiple should return nullptr when the family has no path to the root
+  EXPECT_EQ(result, nullptr);
+}
+
+TEST_F(ShadowNodeTest, cloneMultipleWithMixOfValidAndInvalidFamilies) {
+  auto newProps = std::make_shared<const TestProps>();
+  // nodeAB_ is in the tree, nodeZ_ is not
+  auto result = nodeA_->cloneMultiple(
+      {nodeAB_->getFamilyShared(), nodeZ_->getFamilyShared()},
+      [&](const ShadowNode& oldShadowNode, const ShadowNodeFragment& fragment) {
+        return oldShadowNode.clone({
+            .props = newProps,
+            .children = fragment.children,
+            .state = fragment.state,
+        });
+      });
+
+  // Should still succeed and clone the valid family (nodeAB_)
+  EXPECT_NE(result, nullptr);
+  EXPECT_EQ(result->getTag(), nodeA_->getTag());
+  EXPECT_EQ(result->getProps(), newProps);
+
+  auto newNodeAB = result->getChildren()[1];
+  EXPECT_EQ(newNodeAB->getTag(), nodeAB_->getTag());
+  EXPECT_EQ(newNodeAB->getProps(), newProps);
+}
+
+TEST_F(ShadowNodeTest, cloneMultipleWithEmptyFamilySet) {
+  auto newProps = std::make_shared<const TestProps>();
+  auto result = nodeA_->cloneMultiple(
+      {},
+      [&](const ShadowNode& oldShadowNode, const ShadowNodeFragment& fragment) {
+        return oldShadowNode.clone({
+            .props = newProps,
+            .children = fragment.children,
+            .state = fragment.state,
+        });
+      });
+
+  EXPECT_EQ(result, nullptr);
+}