@depup/react-native 0.86.2-depup.0 → 0.87.0-depup.0

package/ReactCommon/react/renderer/components/view/YogaLayoutableShadowNode.cpp

@@ -100,27 +100,23 @@ YogaLayoutableShadowNode::YogaLayoutableShadowNode(
       yogaNode_(
           static_cast<const YogaLayoutableShadowNode&>(sourceShadowNode)
               .yogaNode_) {
-// Note, cloned `yoga::Node` instance (copied using copy-constructor) inherits
-// dirty flag, measure function, and other properties being set originally in
-// the `YogaLayoutableShadowNode` constructor above.
-
-// There is a known race condition when background executor is enabled, where
-// a tree may be laid out on the Fabric background thread concurrently with
-// the ShadowTree being created on the JS thread. This assert can be
-// re-enabled after disabling background executor everywhere.
-#if 0
-  react_native_assert(YGNodeIsDirty(&static_cast<const YogaLayoutableShadowNode&>(sourceShadowNode)
-              .yogaNode_) == YGNodeIsDirty(&yogaNode_) &&
+  // Note, cloned `yoga::Node` instance (copied using copy-constructor)
+  // inherits dirty flag, measure function, and other properties being set
+  // originally in the `YogaLayoutableShadowNode` constructor above.
+  react_native_assert(
+      YGNodeIsDirty(
+          &static_cast<const YogaLayoutableShadowNode&>(sourceShadowNode)
+               .yogaNode_) == YGNodeIsDirty(&yogaNode_) &&
       "Yoga node must inherit dirty flag.");
-#endif
-  if (!getTraits().check(ShadowNodeTraits::Trait::LeafYogaNode)) {
-    for (auto& child : getChildren()) {
-      if (auto layoutableChild =
-              std::dynamic_pointer_cast<const YogaLayoutableShadowNode>(
-                  child)) {
-        yogaLayoutableChildren_.push_back(std::move(layoutableChild));
-      }
-    }
+  if (!getTraits().check(ShadowNodeTraits::Trait::LeafYogaNode) &&
+      !fragment.children) {
+    // Children unchanged: copy the filtered list directly from the source,
+    // skipping per-child dynamic_pointer_cast. When fragment.children is set,
+    // updateYogaChildren() below rebuilds the vector from the new children
+    // list — populating it here would be immediately discarded.
+    yogaLayoutableChildren_ =
+        static_cast<const YogaLayoutableShadowNode&>(sourceShadowNode)
+            .yogaLayoutableChildren_;
   }
 
   YGConfigConstRef previousConfig =
@@ -325,11 +321,28 @@ bool YogaLayoutableShadowNode::shouldNewRevisionDirtyMeasurement(
   return true;
 }
 
+// Detects the ABA scenario where a freshly-allocated `yogaNode_` happens
+// to land at the same address a previous parent occupied. After such a
+// realloc, any Yoga child whose owner pointer still equals `&yogaNode_`
+// is a stale match — yoga would mistake it for "owned by us" and skip the
+// clone-on-write check. We rewrite those spurious owner pointers to a
+// recognisable sentinel so the next `YGNodeGetOwner(child) == this` check
+// correctly returns false and yoga clones the child as it would for any
+// foreign tree.
+//
+// No-op in the common case: right after a clone, children's owner
+// pointers still reference the source node, not us.
 void YogaLayoutableShadowNode::updateYogaChildrenOwnersIfNeeded() {
+  // Magic constant intentionally recognisable in debuggers when the address
+  // pops up. `reinterpret_cast` is not constexpr, so this is a runtime-
+  // initialised function-local static.
+  // NOLINTBEGIN(cppcoreguidelines-pro-type-reinterpret-cast)
+  static auto* const kDetachedYogaNodeOwnerSentinel =
+      reinterpret_cast<yoga::Node*>(0xBADC0FFEE0DDF00DULL);
+  // NOLINTEND(cppcoreguidelines-pro-type-reinterpret-cast)
   for (auto& childYogaNode : yogaNode_.getChildren()) {
     if (YGNodeGetOwner(childYogaNode) == &yogaNode_) {
-      childYogaNode->setOwner(
-          reinterpret_cast<yoga::Node*>(0xBADC0FFEE0DDF00D));
+      childYogaNode->setOwner(kDetachedYogaNodeOwnerSentinel);
     }
   }
 }
@@ -349,6 +362,7 @@ void YogaLayoutableShadowNode::updateYogaChildren() {
 
   yogaNode_.setChildren({});
   yogaLayoutableChildren_.clear();
+  yogaLayoutableChildren_.reserve(getChildren().size());
 
   for (size_t i = 0; i < getChildren().size(); i++) {
     if (auto yogaLayoutableChild =
@@ -466,6 +480,7 @@ void YogaLayoutableShadowNode::updateYogaProps() {
 
 void YogaLayoutableShadowNode::configureYogaTree(
     float pointScaleFactor,
+    Float fontSizeMultiplier,
     YGErrata defaultErrata,
     bool swapLeftAndRight) {
   ensureUnsealed();
@@ -475,6 +490,18 @@ void YogaLayoutableShadowNode::configureYogaTree(
   YGConfigSetErrata(&yogaConfig_, errata);
   YGConfigSetPointScaleFactor(&yogaConfig_, pointScaleFactor);
 
+  // A measurable node's measurement depends on `fontSizeMultiplier`, but unlike
+  // `pointScaleFactor` it is not part of the Yoga config, so a change does not
+  // invalidate Yoga's layout cache. Dirty the node when it changes to force
+  // re-measurement. We propagate up to the root so an unchanged, still-cached
+  // ancestor isn't skipped by `calculateLayoutInternal` before reaching us.
+  if (ReactNativeFeatureFlags::enableFontScaleChangesUpdatingLayout() &&
+      getTraits().check(ShadowNodeTraits::Trait::MeasurableYogaNode) &&
+      !floatEquality(
+          getLayoutMetrics().fontSizeMultiplier, fontSizeMultiplier)) {
+    yogaNode_.markDirtyAndPropagate();
+  }
+
   // TODO: `swapLeftAndRight` modified backing props and cannot be undone
   if (swapLeftAndRight) {
     swapStyleLeftAndRight();
@@ -493,6 +520,8 @@ void YogaLayoutableShadowNode::configureYogaTree(
 
     if (child.yogaTreeHasBeenConfigured_ &&
         childLayoutMetrics.pointScaleFactor == pointScaleFactor &&
+        floatEquality(
+            childLayoutMetrics.fontSizeMultiplier, fontSizeMultiplier) &&
         childLayoutMetrics.wasLeftAndRightSwapped == swapLeftAndRight &&
         childErrata == child.resolveErrata(errata)) {
       continue;
@@ -501,10 +530,13 @@ void YogaLayoutableShadowNode::configureYogaTree(
     if (doesOwn(child)) {
       auto& mutableChild = const_cast<YogaLayoutableShadowNode&>(child);
       mutableChild.configureYogaTree(
-          pointScaleFactor, child.resolveErrata(errata), swapLeftAndRight);
+          pointScaleFactor,
+          fontSizeMultiplier,
+          child.resolveErrata(errata),
+          swapLeftAndRight);
     } else {
       cloneChildInPlace(i).configureYogaTree(
-          pointScaleFactor, errata, swapLeftAndRight);
+          pointScaleFactor, fontSizeMultiplier, errata, swapLeftAndRight);
     }
   }
 }
@@ -514,7 +546,19 @@ YGErrata YogaLayoutableShadowNode::resolveErrata(YGErrata defaultErrata) const {
           dynamic_cast<const LayoutConformanceShadowNode*>(this)) {
     switch (layoutConformanceNode->getConcreteProps().mode) {
       case LayoutConformance::Strict:
-        return YGErrataNone;
+        // CSS Flexbox §4.5 automatic minimum sizing is the spec-compliant
+        // behaviour, so strict conformance should adopt it — but its probe
+        // walks measure callbacks with `AtMost 0`, which can surface latent
+        // bugs in platform measure overrides. Gate the rollout behind a
+        // feature flag so the behaviour can be ramped independently of strict
+        // conformance: when enabled, clear every errata bit (fully
+        // spec-compliant); when disabled (default), keep
+        // `MinSizeUndefinedInsteadOfAuto` set so strict subtrees preserve
+        // today's behaviour and the auto-min probe stays explicitly opt-in
+        // via `YogaConfig` setup.
+        return ReactNativeFeatureFlags::enableFlexboxAutoMinSizeInStrictMode()
+            ? YGErrataNone
+            : YGErrataMinSizeUndefinedInsteadOfAuto;
       case LayoutConformance::Compatibility:
         return YGErrataAll;
     }
@@ -601,6 +645,7 @@ void YogaLayoutableShadowNode::layoutTree(
     TraceSection s2("YogaLayoutableShadowNode::configureYogaTree");
     configureYogaTree(
         layoutContext.pointScaleFactor,
+        layoutContext.fontSizeMultiplier,
         YGErrataAll /*defaultErrata*/,
         swapLeftAndRight);
   }
@@ -666,6 +711,7 @@ void YogaLayoutableShadowNode::layoutTree(
   if (yogaNode_.getHasNewLayout()) {
     auto layoutMetrics = layoutMetricsFromYogaNode(yogaNode_);
     layoutMetrics.pointScaleFactor = layoutContext.pointScaleFactor;
+    layoutMetrics.fontSizeMultiplier = layoutContext.fontSizeMultiplier;
     layoutMetrics.wasLeftAndRightSwapped = swapLeftAndRight;
     setLayoutMetrics(layoutMetrics);
     yogaNode_.setHasNewLayout(false);
@@ -713,6 +759,7 @@ void YogaLayoutableShadowNode::layout(LayoutContext layoutContext) {
 
       auto newLayoutMetrics = layoutMetricsFromYogaNode(*childYogaNode);
       newLayoutMetrics.pointScaleFactor = layoutContext.pointScaleFactor;
+      newLayoutMetrics.fontSizeMultiplier = layoutContext.fontSizeMultiplier;
       newLayoutMetrics.wasLeftAndRightSwapped =
           layoutContext.swapLeftAndRightInRTL &&
           newLayoutMetrics.layoutDirection == LayoutDirection::RightToLeft;
@@ -970,8 +1017,7 @@ void YogaLayoutableShadowNode::swapLeftAndRightInYogaStyleProps() {
 void YogaLayoutableShadowNode::swapLeftAndRightInViewProps() {
   if (auto viewShadowNode = dynamic_cast<ViewShadowNode*>(this)) {
     // TODO: Do not mutate props directly.
-    auto& props =
-        const_cast<ViewShadowNodeProps&>(viewShadowNode->getConcreteProps());
+    auto& props = const_cast<ViewProps&>(viewShadowNode->getConcreteProps());
 
     // Swap border node values, borderRadii, borderColors and borderStyles.
     if (props.borderRadii.topLeft.has_value()) {

package/ReactCommon/react/renderer/components/view/YogaLayoutableShadowNode.h

@@ -22,6 +22,11 @@
 namespace facebook::react {
 
 class YogaLayoutableShadowNode : public LayoutableShadowNode {
+  // Allow YogaCloneTest to read yogaNode_ for ownership assertions in unit
+  // tests. The class is only defined in the tests target; production code
+  // sees the friend as a forward declaration with no effect.
+  friend class YogaCloneTest;
+
  public:
   using Shared = std::shared_ptr<const YogaLayoutableShadowNode>;
   using ListOfShared = std::vector<Shared>;
@@ -103,14 +108,6 @@ class YogaLayoutableShadowNode : public LayoutableShadowNode {
   mutable yoga::Node yogaNode_;
 
  private:
-  /*
-   * Goes over `yogaNode_.getChildren()` and in case child's owner is
-   * equal to address of `yogaNode_`, it sets child's owner address
-   * to `0xBADC0FFEE0DDF00D`. This is magic constant, the intention
-   * is to make debugging easier when the address pops up in debugger.
-   * This prevents ABA problem where child yoga node goes from owned -> unowned
-   * -> back to owned because its parent is allocated at the same address.
-   */
   void updateYogaChildrenOwnersIfNeeded();
 
   /*
@@ -137,7 +134,8 @@ class YogaLayoutableShadowNode : public LayoutableShadowNode {
    * ShadowTree has been constructed, but before it has been is laid out or
    * committed.
    */
-  void configureYogaTree(float pointScaleFactor, YGErrata defaultErrata, bool swapLeftAndRight);
+  void
+  configureYogaTree(float pointScaleFactor, Float fontSizeMultiplier, YGErrata defaultErrata, bool swapLeftAndRight);
 
   /**
    * Return an errata based on a `layoutConformance` prop if given, otherwise

package/ReactCommon/react/renderer/components/view/YogaStylableProps.cpp

@@ -7,7 +7,6 @@
 
 #include "YogaStylableProps.h"
 
-#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/components/view/conversions.h>
 #include <react/renderer/components/view/propsConversions.h>
 #include <react/renderer/core/propsConversions.h>
@@ -24,16 +23,9 @@ YogaStylableProps::YogaStylableProps(
     const YogaStylableProps& sourceProps,
     const RawProps& rawProps,
     const std::function<bool(const std::string&)>& filterObjectKeys)
-    : Props() {
-  initialize(context, sourceProps, rawProps, filterObjectKeys);
-
-  yogaStyle = ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
-      ? sourceProps.yogaStyle
-      : convertRawProp(context, rawProps, sourceProps.yogaStyle);
-
-  if (!ReactNativeFeatureFlags::enableCppPropsIteratorSetter()) {
-    convertRawPropAliases(context, sourceProps, rawProps);
-  }
+    : Props(context, sourceProps, rawProps, filterObjectKeys),
+      yogaStyle(convertRawProp(context, rawProps, sourceProps.yogaStyle)) {
+  convertRawPropAliases(context, sourceProps, rawProps);
 };
 
 template <typename T>

package/ReactCommon/react/renderer/components/view/platform/android/react/renderer/components/view/HostPlatformViewProps.cpp

@@ -9,7 +9,6 @@
 
 #include <algorithm>
 
-#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/components/view/accessibilityPropsConversions.h>
 #include <react/renderer/components/view/conversions.h>
 #include <react/renderer/components/view/propsConversions.h>
@@ -25,151 +24,84 @@ HostPlatformViewProps::HostPlatformViewProps(
     const RawProps& rawProps,
     const std::function<bool(const std::string&)>& filterObjectKeys)
     : BaseViewProps(context, sourceProps, rawProps, filterObjectKeys),
-      elevation(
-          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
-              ? sourceProps.elevation
-              : convertRawProp(
-                    context,
-                    rawProps,
-                    "elevation",
-                    sourceProps.elevation,
-                    {})),
-      nativeBackground(
-          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
-              ? sourceProps.nativeBackground
-              : convertRawProp(
-                    context,
-                    rawProps,
-                    "nativeBackgroundAndroid",
-                    sourceProps.nativeBackground,
-                    {})),
-      nativeForeground(
-          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
-              ? sourceProps.nativeForeground
-              : convertRawProp(
-                    context,
-                    rawProps,
-                    "nativeForegroundAndroid",
-                    sourceProps.nativeForeground,
-                    {})),
-      focusable(
-          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
-              ? sourceProps.focusable
-              : convertRawProp(
-                    context,
-                    rawProps,
-                    "focusable",
-                    sourceProps.focusable,
-                    {})),
-      hasTVPreferredFocus(
-          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
-              ? sourceProps.hasTVPreferredFocus
-              : convertRawProp(
-                    context,
-                    rawProps,
-                    "hasTVPreferredFocus",
-                    sourceProps.hasTVPreferredFocus,
-                    {})),
-      needsOffscreenAlphaCompositing(
-          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
-              ? sourceProps.needsOffscreenAlphaCompositing
-              : convertRawProp(
-                    context,
-                    rawProps,
-                    "needsOffscreenAlphaCompositing",
-                    sourceProps.needsOffscreenAlphaCompositing,
-                    {})),
-      renderToHardwareTextureAndroid(
-          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
-              ? sourceProps.renderToHardwareTextureAndroid
-              : convertRawProp(
-                    context,
-                    rawProps,
-                    "renderToHardwareTextureAndroid",
-                    sourceProps.renderToHardwareTextureAndroid,
-                    {})),
-      screenReaderFocusable(
-          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
-              ? sourceProps.screenReaderFocusable
-              : convertRawProp(
-                    context,
-                    rawProps,
-                    "screenReaderFocusable",
-                    sourceProps.screenReaderFocusable,
-                    {})),
-      nextFocusDown(
-          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
-              ? sourceProps.nextFocusDown
-              : convertRawProp(
-                    context,
-                    rawProps,
-                    "nextFocusDown",
-                    sourceProps.nextFocusDown,
-                    {})),
-      nextFocusForward(
-          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
-              ? sourceProps.nextFocusForward
-              : convertRawProp(
-                    context,
-                    rawProps,
-                    "nextFocusForward",
-                    sourceProps.nextFocusForward,
-                    {})),
-      nextFocusLeft(
-          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
-              ? sourceProps.nextFocusLeft
-              : convertRawProp(
-                    context,
-                    rawProps,
-                    "nextFocusLeft",
-                    sourceProps.nextFocusLeft,
-                    {})),
-      nextFocusRight(
-          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
-              ? sourceProps.nextFocusRight
-              : convertRawProp(
-                    context,
-                    rawProps,
-                    "nextFocusRight",
-                    sourceProps.nextFocusRight,
-                    {})),
-      nextFocusUp(
-          ReactNativeFeatureFlags::enableCppPropsIteratorSetter()
-              ? sourceProps.nextFocusUp
-              : convertRawProp(
-                    context,
-                    rawProps,
-                    "nextFocusUp",
-                    sourceProps.nextFocusUp,
-                    {})) {
-  if (!ReactNativeFeatureFlags::enableCppPropsIteratorSetter()) {
-    if (ReactNativeFeatureFlags::enableNativeViewPropTransformations()) {
-      // tabIndex -> focusable
-      auto* tabIndexValue = rawProps.at("tabIndex", nullptr, nullptr);
-      if (tabIndexValue != nullptr) {
-        if (tabIndexValue->hasValue()) {
-          int tabIndex = 0;
-          fromRawValue(context, *tabIndexValue, tabIndex);
-          focusable = tabIndex == 0;
-        } else {
-          focusable = {};
-        }
-      }
-    }
-  }
-}
-
-#define VIEW_EVENT_CASE(eventType)                      \
-  case CONSTEXPR_RAW_PROPS_KEY_HASH("on" #eventType): { \
-    const auto offset = ViewEvents::Offset::eventType;  \
-    ViewEvents defaultViewEvents{};                     \
-    bool res = defaultViewEvents[offset];               \
-    if (value.hasValue()) {                             \
-      fromRawValue(context, value, res);                \
-    }                                                   \
-    events[offset] = res;                               \
-    return;                                             \
-  }
+      elevation(convertRawProp(
+          context,
+          rawProps,
+          "elevation",
+          sourceProps.elevation,
+          {})),
+      nativeBackground(convertRawProp(
+          context,
+          rawProps,
+          "nativeBackgroundAndroid",
+          sourceProps.nativeBackground,
+          {})),
+      nativeForeground(convertRawProp(
+          context,
+          rawProps,
+          "nativeForegroundAndroid",
+          sourceProps.nativeForeground,
+          {})),
+      focusable(convertRawProp(
+          context,
+          rawProps,
+          "focusable",
+          sourceProps.focusable,
+          {})),
+      hasTVPreferredFocus(convertRawProp(
+          context,
+          rawProps,
+          "hasTVPreferredFocus",
+          sourceProps.hasTVPreferredFocus,
+          {})),
+      needsOffscreenAlphaCompositing(convertRawProp(
+          context,
+          rawProps,
+          "needsOffscreenAlphaCompositing",
+          sourceProps.needsOffscreenAlphaCompositing,
+          {})),
+      renderToHardwareTextureAndroid(convertRawProp(
+          context,
+          rawProps,
+          "renderToHardwareTextureAndroid",
+          sourceProps.renderToHardwareTextureAndroid,
+          {})),
+      screenReaderFocusable(convertRawProp(
+          context,
+          rawProps,
+          "screenReaderFocusable",
+          sourceProps.screenReaderFocusable,
+          {})),
+      nextFocusDown(convertRawProp(
+          context,
+          rawProps,
+          "nextFocusDown",
+          sourceProps.nextFocusDown,
+          {})),
+      nextFocusForward(convertRawProp(
+          context,
+          rawProps,
+          "nextFocusForward",
+          sourceProps.nextFocusForward,
+          {})),
+      nextFocusLeft(convertRawProp(
+          context,
+          rawProps,
+          "nextFocusLeft",
+          sourceProps.nextFocusLeft,
+          {})),
+      nextFocusRight(convertRawProp(
+          context,
+          rawProps,
+          "nextFocusRight",
+          sourceProps.nextFocusRight,
+          {})),
+      nextFocusUp(convertRawProp(
+          context,
+          rawProps,
+          "nextFocusUp",
+          sourceProps.nextFocusUp,
+          {})) {}
 
 void HostPlatformViewProps::setProp(
     const PropsParserContext& context,
@@ -197,19 +129,6 @@ void HostPlatformViewProps::setProp(
     RAW_SET_PROP_SWITCH_CASE_BASIC(nextFocusLeft);
     RAW_SET_PROP_SWITCH_CASE_BASIC(nextFocusRight);
     RAW_SET_PROP_SWITCH_CASE_BASIC(nextFocusUp);
-    case CONSTEXPR_RAW_PROPS_KEY_HASH("tabIndex"): {
-      if (!ReactNativeFeatureFlags::enableNativeViewPropTransformations()) {
-        return;
-      }
-      if (value.hasValue()) {
-        int tabIndex = 0;
-        fromRawValue(context, value, tabIndex);
-        focusable = tabIndex == 0;
-      } else {
-        focusable = defaults.focusable;
-      }
-      return;
-    }
   }
 }
 
@@ -502,8 +421,9 @@ inline static void updateAccessibilityStateProp(
   }
 
   if (!oldState.has_value() || newState->expanded != oldState->expanded) {
-    resultState["expanded"] =
-        newState->expanded.has_value() && newState->expanded.value();
+    if (newState->expanded.has_value()) {
+      resultState["expanded"] = newState->expanded.value();
+    }
   }
 
   if (!oldState.has_value() || newState->checked != oldState->checked) {
@@ -653,7 +573,7 @@ folly::dynamic HostPlatformViewProps::getDiffProps(
   }
 
   if (backgroundImage != oldProps->backgroundImage) {
-    result["experimental_backgroundImage"] = toDynamic(backgroundImage);
+    result["backgroundImage"] = toDynamic(backgroundImage);
   }
 
   if (mixBlendMode != oldProps->mixBlendMode) {

package/ReactCommon/react/renderer/components/view/primitives.h

@@ -248,4 +248,9 @@ struct BorderMetrics {
   bool operator==(const BorderMetrics &rhs) const = default;
 };
 
+inline bool areBorderRadiiCircular(const BorderRadii &borderRadii)
+{
+  return borderRadii.isUniform() && borderRadii.topLeft.horizontal == borderRadii.topLeft.vertical;
+}
+
 } // namespace facebook::react