react-native-windows 0.71.10 → 0.72.0-preview.2

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/view/ViewProps.cpp

@@ -0,0 +1,465 @@
+/*
+ * 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.
+ */
+
+#include "ViewProps.h"
+
+#include <algorithm>
+
+#include <react/renderer/components/view/conversions.h>
+#include <react/renderer/components/view/propsConversions.h>
+#include <react/renderer/core/CoreFeatures.h>
+#include <react/renderer/core/graphicsConversions.h>
+#include <react/renderer/core/propsConversions.h>
+#include <react/renderer/debug/debugStringConvertibleUtils.h>
+
+namespace facebook::react {
+
+ViewProps::ViewProps(
+    const PropsParserContext &context,
+    ViewProps const &sourceProps,
+    RawProps const &rawProps,
+    bool shouldSetRawProps)
+    : YogaStylableProps(context, sourceProps, rawProps, shouldSetRawProps),
+      AccessibilityProps(context, sourceProps, rawProps),
+      HostPlatformViewProps(context, sourceProps, rawProps, shouldSetRawProps), // [Windows]
+      opacity(
+          CoreFeatures::enablePropIteratorSetter ? sourceProps.opacity
+                                                 : convertRawProp(
+                                                       context,
+                                                       rawProps,
+                                                       "opacity",
+                                                       sourceProps.opacity,
+                                                       (Float)1.0)),
+      foregroundColor(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.foregroundColor
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "foregroundColor",
+                    sourceProps.foregroundColor,
+                    {})),
+      backgroundColor(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.backgroundColor
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "backgroundColor",
+                    sourceProps.backgroundColor,
+                    {})),
+      borderRadii(
+          CoreFeatures::enablePropIteratorSetter ? sourceProps.borderRadii
+                                                 : convertRawProp(
+                                                       context,
+                                                       rawProps,
+                                                       "border",
+                                                       "Radius",
+                                                       sourceProps.borderRadii,
+                                                       {})),
+      borderColors(
+          CoreFeatures::enablePropIteratorSetter ? sourceProps.borderColors
+                                                 : convertRawProp(
+                                                       context,
+                                                       rawProps,
+                                                       "border",
+                                                       "Color",
+                                                       sourceProps.borderColors,
+                                                       {})),
+      borderCurves(
+          CoreFeatures::enablePropIteratorSetter ? sourceProps.borderCurves
+                                                 : convertRawProp(
+                                                       context,
+                                                       rawProps,
+                                                       "border",
+                                                       "Curve",
+                                                       sourceProps.borderCurves,
+                                                       {})),
+      borderStyles(
+          CoreFeatures::enablePropIteratorSetter ? sourceProps.borderStyles
+                                                 : convertRawProp(
+                                                       context,
+                                                       rawProps,
+                                                       "border",
+                                                       "Style",
+                                                       sourceProps.borderStyles,
+                                                       {})),
+      shadowColor(
+          CoreFeatures::enablePropIteratorSetter ? sourceProps.shadowColor
+                                                 : convertRawProp(
+                                                       context,
+                                                       rawProps,
+                                                       "shadowColor",
+                                                       sourceProps.shadowColor,
+                                                       {})),
+      shadowOffset(
+          CoreFeatures::enablePropIteratorSetter ? sourceProps.shadowOffset
+                                                 : convertRawProp(
+                                                       context,
+                                                       rawProps,
+                                                       "shadowOffset",
+                                                       sourceProps.shadowOffset,
+                                                       {})),
+      shadowOpacity(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.shadowOpacity
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "shadowOpacity",
+                    sourceProps.shadowOpacity,
+                    {})),
+      shadowRadius(
+          CoreFeatures::enablePropIteratorSetter ? sourceProps.shadowRadius
+                                                 : convertRawProp(
+                                                       context,
+                                                       rawProps,
+                                                       "shadowRadius",
+                                                       sourceProps.shadowRadius,
+                                                       {})),
+      transform(
+          CoreFeatures::enablePropIteratorSetter ? sourceProps.transform
+                                                 : convertRawProp(
+                                                       context,
+                                                       rawProps,
+                                                       "transform",
+                                                       sourceProps.transform,
+                                                       {})),
+      backfaceVisibility(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.backfaceVisibility
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "backfaceVisibility",
+                    sourceProps.backfaceVisibility,
+                    {})),
+      shouldRasterize(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.shouldRasterize
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "shouldRasterize",
+                    sourceProps.shouldRasterize,
+                    {})),
+      zIndex(
+          CoreFeatures::enablePropIteratorSetter ? sourceProps.zIndex
+                                                 : convertRawProp(
+                                                       context,
+                                                       rawProps,
+                                                       "zIndex",
+                                                       sourceProps.zIndex,
+                                                       {})),
+      pointerEvents(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.pointerEvents
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "pointerEvents",
+                    sourceProps.pointerEvents,
+                    {})),
+      hitSlop(
+          CoreFeatures::enablePropIteratorSetter ? sourceProps.hitSlop
+                                                 : convertRawProp(
+                                                       context,
+                                                       rawProps,
+                                                       "hitSlop",
+                                                       sourceProps.hitSlop,
+                                                       {})),
+      onLayout(
+          CoreFeatures::enablePropIteratorSetter ? sourceProps.onLayout
+                                                 : convertRawProp(
+                                                       context,
+                                                       rawProps,
+                                                       "onLayout",
+                                                       sourceProps.onLayout,
+                                                       {})),
+      events(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.events
+              : convertRawProp(context, rawProps, sourceProps.events, {})),
+      collapsable(
+          CoreFeatures::enablePropIteratorSetter ? sourceProps.collapsable
+                                                 : convertRawProp(
+                                                       context,
+                                                       rawProps,
+                                                       "collapsable",
+                                                       sourceProps.collapsable,
+                                                       true)),
+      removeClippedSubviews(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.removeClippedSubviews
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "removeClippedSubviews",
+                    sourceProps.removeClippedSubviews,
+                    false))
+#ifdef ANDROID
+      ,
+      elevation(
+          CoreFeatures::enablePropIteratorSetter ? sourceProps.elevation
+                                                 : convertRawProp(
+                                                       context,
+                                                       rawProps,
+                                                       "elevation",
+                                                       sourceProps.elevation,
+                                                       {})),
+      nativeBackground(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.nativeBackground
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "nativeBackgroundAndroid",
+                    sourceProps.nativeBackground,
+                    {})),
+      nativeForeground(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.nativeForeground
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "nativeForegroundAndroid",
+                    sourceProps.nativeForeground,
+                    {})),
+      focusable(
+          CoreFeatures::enablePropIteratorSetter ? sourceProps.focusable
+                                                 : convertRawProp(
+                                                       context,
+                                                       rawProps,
+                                                       "focusable",
+                                                       sourceProps.focusable,
+                                                       {})),
+      hasTVPreferredFocus(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.hasTVPreferredFocus
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "hasTVPreferredFocus",
+                    sourceProps.hasTVPreferredFocus,
+                    {})),
+      needsOffscreenAlphaCompositing(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.needsOffscreenAlphaCompositing
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "needsOffscreenAlphaCompositing",
+                    sourceProps.needsOffscreenAlphaCompositing,
+                    {})),
+      renderToHardwareTextureAndroid(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.renderToHardwareTextureAndroid
+              : convertRawProp(
+                    context,
+                    rawProps,
+                    "renderToHardwareTextureAndroid",
+                    sourceProps.renderToHardwareTextureAndroid,
+                    {}))
+
+#endif
+{
+}
+
+#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;                                             \
+  }
+
+void ViewProps::setProp(
+    const PropsParserContext &context,
+    RawPropsPropNameHash hash,
+    const char *propName,
+    RawValue const &value) {
+  // All Props structs setProp methods must always, unconditionally,
+  // call all super::setProp methods, since multiple structs may
+  // reuse the same values.
+  YogaStylableProps::setProp(context, hash, propName, value);
+  AccessibilityProps::setProp(context, hash, propName, value);
+  HostPlatformViewProps::setProp(context, hash, propName, value); // [Windows]
+
+  static auto defaults = ViewProps{};
+
+  switch (hash) {
+    RAW_SET_PROP_SWITCH_CASE_BASIC(opacity);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(foregroundColor);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(backgroundColor);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(shadowColor);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(shadowOffset);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(shadowOpacity);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(shadowRadius);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(transform);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(backfaceVisibility);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(shouldRasterize);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(zIndex);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(pointerEvents);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(hitSlop);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(onLayout);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(collapsable);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(removeClippedSubviews);
+    // events field
+    VIEW_EVENT_CASE(PointerEnter);
+    VIEW_EVENT_CASE(PointerEnterCapture);
+    VIEW_EVENT_CASE(PointerMove);
+    VIEW_EVENT_CASE(PointerMoveCapture);
+    VIEW_EVENT_CASE(PointerLeave);
+    VIEW_EVENT_CASE(PointerLeaveCapture);
+    VIEW_EVENT_CASE(PointerOver);
+    VIEW_EVENT_CASE(PointerOut);
+    VIEW_EVENT_CASE(MoveShouldSetResponder);
+    VIEW_EVENT_CASE(MoveShouldSetResponderCapture);
+    VIEW_EVENT_CASE(StartShouldSetResponder);
+    VIEW_EVENT_CASE(StartShouldSetResponderCapture);
+    VIEW_EVENT_CASE(ResponderGrant);
+    VIEW_EVENT_CASE(ResponderReject);
+    VIEW_EVENT_CASE(ResponderStart);
+    VIEW_EVENT_CASE(ResponderEnd);
+    VIEW_EVENT_CASE(ResponderRelease);
+    VIEW_EVENT_CASE(ResponderMove);
+    VIEW_EVENT_CASE(ResponderTerminate);
+    VIEW_EVENT_CASE(ResponderTerminationRequest);
+    VIEW_EVENT_CASE(ShouldBlockNativeResponder);
+    VIEW_EVENT_CASE(TouchStart);
+    VIEW_EVENT_CASE(TouchMove);
+    VIEW_EVENT_CASE(TouchEnd);
+    VIEW_EVENT_CASE(TouchCancel);
+    VIEW_EVENT_CASE(MouseEnter); // [Windows]
+    VIEW_EVENT_CASE(MouseLeave); // [Windows]
+
+#ifdef ANDROID
+    RAW_SET_PROP_SWITCH_CASE_BASIC(elevation);
+    RAW_SET_PROP_SWITCH_CASE(nativeBackground, "nativeBackgroundAndroid");
+    RAW_SET_PROP_SWITCH_CASE(nativeForeground, "nativeForegroundAndroid");
+    RAW_SET_PROP_SWITCH_CASE_BASIC(focusable);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(hasTVPreferredFocus);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(needsOffscreenAlphaCompositing);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(renderToHardwareTextureAndroid);
+#endif
+    // BorderRadii
+    SET_CASCADED_RECTANGLE_CORNERS(borderRadii, "border", "Radius", value);
+    SET_CASCADED_RECTANGLE_EDGES(borderColors, "border", "Color", value);
+    SET_CASCADED_RECTANGLE_EDGES(borderStyles, "border", "Style", value);
+  }
+}
+
+#pragma mark - Convenience Methods
+
+static BorderRadii ensureNoOverlap(BorderRadii const &radii, Size const &size) {
+  // "Corner curves must not overlap: When the sum of any two adjacent border
+  // radii exceeds the size of the border box, UAs must proportionally reduce
+  // the used values of all border radii until none of them overlap."
+  // Source: https://www.w3.org/TR/css-backgrounds-3/#corner-overlap
+
+  auto insets = EdgeInsets{
+      /* .left = */ radii.topLeft + radii.bottomLeft,
+      /* .top = */ radii.topLeft + radii.topRight,
+      /* .right = */ radii.topRight + radii.bottomRight,
+      /* .bottom = */ radii.bottomLeft + radii.bottomRight,
+  };
+
+  auto insetsScale = EdgeInsets{
+      /* .left = */
+      insets.left > 0 ? std::min((Float)1.0, size.height / insets.left) : 0,
+      /* .top = */
+      insets.top > 0 ? std::min((Float)1.0, size.width / insets.top) : 0,
+      /* .right = */
+      insets.right > 0 ? std::min((Float)1.0, size.height / insets.right) : 0,
+      /* .bottom = */
+      insets.bottom > 0 ? std::min((Float)1.0, size.width / insets.bottom) : 0,
+  };
+
+  return BorderRadii{
+      /* topLeft = */
+      radii.topLeft * std::min(insetsScale.top, insetsScale.left),
+      /* topRight = */
+      radii.topRight * std::min(insetsScale.top, insetsScale.right),
+      /* bottomLeft = */
+      radii.bottomLeft * std::min(insetsScale.bottom, insetsScale.left),
+      /* bottomRight = */
+      radii.bottomRight * std::min(insetsScale.bottom, insetsScale.right),
+  };
+}
+
+BorderMetrics ViewProps::resolveBorderMetrics(
+    LayoutMetrics const &layoutMetrics) const {
+  auto isRTL =
+      bool{layoutMetrics.layoutDirection == LayoutDirection::RightToLeft};
+
+  auto borderWidths = CascadedBorderWidths{
+      /* .left = */ optionalFloatFromYogaValue(yogaStyle.border()[YGEdgeLeft]),
+      /* .top = */ optionalFloatFromYogaValue(yogaStyle.border()[YGEdgeTop]),
+      /* .right = */
+      optionalFloatFromYogaValue(yogaStyle.border()[YGEdgeRight]),
+      /* .bottom = */
+      optionalFloatFromYogaValue(yogaStyle.border()[YGEdgeBottom]),
+      /* .start = */
+      optionalFloatFromYogaValue(yogaStyle.border()[YGEdgeStart]),
+      /* .end = */ optionalFloatFromYogaValue(yogaStyle.border()[YGEdgeEnd]),
+      /* .horizontal = */
+      optionalFloatFromYogaValue(yogaStyle.border()[YGEdgeHorizontal]),
+      /* .vertical = */
+      optionalFloatFromYogaValue(yogaStyle.border()[YGEdgeVertical]),
+      /* .all = */ optionalFloatFromYogaValue(yogaStyle.border()[YGEdgeAll]),
+  };
+
+  return {
+      /* .borderColors = */ borderColors.resolve(isRTL, {}),
+      /* .borderWidths = */ borderWidths.resolve(isRTL, 0),
+      /* .borderRadii = */
+      ensureNoOverlap(borderRadii.resolve(isRTL, 0), layoutMetrics.frame.size),
+      /* .borderCurves = */ borderCurves.resolve(isRTL, BorderCurve::Circular),
+      /* .borderStyles = */ borderStyles.resolve(isRTL, BorderStyle::Solid),
+  };
+}
+
+bool ViewProps::getClipsContentToBounds() const {
+  return yogaStyle.overflow() != YGOverflowVisible;
+}
+
+#ifdef ANDROID
+bool ViewProps::getProbablyMoreHorizontalThanVertical_DEPRECATED() const {
+  return yogaStyle.flexDirection() == YGFlexDirectionRow;
+}
+#endif
+
+#pragma mark - DebugStringConvertible
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+SharedDebugStringConvertibleList ViewProps::getDebugProps() const {
+  const auto &defaultViewProps = ViewProps();
+
+  return AccessibilityProps::getDebugProps() +
+      YogaStylableProps::getDebugProps() +
+      SharedDebugStringConvertibleList{
+          debugStringConvertibleItem(
+              "opacity", opacity, defaultViewProps.opacity),
+          debugStringConvertibleItem(
+              "foregroundColor",
+              foregroundColor,
+              defaultViewProps.foregroundColor),
+          debugStringConvertibleItem(
+              "backgroundColor",
+              backgroundColor,
+              defaultViewProps.backgroundColor),
+          debugStringConvertibleItem(
+              "zIndex", zIndex, defaultViewProps.zIndex.value_or(0)),
+      };
+}
+#endif
+
+} // namespace facebook::react

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/view/ViewProps.h

@@ -0,0 +1,116 @@
+/*
+ * 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 <react/renderer/components/view/AccessibilityProps.h>
+#include <react/renderer/components/view/YogaStylableProps.h>
+#include <react/renderer/components/view/HostPlatformViewProps.h> // [Windows]
+#include <react/renderer/components/view/primitives.h>
+#include <react/renderer/core/LayoutMetrics.h>
+#include <react/renderer/core/Props.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/graphics/Color.h>
+#include <react/renderer/graphics/Transform.h>
+
+#include <optional>
+
+namespace facebook {
+namespace react {
+
+class ViewProps;
+
+using SharedViewProps = std::shared_ptr<ViewProps const>;
+
+class ViewProps : public YogaStylableProps, public AccessibilityProps, public HostPlatformViewProps  { // [Windows] added HostPlatformViewProps
+ public:
+  ViewProps() = default;
+  ViewProps(
+      const PropsParserContext &context,
+      ViewProps const &sourceProps,
+      RawProps const &rawProps,
+      bool shouldSetRawProps = true);
+
+  void setProp(
+      const PropsParserContext &context,
+      RawPropsPropNameHash hash,
+      const char *propName,
+      RawValue const &value);
+
+#ifdef ANDROID
+  void propsDiffMapBuffer(Props const *oldProps, MapBufferBuilder &builder)
+      const override;
+#endif
+
+#pragma mark - Props
+
+  // Color
+  Float opacity{1.0};
+  SharedColor foregroundColor{};
+  SharedColor backgroundColor{};
+
+  // Borders
+  CascadedBorderRadii borderRadii{};
+  CascadedBorderColors borderColors{};
+  CascadedBorderCurves borderCurves{}; // iOS only?
+  CascadedBorderStyles borderStyles{};
+
+  // Shadow
+  SharedColor shadowColor{};
+  Size shadowOffset{0, -3};
+  Float shadowOpacity{};
+  Float shadowRadius{3};
+
+  // Transform
+  Transform transform{};
+  BackfaceVisibility backfaceVisibility{};
+  bool shouldRasterize{};
+  std::optional<int> zIndex{};
+
+  // Events
+  PointerEventsMode pointerEvents{};
+  EdgeInsets hitSlop{};
+  bool onLayout{};
+
+  ViewEvents events{};
+
+  bool collapsable{true};
+
+  bool removeClippedSubviews{false};
+
+  Float elevation{}; /* Android-only */
+
+#ifdef ANDROID
+
+  std::optional<NativeDrawable> nativeBackground{};
+  std::optional<NativeDrawable> nativeForeground{};
+
+  bool focusable{false};
+  bool hasTVPreferredFocus{false};
+  bool needsOffscreenAlphaCompositing{false};
+  bool renderToHardwareTextureAndroid{false};
+
+#endif
+
+#pragma mark - Convenience Methods
+
+  BorderMetrics resolveBorderMetrics(LayoutMetrics const &layoutMetrics) const;
+  bool getClipsContentToBounds() const;
+
+#ifdef ANDROID
+  bool getProbablyMoreHorizontalThanVertical_DEPRECATED() const;
+#endif
+
+#pragma mark - DebugStringConvertible
+
+#if RN_DEBUG_STRING_CONVERTIBLE
+  SharedDebugStringConvertibleList getDebugProps() const override;
+#endif
+};
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/components/view/ViewShadowNode.cpp

@@ -0,0 +1,98 @@
+/*
+ * 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.
+ */
+
+#include "ViewShadowNode.h"
+#include <react/config/ReactNativeConfig.h>
+#include <react/renderer/components/view/primitives.h>
+#include <react/renderer/core/CoreFeatures.h>
+
+namespace facebook::react {
+
+char const ViewComponentName[] = "View";
+
+ViewShadowNodeProps::ViewShadowNodeProps(
+    PropsParserContext const &context,
+    ViewShadowNodeProps const &sourceProps,
+    RawProps const &rawProps)
+    : ViewProps(
+          context,
+          sourceProps,
+          rawProps,
+          !CoreFeatures::enableMapBuffer){};
+
+ViewShadowNode::ViewShadowNode(
+    ShadowNodeFragment const &fragment,
+    ShadowNodeFamily::Shared const &family,
+    ShadowNodeTraits traits)
+    : ConcreteViewShadowNode(fragment, family, traits) {
+  initialize();
+}
+
+ViewShadowNode::ViewShadowNode(
+    ShadowNode const &sourceShadowNode,
+    ShadowNodeFragment const &fragment)
+    : ConcreteViewShadowNode(sourceShadowNode, fragment) {
+  initialize();
+}
+
+void ViewShadowNode::initialize() noexcept {
+  auto &viewProps = static_cast<ViewProps const &>(*props_);
+
+  bool formsStackingContext = !viewProps.collapsable ||
+      viewProps.pointerEvents == PointerEventsMode::None ||
+      !viewProps.nativeId.empty() || viewProps.accessible ||
+      viewProps.opacity != 1.0 || viewProps.transform != Transform{} ||
+      (viewProps.zIndex.has_value() &&
+       viewProps.yogaStyle.positionType() != YGPositionTypeStatic) ||
+      viewProps.yogaStyle.display() == YGDisplayNone ||
+      viewProps.getClipsContentToBounds() || viewProps.events.bits.any() ||
+      isColorMeaningful(viewProps.shadowColor) ||
+      viewProps.accessibilityElementsHidden ||
+      viewProps.accessibilityViewIsModal ||
+      viewProps.importantForAccessibility != ImportantForAccessibility::Auto ||
+      viewProps.removeClippedSubviews;
+
+#ifdef ANDROID
+  formsStackingContext = formsStackingContext || viewProps.elevation != 0;
+#endif
+
+  formsStackingContext = formsStackingContext || HostPlatformViewProps::requiresFormsStackingContext(viewProps); // [Windows]
+
+  bool formsView = formsStackingContext ||
+      isColorMeaningful(viewProps.backgroundColor) ||
+      isColorMeaningful(viewProps.foregroundColor) ||
+      !(viewProps.yogaStyle.border() == YGStyle::Edges{}) ||
+      !viewProps.testId.empty();
+
+  formsView = formsView || HostPlatformViewProps::requiresFormsView(viewProps); // [Windows]
+
+#ifdef ANDROID
+  formsView = formsView || viewProps.nativeBackground.has_value() ||
+      viewProps.nativeForeground.has_value() || viewProps.focusable ||
+      viewProps.hasTVPreferredFocus ||
+      viewProps.needsOffscreenAlphaCompositing ||
+      viewProps.renderToHardwareTextureAndroid;
+#endif
+
+  if (formsView) {
+    traits_.set(ShadowNodeTraits::Trait::FormsView);
+  } else {
+    traits_.unset(ShadowNodeTraits::Trait::FormsView);
+  }
+
+  if (formsStackingContext) {
+    traits_.set(ShadowNodeTraits::Trait::FormsStackingContext);
+  } else {
+    traits_.unset(ShadowNodeTraits::Trait::FormsStackingContext);
+  }
+
+#ifdef ANDROID
+  traits_.set(ShadowNodeTraits::Trait::AndroidMapBufferPropsSupported);
+#endif
+}
+
+} // namespace facebook::react