react-native 0.71.4 → 0.72.0-rc.0

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

@@ -11,8 +11,9 @@
 #include <react/renderer/core/LayoutContext.h>
 #include <react/renderer/core/LayoutMetrics.h>
 #include <react/renderer/core/ShadowNode.h>
+#include <react/renderer/core/TraitCast.h>
+#include <react/renderer/core/graphicsConversions.h>
 #include <react/renderer/debug/DebugStringConvertibleItem.h>
-#include <react/renderer/graphics/conversions.h>
 
 namespace facebook::react {
 
@@ -93,6 +94,9 @@ LayoutMetrics LayoutableShadowNode::computeRelativeLayoutMetrics(
     // Layout metrics of a node computed relatively to the same node are equal
     // to `transform`-ed layout metrics of the node with zero `origin`.
     auto layoutMetrics = ancestorNode.getLayoutMetrics();
+    if (layoutMetrics.displayType == DisplayType::None) {
+      return EmptyLayoutMetrics;
+    }
     if (policy.includeTransform) {
       layoutMetrics.frame = layoutMetrics.frame * ancestorNode.getTransform();
     }
@@ -180,6 +184,12 @@ LayoutMetrics LayoutableShadowNode::computeRelativeLayoutMetrics(
       return EmptyLayoutMetrics;
     }
 
+    // Descendants of display: none don't have relative layout metrics.
+    if (currentShadowNode->getLayoutMetrics().displayType ==
+        DisplayType::None) {
+      return EmptyLayoutMetrics;
+    }
+
     auto currentFrame = shouldCalculateTransformedFrames
         ? transformedFrames[i]
         : currentShadowNode->getLayoutMetrics().frame;
@@ -212,10 +222,14 @@ LayoutMetrics LayoutableShadowNode::computeRelativeLayoutMetrics(
 
 ShadowNodeTraits LayoutableShadowNode::BaseTraits() {
   auto traits = ShadowNodeTraits{};
-  traits.set(ShadowNodeTraits::Trait::LayoutableKind);
+  traits.set(IdentifierTrait());
   return traits;
 }
 
+ShadowNodeTraits::Trait LayoutableShadowNode::IdentifierTrait() {
+  return ShadowNodeTraits::Trait::LayoutableKind;
+}
+
 LayoutMetrics LayoutableShadowNode::getLayoutMetrics() const {
   return layoutMetrics_;
 }

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

@@ -18,7 +18,6 @@
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/core/ShadowNodeFragment.h>
 #include <react/renderer/debug/DebugStringConvertible.h>
-#include <react/renderer/graphics/Geometry.h>
 #include <react/renderer/graphics/Transform.h>
 
 namespace facebook {
@@ -43,6 +42,7 @@ class LayoutableShadowNode : public ShadowNode {
       ShadowNodeFragment const &fragment);
 
   static ShadowNodeTraits BaseTraits();
+  static ShadowNodeTraits::Trait IdentifierTrait();
 
   struct LayoutInspectingPolicy {
     bool includeTransform{true};
@@ -152,7 +152,7 @@ class LayoutableShadowNode : public ShadowNode {
   virtual Float lastBaseline(Size size) const;
 
   /*
-   * Returns layoutable children to interate on.
+   * Returns layoutable children to iterate on.
    */
   LayoutableShadowNode::UnsharedList getLayoutableChildNodes() const;
 
@@ -165,29 +165,5 @@ class LayoutableShadowNode : public ShadowNode {
   LayoutMetrics layoutMetrics_;
 };
 
-template <>
-inline LayoutableShadowNode const &traitCast<LayoutableShadowNode const &>(
-    ShadowNode const &shadowNode) {
-  bool castable =
-      shadowNode.getTraits().check(ShadowNodeTraits::Trait::LayoutableKind);
-  react_native_assert(castable);
-  (void)castable;
-  return static_cast<LayoutableShadowNode const &>(shadowNode);
-}
-
-template <>
-inline LayoutableShadowNode const *traitCast<LayoutableShadowNode const *>(
-    ShadowNode const *shadowNode) {
-  if (!shadowNode) {
-    return nullptr;
-  }
-  bool castable =
-      shadowNode->getTraits().check(ShadowNodeTraits::Trait::LayoutableKind);
-  if (!castable) {
-    return nullptr;
-  }
-  return static_cast<LayoutableShadowNode const *>(shadowNode);
-}
-
 } // namespace react
 } // namespace facebook

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

@@ -31,15 +31,15 @@
 // Convenience for building setProps switch statements.
 // This injects `fromRawValue` into source; each file that uses
 // this macro must import the proper, respective headers required.
-#define RAW_SET_PROP_SWITCH_CASE(field, jsPropName, defaultValue) \
-  case CONSTEXPR_RAW_PROPS_KEY_HASH(jsPropName):                  \
-    fromRawValue(context, value, field, defaultValue);            \
+#define RAW_SET_PROP_SWITCH_CASE(field, jsPropName)      \
+  case CONSTEXPR_RAW_PROPS_KEY_HASH(jsPropName):         \
+    fromRawValue(context, value, field, defaults.field); \
     return;
 
 // Convenience for building setProps switch statements where the field name is
 // the same as the string identifier
-#define RAW_SET_PROP_SWITCH_CASE_BASIC(field, defaultValue) \
-  RAW_SET_PROP_SWITCH_CASE(field, #field, defaultValue)
+#define RAW_SET_PROP_SWITCH_CASE_BASIC(field) \
+  RAW_SET_PROP_SWITCH_CASE(field, #field)
 
 #define CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(         \
     struct, field, fieldNameString, value)              \
@@ -71,7 +71,15 @@
   CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
       struct, bottomEnd, prefix "BottomEnd" suffix, rawValue)            \
   CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
-      struct, all, prefix "" suffix, rawValue)
+      struct, all, prefix "" suffix, rawValue)                           \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
+      struct, endEnd, prefix "EndEnd" suffix, rawValue)                  \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
+      struct, endStart, prefix "EndStart" suffix, rawValue)              \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
+      struct, startEnd, prefix "StartEnd" suffix, rawValue)              \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
+      struct, startStart, prefix "StartStart" suffix, rawValue)
 
 #define SET_CASCADED_RECTANGLE_EDGES(struct, prefix, suffix, rawValue) \
   CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
@@ -91,7 +99,13 @@
   CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
       struct, vertical, prefix "Vertical" suffix, rawValue)            \
   CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
-      struct, all, prefix "" suffix, rawValue)
+      struct, all, prefix "" suffix, rawValue)                         \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
+      struct, block, prefix "Block" suffix, rawValue)                  \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
+      struct, blockEnd, prefix "BlockEnd" suffix, rawValue)            \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
+      struct, blockStart, prefix "BlockStart" suffix, rawValue)
 
 // Rebuild a type that contains multiple fields from a single field value
 #define REBUILD_FIELD_SWITCH_CASE(                  \

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

@@ -8,12 +8,11 @@
 #include "PropsMapBuffer.h"
 #include "Props.h"
 
-#include <react/renderer/mapbuffer/MapBufferBuilder.h>
+#ifdef ANDROID
 
 namespace facebook {
 namespace react {
 
-#ifdef ANDROID
 void Props::propsDiffMapBuffer(
     Props const *oldPropsPtr,
     MapBufferBuilder &builder) const {
@@ -31,7 +30,7 @@ void Props::propsDiffMapBuffer(
     builder.putString(PROPS_NATIVE_ID, nativeId);
   }
 }
-#endif
 
 } // namespace react
 } // namespace facebook
+#endif

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

@@ -10,6 +10,7 @@
 #ifdef ANDROID
 
 #include <react/renderer/mapbuffer/MapBuffer.h>
+#include <react/renderer/mapbuffer/MapBufferBuilder.h>
 
 namespace facebook {
 namespace react {

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

@@ -10,6 +10,7 @@
 #include <memory>
 #include <string>
 
+#include <react/renderer/core/EventLogger.h>
 #include <react/renderer/core/EventTarget.h>
 #include <react/renderer/core/ValueFactory.h>
 
@@ -68,6 +69,7 @@ struct RawEvent {
   ValueFactory payloadFactory;
   SharedEventTarget eventTarget;
   Category category;
+  EventTag loggingTag{0};
 };
 
 } // namespace react

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

@@ -138,7 +138,7 @@ class RawProps final {
       small_vector<RawPropsValueIndex, kNumberOfPropsPerComponentSoftCap>
           keyIndexToValueIndex_;
   mutable butter::
-      small_vector<RawValue, kNumberOfExplicitlySpecifedPropsSoftCap>
+      small_vector<RawValue, kNumberOfExplicitlySpecifiedPropsSoftCap>
           values_;
 };
 

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

@@ -55,7 +55,7 @@ class RawPropsKeyMap final {
       Item const &rhs) noexcept;
   static bool hasSameName(Item const &lhs, Item const &rhs) noexcept;
 
-  butter::small_vector<Item, kNumberOfExplicitlySpecifedPropsSoftCap> items_{};
+  butter::small_vector<Item, kNumberOfExplicitlySpecifiedPropsSoftCap> items_{};
   butter::small_vector<RawPropsPropNameLength, kPropNameLengthHardCap>
       buckets_{};
 };

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

@@ -27,7 +27,7 @@ using RawPropsPropNameHash = uint32_t;
  * The number which is *usually* bigger than a number of explicitly specified
  * props for some component.
  */
-constexpr static int kNumberOfExplicitlySpecifedPropsSoftCap = 16;
+constexpr static int kNumberOfExplicitlySpecifiedPropsSoftCap = 16;
 
 /*
  * Special value of `RawPropsValueIndex` which is used to represent `no value`.

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

@@ -26,7 +26,7 @@ namespace react {
  * even if they are explicitly marked as `const`. It means that in some special
  * cases those objects can be const-casted-away and then mutated. That comes
  * from the fact that we share some object's life-cycle responsibilities with
- * React and the immutability is guaranteed by some logic splitted between
+ * React and the immutability is guaranteed by some logic split between
  * native and JavaScript worlds (which makes it impossible to fully use
  * immutability enforcement at a language level). To detect possible errors as
  * early as possible we additionally mark objects as *sealed* after some stages
@@ -70,7 +70,7 @@ class Sealable {
 
   /*
    * Seals the object. This operation is irreversible;
-   * the object cannot be "unsealed" after being sealing.
+   * the object cannot be "unsealed" after being sealed.
    */
   void seal() const;
 

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

@@ -117,7 +117,31 @@ ShadowNode::ShadowNode(
 
 ShadowNode::Unshared ShadowNode::clone(
     const ShadowNodeFragment &fragment) const {
-  return family_->componentDescriptor_.cloneShadowNode(*this, fragment);
+  auto const &family = *family_;
+  auto const &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,
+              fragment.children,
+              fragment.state,
+          });
+      return clonedNode;
+    } else {
+      // TODO: We might need to merge fragment.priops with
+      // `family.nativeProps_DEPRECATED`.
+      return componentDescriptor.cloneShadowNode(*this, fragment);
+    }
+  } else {
+    return componentDescriptor.cloneShadowNode(*this, fragment);
+  }
 }
 
 ContextContainer::Shared ShadowNode::getContextContainer() const {
@@ -204,7 +228,7 @@ void ShadowNode::appendChild(const ShadowNode::Shared &child) {
 void ShadowNode::replaceChild(
     ShadowNode const &oldChild,
     ShadowNode::Shared const &newChild,
-    int suggestedIndex) {
+    size_t suggestedIndex) {
   ensureUnsealed();
 
   cloneChildrenIfShared();
@@ -215,7 +239,7 @@ void ShadowNode::replaceChild(
       *std::const_pointer_cast<ShadowNode::ListOfShared>(children_);
   auto size = children.size();
 
-  if (suggestedIndex != -1 && static_cast<size_t>(suggestedIndex) < size) {
+  if (suggestedIndex != -1 && suggestedIndex < size) {
     // If provided `suggestedIndex` is accurate,
     // replacing in place using the index.
     if (children.at(suggestedIndex).get() == &oldChild) {

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

@@ -29,7 +29,9 @@ static constexpr const int kShadowNodeChildrenSmallVectorSize = 8;
 class ComponentDescriptor;
 struct ShadowNodeFragment;
 
-class ShadowNode : public Sealable, public DebugStringConvertible {
+class ShadowNode : public Sealable,
+                   public DebugStringConvertible,
+                   public jsi::NativeState {
  public:
   using Shared = std::shared_ptr<ShadowNode const>;
   using Weak = std::weak_ptr<ShadowNode const>;
@@ -161,11 +163,11 @@ class ShadowNode : public Sealable, public DebugStringConvertible {
 
 #pragma mark - Mutating Methods
 
-  void appendChild(Shared const &child);
-  void replaceChild(
+  virtual void appendChild(Shared const &child);
+  virtual void replaceChild(
       ShadowNode const &oldChild,
       Shared const &newChild,
-      int suggestedIndex = -1);
+      size_t suggestedIndex = -1);
 
   /*
    * Performs all side effects associated with mounting/unmounting in one place.
@@ -224,21 +226,5 @@ class ShadowNode : public Sealable, public DebugStringConvertible {
   ShadowNodeTraits traits_;
 };
 
-/*
- * Template declarations for future specializations in concrete classes.
- * `traitCast` checks for a trait that corresponds to the provided type and
- * performs `static_cast`. Practically, the behavior is identical to
- * `dynamic_cast` with very little runtime overhead.
- */
-template <typename ShadowNodeReferenceT>
-ShadowNodeReferenceT traitCast(ShadowNode const &shadowNode);
-
-template <typename ShadowNodePointerT>
-ShadowNodePointerT traitCast(ShadowNode const *shadowNode);
-
-template <typename ShadowNodePointerT>
-std::shared_ptr<ShadowNodePointerT const> traitCast(
-    std::shared_ptr<ShadowNode const> shadowNode);
-
 } // namespace react
 } // namespace facebook

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

@@ -97,12 +97,12 @@ AncestorList ShadowNodeFamily::getAncestors(
 }
 
 State::Shared ShadowNodeFamily::getMostRecentState() const {
-  std::unique_lock<butter::shared_mutex> lock(mutex_);
+  std::unique_lock lock(mutex_);
   return mostRecentState_;
 }
 
 void ShadowNodeFamily::setMostRecentState(State::Shared const &state) const {
-  std::unique_lock<butter::shared_mutex> lock(mutex_);
+  std::unique_lock lock(mutex_);
 
   /*
    * Checking and setting `isObsolete_` prevents old states to be recommitted
@@ -123,7 +123,7 @@ void ShadowNodeFamily::setMostRecentState(State::Shared const &state) const {
 
 std::shared_ptr<State const> ShadowNodeFamily::getMostRecentStateIfObsolete(
     State const &state) const {
-  std::unique_lock<butter::shared_mutex> lock(mutex_);
+  std::unique_lock lock(mutex_);
   if (!state.isObsolete_) {
     return {};
   }

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

@@ -8,8 +8,8 @@
 #pragma once
 
 #include <memory>
+#include <shared_mutex>
 
-#include <butter/mutex.h>
 #include <butter/small_vector.h>
 
 #include <react/renderer/core/EventEmitter.h>
@@ -86,6 +86,13 @@ class ShadowNodeFamily final {
   void dispatchRawState(StateUpdate &&stateUpdate, EventPriority priority)
       const;
 
+  /*
+   * Holds currently applied native props. `nullptr` if setNativeProps API is
+   * not used. It is used to backport setNativeProps API from the old
+   * architecture and will be removed in the future.
+   */
+  mutable std::unique_ptr<folly::dynamic> nativeProps_DEPRECATED;
+
  private:
   friend ShadowNode;
   friend ShadowNodeFamilyFragment;
@@ -101,7 +108,7 @@ class ShadowNodeFamily final {
 
   EventDispatcher::Weak eventDispatcher_;
   mutable std::shared_ptr<State const> mostRecentState_;
-  mutable butter::shared_mutex mutex_;
+  mutable std::shared_mutex mutex_;
 
   /*
    * Deprecated.

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

@@ -92,17 +92,8 @@ class ShadowNodeTraits {
     // Temporary (?) to indicate MapBuffer support on Android
     AndroidMapBufferPropsSupported = 1 << 15,
 
-    // Reserved
-    ReservedTrait0 = 1 << 16,
-    ReservedTrait1 = 1 << 17,
-    ReservedTrait2 = 1 << 18,
-    ReservedTrait3 = 1 << 19,
-    ReservedTrait4 = 1 << 20,
-    ReservedTrait5 = 1 << 21,
-    ReservedTrait6 = 1 << 22,
-
-    // Unserved - alias these for local usage
-    UnreservedTrait1 = 1 << 23
+    // Inherits 'ArtBaseShadowNode' (previously built into RN)
+    Art = 1 << 16,
   };
 
   /*
@@ -120,6 +111,10 @@ class ShadowNodeTraits {
     return ShadowNodeTraits::Trait(traits_ & traits) == traits;
   }
 
+  inline Trait get() const {
+    return traits_;
+  }
+
  private:
   Trait traits_{Trait::None};
 };

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

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <glog/logging.h>
+#include <react/renderer/core/ShadowNode.h>
+#include <memory>
+
+namespace facebook::react::details {
+template <typename ShadowNodePointerT, typename ParamT>
+ShadowNodePointerT traitCastPointer(ParamT shadowNode) {
+  auto expectedIdentifier =
+      std::remove_pointer_t<ShadowNodePointerT>::IdentifierTrait();
+  if (!shadowNode || !shadowNode->getTraits().check(expectedIdentifier)) {
+    return nullptr;
+  }
+
+  return static_cast<ShadowNodePointerT>(shadowNode);
+}
+
+template <typename ShadowNodeRefT, typename ParamT>
+ShadowNodeRefT traitCastRef(ParamT &&shadowNode) {
+  auto expectedIdentifier =
+      std::remove_reference_t<ShadowNodeRefT>::IdentifierTrait();
+  if (!shadowNode.getTraits().check(expectedIdentifier)) {
+    LOG(FATAL) << "Invalid ShadowNode cast\n"
+               << "Expected identifier: " << std::hex
+               << static_cast<int32_t>(expectedIdentifier) << "\n"
+               << "Actual traits: " << std::hex
+               << static_cast<int32_t>(shadowNode.getTraits().get()) << "\n";
+  }
+
+  return static_cast<ShadowNodeRefT>(shadowNode);
+}
+
+template <typename ShadowNodeT, typename ParamT>
+std::shared_ptr<ShadowNodeT> traitCastShared(
+    const std::shared_ptr<ParamT> &shadowNode) {
+  auto expectedIdentifier = ShadowNodeT::IdentifierTrait();
+  if (!shadowNode || !shadowNode->getTraits().check(expectedIdentifier)) {
+    return nullptr;
+  }
+
+  return std::static_pointer_cast<ShadowNodeT>(shadowNode);
+}
+} // namespace facebook::react::details
+
+namespace facebook::react {
+
+// Cast from one ShadowNode reference to another, terminating if the cast is
+// invalid.
+template <typename ShadowNodeReferenceT>
+ShadowNodeReferenceT traitCast(ShadowNode const &shadowNode) {
+  return details::traitCastRef<ShadowNodeReferenceT>(shadowNode);
+}
+template <typename ShadowNodeReferenceT>
+ShadowNodeReferenceT traitCast(ShadowNode &shadowNode) {
+  return details::traitCastRef<ShadowNodeReferenceT>(shadowNode);
+}
+
+// Cast from one ShadowNode pointer to another, returning nullptr if the cast is
+// invalid.
+template <typename ShadowNodePointerT>
+ShadowNodePointerT traitCast(ShadowNode const *shadowNode) {
+  return details::traitCastPointer<ShadowNodePointerT>(shadowNode);
+}
+template <typename ShadowNodePointerT>
+ShadowNodePointerT traitCast(ShadowNode *shadowNode) {
+  return details::traitCastPointer<ShadowNodePointerT>(shadowNode);
+}
+
+// Cast from one ShadowNode shared_ptr to another, returning nullptr if the
+// cast is invalid.
+template <typename ShadowNodeT, typename ParamT>
+std::shared_ptr<ShadowNodeT> traitCast(
+    const std::shared_ptr<ParamT> &shadowNode) {
+  return details::traitCastShared<ShadowNodeT>(shadowNode);
+}
+template <typename ShadowNodeT, typename ParamT>
+std::shared_ptr<ShadowNodeT const> traitCast(
+    const std::shared_ptr<ParamT const> &shadowNode) {
+  return details::traitCastShared<ShadowNodeT const>(shadowNode);
+}
+
+} // namespace facebook::react