react-native-tvos 0.80.1-0 → 0.81.0-0

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

@@ -76,10 +76,11 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
     return shadowNode;
   }
 
-  ShadowNode::Unshared cloneShadowNode(
+  std::shared_ptr<ShadowNode> cloneShadowNode(
       const ShadowNode& sourceShadowNode,
       const ShadowNodeFragment& fragment) const override {
     auto shadowNode = std::make_shared<ShadowNodeT>(sourceShadowNode, fragment);
+    shadowNode->completeClone(sourceShadowNode, fragment);
     sourceShadowNode.transferRuntimeShadowNodeReference(shadowNode, fragment);
 
     adopt(*shadowNode);
@@ -87,8 +88,8 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
   }
 
   void appendChild(
-      const ShadowNode::Shared& parentShadowNode,
-      const ShadowNode::Shared& childShadowNode) const override {
+      const std::shared_ptr<const ShadowNode>& parentShadowNode,
+      const std::shared_ptr<const ShadowNode>& childShadowNode) const override {
     auto& concreteParentShadowNode =
         static_cast<const ShadowNodeT&>(*parentShadowNode);
     const_cast<ShadowNodeT&>(concreteParentShadowNode)
@@ -119,7 +120,7 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
     // 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 ANDROID
+#ifdef RN_SERIALIZABLE_STATE
       const auto& dynamic = shadowNodeProps->rawProps;
 #else
       const auto& dynamic = static_cast<folly::dynamic>(rawProps);
@@ -171,8 +172,10 @@ class ConcreteComponentDescriptor : public ComponentDescriptor {
         std::make_shared<EventTarget>(
             fragment.instanceHandle, fragment.surfaceId),
         eventDispatcher_);
-    return std::make_shared<ShadowNodeFamily>(
-        fragment, std::move(eventEmitter), eventDispatcher_, *this);
+    auto family = std::make_shared<ShadowNodeFamily>(
+        fragment, eventEmitter, eventDispatcher_, *this);
+    eventEmitter->setShadowNodeFamily(family);
+    return family;
   }
 
  protected:

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

@@ -13,7 +13,7 @@
 #include <react/debug/react_native_assert.h>
 #include <react/renderer/core/State.h>
 
-#ifdef ANDROID
+#ifdef RN_SERIALIZABLE_STATE
 #include <fbjni/fbjni.h>
 #include <react/renderer/mapbuffer/MapBuffer.h>
 #include <react/renderer/mapbuffer/MapBufferBuilder.h>
@@ -21,7 +21,7 @@
 
 namespace facebook::react {
 
-#ifdef ANDROID
+#ifdef RN_SERIALIZABLE_STATE
 template <typename StateDataT>
 concept StateDataWithMapBuffer = requires(StateDataT stateData) {
   { stateData.getMapBuffer() } -> std::same_as<MapBuffer>;
@@ -49,17 +49,15 @@ class ConcreteState : public State {
   /*
    * Creates an updated `State` object with given previous one and `data`.
    */
-  explicit ConcreteState(const SharedData& data, const State& previousState)
-      : State(data, previousState) {}
+  explicit ConcreteState(SharedData data, const State& previousState)
+      : State(std::move(data), previousState) {}
 
   /*
    * Creates a first-of-its-family `State` object with given `family` and
    * `data`.
    */
-  explicit ConcreteState(
-      const SharedData& data,
-      const ShadowNodeFamily::Shared& family)
-      : State(data, family) {}
+  explicit ConcreteState(SharedData data, ShadowNodeFamily::Weak family)
+      : State(std::move(data), std::move(family)) {}
 
   ~ConcreteState() override = default;
 
@@ -109,7 +107,7 @@ class ConcreteState : public State {
     family->dispatchRawState(std::move(stateUpdate));
   }
 
-#ifdef ANDROID
+#if defined(RN_SERIALIZABLE_STATE)
   folly::dynamic getDynamic() const override {
     return getData().getDynamic();
   }

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

@@ -98,6 +98,7 @@ void EventEmitter::dispatchEvent(
       normalizeEventType(std::move(type)),
       std::move(payload),
       eventTarget_,
+      shadowNodeFamily_,
       category));
 }
 
@@ -123,6 +124,7 @@ void EventEmitter::dispatchUniqueEvent(
       normalizeEventType(std::move(type)),
       std::move(payload),
       eventTarget_,
+      shadowNodeFamily_,
       RawEvent::Category::Continuous));
 }
 
@@ -149,6 +151,11 @@ void EventEmitter::setEnabled(bool enabled) const {
   }
 }
 
+void EventEmitter::setShadowNodeFamily(
+    std::weak_ptr<const ShadowNodeFamily> shadowNodeFamily) const {
+  shadowNodeFamily_ = std::move(shadowNodeFamily);
+}
+
 const SharedEventTarget& EventEmitter::getEventTarget() const {
   return eventTarget_;
 }

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

@@ -57,6 +57,12 @@ class EventEmitter {
    */
   void setEnabled(bool enabled) const;
 
+  /*
+   * Sets a weak reference to the cooresponding ShadowNodeFamily
+   */
+  void setShadowNodeFamily(
+      std::weak_ptr<const ShadowNodeFamily> shadowNodeFamily) const;
+
   const SharedEventTarget& getEventTarget() const;
 
   /*
@@ -106,6 +112,7 @@ class EventEmitter {
   friend class UIManagerBinding;
 
   mutable SharedEventTarget eventTarget_;
+  mutable std::weak_ptr<const ShadowNodeFamily> shadowNodeFamily_;
 
   EventDispatcher::Weak eventDispatcher_;
   mutable int enableCounter_{0};

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

@@ -9,6 +9,8 @@
 
 #include <react/renderer/core/EventTarget.h>
 #include <react/timing/primitives.h>
+
+#include <optional>
 #include <string_view>
 
 namespace facebook::react {
@@ -32,8 +34,7 @@ class EventLogger {
   virtual EventTag onEventStart(
       std::string_view name,
       SharedEventTarget target,
-      DOMHighResTimeStamp eventStartTimeStamp =
-          DOM_HIGH_RES_TIME_STAMP_UNSET) = 0;
+      std::optional<HighResTimeStamp> eventStartTimeStamp = std::nullopt) = 0;
 
   /*
    * Called when event starts getting dispatched (processed by the handlers, if

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

@@ -32,6 +32,28 @@ LayoutableShadowNode::LayoutableShadowNode(
       layoutMetrics_(static_cast<const LayoutableShadowNode&>(sourceShadowNode)
                          .layoutMetrics_) {}
 
+LayoutMetrics LayoutableShadowNode::computeLayoutMetricsFromRoot(
+    const ShadowNodeFamily& descendantNodeFamily,
+    const LayoutableShadowNode& rootNode,
+    LayoutInspectingPolicy policy) {
+  // Prelude.
+
+  if (&descendantNodeFamily == &rootNode.getFamily()) {
+    // If calculating layout for root node
+    auto layoutMetrics = rootNode.getLayoutMetrics();
+    if (layoutMetrics.displayType == DisplayType::None) {
+      return EmptyLayoutMetrics;
+    }
+    if (policy.includeTransform) {
+      layoutMetrics.frame = layoutMetrics.frame * rootNode.getTransform();
+    }
+    return layoutMetrics;
+  }
+
+  auto ancestors = descendantNodeFamily.getAncestors(rootNode);
+  return computeRelativeLayoutMetrics(ancestors, policy);
+}
+
 LayoutMetrics LayoutableShadowNode::computeRelativeLayoutMetrics(
     const ShadowNodeFamily& descendantNodeFamily,
     const LayoutableShadowNode& ancestorNode,
@@ -246,8 +268,8 @@ Float LayoutableShadowNode::baseline(
   return 0;
 }
 
-ShadowNode::Shared LayoutableShadowNode::findNodeAtPoint(
-    const ShadowNode::Shared& node,
+std::shared_ptr<const ShadowNode> LayoutableShadowNode::findNodeAtPoint(
+    const std::shared_ptr<const ShadowNode>& node,
     Point point) {
   auto layoutableShadowNode =
       dynamic_cast<const LayoutableShadowNode*>(node.get());

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

@@ -47,6 +47,16 @@ class LayoutableShadowNode : public ShadowNode {
 
   using UnsharedList = std::vector<LayoutableShadowNode*>;
 
+  /*
+   * Returns layout metrics of a node represented as `descendantNodeFamily`
+   * from `rootNode` like `computeRelativeLayoutMetrics` but returns absolute
+   * transform for node if used as root.
+   */
+  static LayoutMetrics computeLayoutMetricsFromRoot(
+      const ShadowNodeFamily& descendantNodeFamily,
+      const LayoutableShadowNode& rootNode,
+      LayoutInspectingPolicy policy);
+
   /*
    * Returns layout metrics of a node represented as `descendantNodeFamily`
    * computed relatively to given `ancestorNode`. Returns `EmptyLayoutMetrics`
@@ -137,8 +147,8 @@ class LayoutableShadowNode : public ShadowNode {
    * Returns the ShadowNode that is rendered at the Point received as a
    * parameter.
    */
-  static ShadowNode::Shared findNodeAtPoint(
-      const ShadowNode::Shared& node,
+  static std::shared_ptr<const ShadowNode> findNodeAtPoint(
+      const std::shared_ptr<const ShadowNode>& node,
       Point point);
 
   /*
@@ -146,7 +156,6 @@ class LayoutableShadowNode : public ShadowNode {
    * Indicates whether all nodes (and possibly their subtrees) along the path
    * to the root node should be re-laid out.
    */
-  virtual void cleanLayout() = 0;
   virtual void dirtyLayout() = 0;
   virtual bool getIsLayoutClean() const = 0;
 

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

@@ -32,7 +32,7 @@ void Props::initialize(
   nativeId = ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
       ? sourceProps.nativeId
       : convertRawProp(context, rawProps, "nativeID", sourceProps.nativeId, {});
-#ifdef ANDROID
+#ifdef RN_SERIALIZABLE_STATE
   if (ReactNativeFeatureFlags::enableAccumulatedUpdatesInRawPropsAndroid()) {
     auto& oldRawProps = sourceProps.rawProps;
     auto newRawProps = rawProps.toDynamic(filterObjectKeys);

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

@@ -63,13 +63,16 @@ class Props : public virtual Sealable, public virtual DebugStringConvertible {
 
   std::string nativeId;
 
-#ifdef ANDROID
+#ifdef RN_SERIALIZABLE_STATE
   folly::dynamic rawProps = folly::dynamic::object();
 
+  virtual ComponentName getDiffPropsImplementationTarget() const {
+    return "";
+  }
+
   virtual folly::dynamic getDiffProps(const Props* prevProps) const {
     return folly::dynamic::object();
   }
-
 #endif
 
 #if RN_DEBUG_STRING_CONVERTIBLE

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

@@ -13,11 +13,13 @@ RawEvent::RawEvent(
     std::string type,
     SharedEventPayload eventPayload,
     SharedEventTarget eventTarget,
+    std::weak_ptr<const ShadowNodeFamily> shadowNodeFamily,
     Category category,
     bool isUnique)
     : type(std::move(type)),
       eventPayload(std::move(eventPayload)),
       eventTarget(std::move(eventTarget)),
+      shadowNodeFamily(std::move(shadowNodeFamily)),
       category(category),
       isUnique(isUnique) {}
 

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

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <memory>
+#include <optional>
 #include <string>
 
 #include <react/renderer/core/EventLogger.h>
@@ -17,6 +18,8 @@
 
 namespace facebook::react {
 
+class ShadowNodeFamily;
+
 /*
  * Represents ready-to-dispatch event object.
  */
@@ -69,12 +72,14 @@ struct RawEvent {
       std::string type,
       SharedEventPayload eventPayload,
       SharedEventTarget eventTarget,
+      std::weak_ptr<const ShadowNodeFamily> shadowNodeFamily,
       Category category = Category::Unspecified,
       bool isUnique = false);
 
   std::string type;
   SharedEventPayload eventPayload;
   SharedEventTarget eventTarget;
+  std::weak_ptr<const ShadowNodeFamily> shadowNodeFamily;
   Category category;
   EventTag loggingTag{0};
   bool isUnique{false};
@@ -82,7 +87,7 @@ struct RawEvent {
   // The client may specify a platform-specific timestamp for the event start
   // time, for example when MotionEvent was triggered on the Android native
   // side.
-  DOMHighResTimeStamp eventStartTimeStamp{DOM_HIGH_RES_TIME_STAMP_UNSET};
+  std::optional<HighResTimeStamp> eventStartTimeStamp = std::nullopt;
 };
 
 } // namespace facebook::react

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

@@ -35,7 +35,7 @@ thread_local bool useRuntimeShadowNodeReferenceUpdateOnThread{false}; // NOLINT
 
 ShadowNode::SharedListOfShared ShadowNode::emptySharedShadowNodeSharedList() {
   static const auto emptySharedShadowNodeSharedList =
-      std::make_shared<ShadowNode::ListOfShared>();
+      std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>();
   return emptySharedShadowNodeSharedList;
 }
 
@@ -50,7 +50,7 @@ ShadowNode::SharedListOfShared ShadowNode::emptySharedShadowNodeSharedList() {
 Props::Shared ShadowNode::propsForClonedShadowNode(
     const ShadowNode& sourceShadowNode,
     const Props::Shared& props) {
-#ifdef ANDROID
+#ifdef RN_SERIALIZABLE_STATE
   bool hasBeenMounted = sourceShadowNode.hasBeenMounted_;
   bool sourceNodeHasRawProps = !sourceShadowNode.getProps()->rawProps.empty();
   if (!hasBeenMounted && sourceNodeHasRawProps && props) {
@@ -96,6 +96,8 @@ ShadowNode::ShadowNode(
     child->family_->setParent(family_);
   }
 
+  updateTraitsIfNeccessary();
+
   // The first node of the family gets its state committed automatically.
   family_->setMostRecentState(state_);
 }
@@ -130,10 +132,11 @@ ShadowNode::ShadowNode(
     for (const auto& child : *children_) {
       child->family_->setParent(family_);
     }
+    updateTraitsIfNeccessary();
   }
 }
 
-ShadowNode::Unshared ShadowNode::clone(
+std::shared_ptr<ShadowNode> ShadowNode::clone(
     const ShadowNodeFragment& fragment) const {
   const auto& family = *family_;
   const auto& componentDescriptor = family.componentDescriptor_;
@@ -174,7 +177,8 @@ ComponentHandle ShadowNode::getComponentHandle() const {
   return family_->getComponentHandle();
 }
 
-const ShadowNode::ListOfShared& ShadowNode::getChildren() const {
+const std::vector<std::shared_ptr<const ShadowNode>>& ShadowNode::getChildren()
+    const {
   return *children_;
 }
 
@@ -191,12 +195,7 @@ const SharedEventEmitter& ShadowNode::getEventEmitter() const {
 }
 
 jsi::Value ShadowNode::getInstanceHandle(jsi::Runtime& runtime) const {
-  auto instanceHandle = family_->instanceHandle_;
-  if (instanceHandle == nullptr) {
-    return jsi::Value::null();
-  }
-
-  return instanceHandle->getInstanceHandle(runtime);
+  return family_->getInstanceHandle(runtime);
 }
 
 Tag ShadowNode::getTag() const {
@@ -239,26 +238,29 @@ void ShadowNode::sealRecursive() const {
 
 #pragma mark - Mutating Methods
 
-void ShadowNode::appendChild(const ShadowNode::Shared& child) {
+void ShadowNode::appendChild(const std::shared_ptr<const ShadowNode>& child) {
   ensureUnsealed();
 
   cloneChildrenIfShared();
-  auto& children = const_cast<ShadowNode::ListOfShared&>(*children_);
+  auto& children =
+      const_cast<std::vector<std::shared_ptr<const ShadowNode>>&>(*children_);
   children.push_back(child);
 
   child->family_->setParent(family_);
+  updateTraitsIfNeccessary();
 }
 
 void ShadowNode::replaceChild(
     const ShadowNode& oldChild,
-    const ShadowNode::Shared& newChild,
+    const std::shared_ptr<const ShadowNode>& newChild,
     size_t suggestedIndex) {
   ensureUnsealed();
 
   cloneChildrenIfShared();
   newChild->family_->setParent(family_);
 
-  auto& children = const_cast<ShadowNode::ListOfShared&>(*children_);
+  auto& children =
+      const_cast<std::vector<std::shared_ptr<const ShadowNode>>&>(*children_);
   auto size = children.size();
 
   if (suggestedIndex != std::numeric_limits<size_t>::max() &&
@@ -279,6 +281,7 @@ void ShadowNode::replaceChild(
   }
 
   react_native_assert(false && "Child to replace was not found.");
+  updateTraitsIfNeccessary();
 }
 
 void ShadowNode::cloneChildrenIfShared() {
@@ -287,7 +290,27 @@ void ShadowNode::cloneChildrenIfShared() {
   }
 
   traits_.unset(ShadowNodeTraits::Trait::ChildrenAreShared);
-  children_ = std::make_shared<ShadowNode::ListOfShared>(*children_);
+  children_ = std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>(
+      *children_);
+}
+
+void ShadowNode::updateTraitsIfNeccessary() {
+  if (ReactNativeFeatureFlags::enableViewCulling()) {
+    if (traits_.check(ShadowNodeTraits::Trait::Unstable_uncullableView)) {
+      return;
+    }
+
+    for (const auto& child : *children_) {
+      if (child->getTraits().check(
+              ShadowNodeTraits::Trait::Unstable_uncullableView) ||
+          child->getTraits().check(
+              ShadowNodeTraits::Trait::Unstable_uncullableTrace)) {
+        traits_.set(ShadowNodeTraits::Trait::Unstable_uncullableTrace);
+        return;
+      }
+    }
+    traits_.unset(ShadowNodeTraits::Trait::Unstable_uncullableTrace);
+  }
 }
 
 void ShadowNode::setMounted(bool mounted) const {
@@ -311,14 +334,14 @@ void ShadowNode::setRuntimeShadowNodeReference(
 }
 
 void ShadowNode::updateRuntimeShadowNodeReference(
-    const Shared& destinationShadowNode) const {
+    const std::shared_ptr<const ShadowNode>& destinationShadowNode) const {
   if (auto reference = runtimeShadowNodeReference_.lock()) {
     reference->shadowNode = destinationShadowNode;
   }
 }
 
 void ShadowNode::transferRuntimeShadowNodeReference(
-    const Shared& destinationShadowNode) const {
+    const std::shared_ptr<const ShadowNode>& destinationShadowNode) const {
   destinationShadowNode->runtimeShadowNodeReference_ =
       runtimeShadowNodeReference_;
 
@@ -328,7 +351,7 @@ void ShadowNode::transferRuntimeShadowNodeReference(
 }
 
 void ShadowNode::transferRuntimeShadowNodeReference(
-    const Shared& destinationShadowNode,
+    const std::shared_ptr<const ShadowNode>& destinationShadowNode,
     const ShadowNodeFragment& fragment) const {
   if ((ReactNativeFeatureFlags::updateRuntimeShadowNodeReferencesOnCommit() ||
        useRuntimeShadowNodeReferenceUpdateOnThread) &&
@@ -341,14 +364,18 @@ const ShadowNodeFamily& ShadowNode::getFamily() const {
   return *family_;
 }
 
-ShadowNode::Unshared ShadowNode::cloneTree(
+ShadowNodeFamily::Shared ShadowNode::getFamilyShared() const {
+  return family_;
+}
+
+std::shared_ptr<ShadowNode> ShadowNode::cloneTree(
     const ShadowNodeFamily& shadowNodeFamily,
-    const std::function<ShadowNode::Unshared(const ShadowNode& oldShadowNode)>&
-        callback) const {
+    const std::function<std::shared_ptr<ShadowNode>(
+        const ShadowNode& oldShadowNode)>& callback) const {
   auto ancestors = shadowNodeFamily.getAncestors(*this);
 
   if (ancestors.empty()) {
-    return ShadowNode::Unshared{nullptr};
+    return std::shared_ptr<ShadowNode>{nullptr};
   }
 
   auto& parent = ancestors.back();
@@ -372,12 +399,89 @@ ShadowNode::Unshared ShadowNode::cloneTree(
     children[childIndex] = childNode;
 
     childNode = parentNode.clone(
-        {.children = std::make_shared<ShadowNode::ListOfShared>(children)});
+        {.children =
+             std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>(
+                 children)});
   }
 
   return std::const_pointer_cast<ShadowNode>(childNode);
 }
 
+namespace {
+
+std::shared_ptr<ShadowNode> cloneMultipleRecursive(
+    const ShadowNode& shadowNode,
+    const std::unordered_set<const ShadowNodeFamily*>& familiesToUpdate,
+    const std::unordered_map<const ShadowNodeFamily*, 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);
+
+  for (int i = 0; count > 0 && i < children.size(); i++) {
+    const auto childFamily = &children[i]->getFamily();
+    if (childrenCount.contains(childFamily)) {
+      count--;
+      if (!newChildren) {
+        newChildren =
+            std::make_shared<std::vector<std::shared_ptr<const ShadowNode>>>(
+                children);
+      }
+      (*newChildren)[i] = cloneMultipleRecursive(
+          *children[i], familiesToUpdate, childrenCount, callback);
+    }
+  }
+
+  ShadowNodeFragment fragment{.children = newChildren};
+  if (familiesToUpdate.contains(family)) {
+    return callback(shadowNode, fragment);
+  }
+  return shadowNode.clone(fragment);
+}
+
+} // namespace
+
+std::shared_ptr<ShadowNode> ShadowNode::cloneMultiple(
+    const std::unordered_set<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;
+
+  for (const auto& family : familiesToUpdate) {
+    if (childrenCount.contains(family)) {
+      continue;
+    }
+
+    childrenCount[family] = 0;
+
+    auto ancestor = family->parent_.lock();
+    while ((ancestor != nullptr) && ancestor != family_) {
+      auto ancestorIt = childrenCount.find(ancestor.get());
+      if (ancestorIt != childrenCount.end()) {
+        ancestorIt->second++;
+        break;
+      }
+      childrenCount[ancestor.get()] = 1;
+
+      ancestor = ancestor->parent_.lock();
+    }
+
+    if (ancestor == family_) {
+      childrenCount[ancestor.get()]++;
+    }
+  }
+
+  if (childrenCount.empty()) {
+    return nullptr;
+  }
+
+  return cloneMultipleRecursive(
+      *this, familiesToUpdate, childrenCount, callback);
+}
+
 #pragma mark - DebugStringConvertible
 
 #if RN_DEBUG_STRING_CONVERTIBLE