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

package/ReactCommon/react/renderer/components/textinput/BaseTextInputShadowNode.h

@@ -25,6 +25,16 @@
 
 namespace facebook::react {
 
+inline ShadowView shadowViewFromShadowNode(const ShadowNode &shadowNode)
+{
+  auto shadowView = ShadowView{shadowNode};
+  // Clearing `props` and `state` (which we don't use) allows avoiding retain
+  // cycles.
+  shadowView.props = nullptr;
+  shadowView.state = nullptr;
+  return shadowView;
+}
+
 /*
  * Base `ShadowNode` for <TextInput> component.
  */
@@ -171,7 +181,9 @@ class BaseTextInputShadowNode
     AttributedString attributedString;
     attributedString.appendFragment(
         AttributedString::Fragment{
-            .string = props.text, .textAttributes = textAttributes, .parentShadowView = ShadowView(*this)});
+            .string = props.text,
+            .textAttributes = textAttributes,
+            .parentShadowView = shadowViewFromShadowNode(*this)});
 
     auto attachments = BaseTextShadowNode::Attachments{};
     BaseTextShadowNode::buildAttributedString(textAttributes, *this, attributedString, attachments);

package/ReactCommon/react/renderer/components/textinput/TextInputEventEmitter.cpp

@@ -140,7 +140,8 @@ void TextInputEventEmitter::onBlur(const Metrics& textInputMetrics) const {
 }
 
 void TextInputEventEmitter::onChange(const Metrics& textInputMetrics) const {
-  dispatchTextInputEvent("change", textInputMetrics);
+  dispatchTextInputEvent(
+      "change", textInputMetrics, /* includeSelectionState */ true);
 }
 
 void TextInputEventEmitter::onContentSizeChange(

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

@@ -56,17 +56,13 @@ inline static bool operator==(const AccessibilityAction &lhs, const Accessibilit
   return lhs.name == rhs.name && lhs.label == rhs.label;
 }
 
-inline static bool operator!=(const AccessibilityAction &lhs, const AccessibilityAction &rhs)
-{
-  return !(rhs == lhs);
-}
-
 struct AccessibilityState {
   bool disabled{false};
   bool selected{false};
   bool busy{false};
   std::optional<bool> expanded{std::nullopt};
-  enum CheckedState { Unchecked, Checked, Mixed, None } checked{None};
+  enum CheckedState { Unchecked, Checked, Mixed, None };
+  CheckedState checked{CheckedState::None};
 };
 
 constexpr bool operator==(const AccessibilityState &lhs, const AccessibilityState &rhs)
@@ -75,11 +71,6 @@ constexpr bool operator==(const AccessibilityState &lhs, const AccessibilityStat
       lhs.busy == rhs.busy && lhs.expanded == rhs.expanded;
 }
 
-constexpr bool operator!=(const AccessibilityState &lhs, const AccessibilityState &rhs)
-{
-  return !(rhs == lhs);
-}
-
 struct AccessibilityLabelledBy {
   std::vector<std::string> value{};
 };
@@ -89,11 +80,6 @@ inline static bool operator==(const AccessibilityLabelledBy &lhs, const Accessib
   return lhs.value == rhs.value;
 }
 
-inline static bool operator!=(const AccessibilityLabelledBy &lhs, const AccessibilityLabelledBy &rhs)
-{
-  return !(lhs == rhs);
-}
-
 struct AccessibilityValue {
   std::optional<int> min;
   std::optional<int> max;
@@ -106,11 +92,6 @@ constexpr bool operator==(const AccessibilityValue &lhs, const AccessibilityValu
   return lhs.min == rhs.min && lhs.max == rhs.max && lhs.now == rhs.now && lhs.text == rhs.text;
 }
 
-constexpr bool operator!=(const AccessibilityValue &lhs, const AccessibilityValue &rhs)
-{
-  return !(rhs == lhs);
-}
-
 enum class ImportantForAccessibility : uint8_t {
   Auto,
   Yes,

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

@@ -119,14 +119,12 @@ void parseProcessedBackgroundImage(
           std::string directionType = (std::string)(directionTypeIt->second);
 
           if (directionType == "angle") {
-            linearGradient.direction.type = GradientDirectionType::Angle;
             if (valueIt->second.hasType<Float>()) {
-              linearGradient.direction.value = (Float)(valueIt->second);
+              linearGradient.direction = (Float)(valueIt->second);
             }
           } else if (directionType == "keyword") {
-            linearGradient.direction.type = GradientDirectionType::Keyword;
             if (valueIt->second.hasType<std::string>()) {
-              linearGradient.direction.value =
+              linearGradient.direction =
                   parseGradientKeyword((std::string)(valueIt->second));
             }
           }
@@ -309,30 +307,26 @@ void parseUnprocessedBackgroundImageList(
                 std::get<CSSLinearGradientDirection>(cssDirection);
 
             if (std::holds_alternative<CSSAngle>(direction.value)) {
-              linearGradient.direction.type = GradientDirectionType::Angle;
-              linearGradient.direction.value =
+              linearGradient.direction =
                   std::get<CSSAngle>(direction.value).degrees;
             } else if (std::holds_alternative<
                            CSSLinearGradientDirectionKeyword>(
                            direction.value)) {
-              linearGradient.direction.type = GradientDirectionType::Keyword;
               auto keyword =
                   std::get<CSSLinearGradientDirectionKeyword>(direction.value);
 
               switch (keyword) {
                 case CSSLinearGradientDirectionKeyword::ToTopLeft:
-                  linearGradient.direction.value = GradientKeyword::ToTopLeft;
+                  linearGradient.direction = GradientKeyword::ToTopLeft;
                   break;
                 case CSSLinearGradientDirectionKeyword::ToTopRight:
-                  linearGradient.direction.value = GradientKeyword::ToTopRight;
+                  linearGradient.direction = GradientKeyword::ToTopRight;
                   break;
                 case CSSLinearGradientDirectionKeyword::ToBottomLeft:
-                  linearGradient.direction.value =
-                      GradientKeyword::ToBottomLeft;
+                  linearGradient.direction = GradientKeyword::ToBottomLeft;
                   break;
                 case CSSLinearGradientDirectionKeyword::ToBottomRight:
-                  linearGradient.direction.value =
-                      GradientKeyword::ToBottomRight;
+                  linearGradient.direction = GradientKeyword::ToBottomRight;
                   break;
               }
             }
@@ -477,7 +471,7 @@ void fromCSSColorStop(
 }
 
 std::optional<BackgroundImage> fromCSSBackgroundImage(
-    const CSSBackgroundImageVariant& cssBackgroundImage) {
+    const CSSBackgroundImage& cssBackgroundImage) {
   if (std::holds_alternative<CSSLinearGradientFunction>(cssBackgroundImage)) {
     const auto& gradient =
         std::get<CSSLinearGradientFunction>(cssBackgroundImage);
@@ -486,26 +480,23 @@ std::optional<BackgroundImage> fromCSSBackgroundImage(
     if (gradient.direction.has_value()) {
       if (std::holds_alternative<CSSAngle>(gradient.direction->value)) {
         const auto& angle = std::get<CSSAngle>(gradient.direction->value);
-        linearGradient.direction.type = GradientDirectionType::Angle;
-        linearGradient.direction.value = angle.degrees;
+        linearGradient.direction = angle.degrees;
       } else if (std::holds_alternative<CSSLinearGradientDirectionKeyword>(
                      gradient.direction->value)) {
         const auto& dirKeyword = std::get<CSSLinearGradientDirectionKeyword>(
             gradient.direction->value);
-        linearGradient.direction.type = GradientDirectionType::Keyword;
-
         switch (dirKeyword) {
           case CSSLinearGradientDirectionKeyword::ToTopLeft:
-            linearGradient.direction.value = GradientKeyword::ToTopLeft;
+            linearGradient.direction = GradientKeyword::ToTopLeft;
             break;
           case CSSLinearGradientDirectionKeyword::ToTopRight:
-            linearGradient.direction.value = GradientKeyword::ToTopRight;
+            linearGradient.direction = GradientKeyword::ToTopRight;
             break;
           case CSSLinearGradientDirectionKeyword::ToBottomLeft:
-            linearGradient.direction.value = GradientKeyword::ToBottomLeft;
+            linearGradient.direction = GradientKeyword::ToBottomLeft;
             break;
           case CSSLinearGradientDirectionKeyword::ToBottomRight:
-            linearGradient.direction.value = GradientKeyword::ToBottomRight;
+            linearGradient.direction = GradientKeyword::ToBottomRight;
             break;
         }
       }
@@ -606,14 +597,14 @@ void parseUnprocessedBackgroundImageString(
   for (const auto& cssBackgroundImage :
        std::get<CSSBackgroundImageList>(backgroundImageList)) {
     if (auto backgroundImage = fromCSSBackgroundImage(cssBackgroundImage)) {
-      backgroundImages.push_back(*backgroundImage);
+      backgroundImages.push_back(std::move(*backgroundImage));
     } else {
       result = {};
       return;
     }
   }
 
-  result = backgroundImages;
+  result = std::move(backgroundImages);
 }
 
 } // namespace facebook::react

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

@@ -22,39 +22,39 @@ struct BaseTouch {
   /*
    * The coordinate of point relative to the root component in points.
    */
-  Point pagePoint;
+  Point pagePoint{};
 
   /*
    * The coordinate of point relative to the target component in points.
    */
-  Point offsetPoint;
+  Point offsetPoint{};
 
   /*
    * The coordinate of point relative to the screen component in points.
    */
-  Point screenPoint;
+  Point screenPoint{};
 
   /*
    * An identification number for each touch point.
    */
-  int identifier;
+  int identifier{0};
 
   /*
    * The tag of a component on which the touch point started when it was first
    * placed on the surface, even if the touch point has since moved outside the
    * interactive area of that element.
    */
-  Tag target;
+  Tag target{0};
 
   /*
    * The force of the touch.
    */
-  Float force;
+  Float force{0.0f};
 
   /*
    * The time in seconds when the touch occurred or when it was last mutated.
    */
-  Float timestamp;
+  Float timestamp{0.0f};
 
   /*
    * The particular implementation of `Hasher` and (especially) `Comparator`

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

@@ -447,7 +447,16 @@ BaseViewProps::BaseViewProps(
                     rawProps,
                     "removeClippedSubviews",
                     sourceProps.removeClippedSubviews,
-                    false)) {}
+                    false))
+#if TARGET_OS_TV
+      ,scrollSnapAlign(ReactNativeFeatureFlags::enableCppPropsIteratorSetter() ? sourceProps.scrollSnapAlign : convertRawProp(
+          context,
+          rawProps,
+          "scrollSnapAlign",
+          sourceProps.scrollSnapAlign,
+          {}))
+#endif
+      {}
 
 #define VIEW_EVENT_CASE(eventType)                      \
   case CONSTEXPR_RAW_PROPS_KEY_HASH("on" #eventType): { \
@@ -518,6 +527,7 @@ void BaseViewProps::setProp(
     RAW_SET_PROP_SWITCH_CASE_BASIC(trapFocusDown);
     RAW_SET_PROP_SWITCH_CASE_BASIC(trapFocusLeft);
     RAW_SET_PROP_SWITCH_CASE_BASIC(trapFocusRight);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(scrollSnapAlign);
 #endif
     // events field
     VIEW_EVENT_CASE(PointerEnter);

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

@@ -124,6 +124,10 @@ class BaseViewProps : public YogaStylableProps, public AccessibilityProps {
 
   bool removeClippedSubviews{false};
 
+#if TARGET_OS_TV
+  std::optional<std::string> scrollSnapAlign;
+#endif
+
 #pragma mark - Convenience Methods
 
   CascadedBorderWidths getBorderWidths() const;

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

@@ -12,10 +12,7 @@
 #include <react/renderer/components/view/ViewProps.h>
 #include <react/renderer/components/view/YogaLayoutableShadowNode.h>
 #include <react/renderer/core/ConcreteShadowNode.h>
-#include <react/renderer/core/LayoutableShadowNode.h>
-#include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/core/ShadowNodeFragment.h>
-#include <react/renderer/debug/DebugStringConvertibleItem.h>
 #include <type_traits>
 
 namespace facebook::react {

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

@@ -45,70 +45,70 @@ parseProcessedFilter(const PropsParserContext &context, const RawValue &value, s
 
     auto rawFilterFunction = static_cast<std::unordered_map<std::string, RawValue>>(rawFilterPrimitive);
     FilterFunction filterFunction{};
-    try {
-      filterFunction.type = filterTypeFromString(rawFilterFunction.begin()->first);
-      if (filterFunction.type == FilterType::DropShadow) {
-        auto rawDropShadow = static_cast<std::unordered_map<std::string, RawValue>>(rawFilterFunction.begin()->second);
-        DropShadowParams dropShadowParams{};
-
-        auto offsetX = rawDropShadow.find("offsetX");
-        react_native_expect(offsetX != rawDropShadow.end());
-        if (offsetX == rawDropShadow.end()) {
-          result = {};
-          return;
-        }
+    auto filterType = filterTypeFromString(rawFilterFunction.begin()->first);
+    if (!filterType.has_value()) {
+      LOG(ERROR) << "Could not parse FilterFunction: " << rawFilterFunction.begin()->first;
+      result = {};
+      return;
+    }
+    filterFunction.type = *filterType;
+    if (filterFunction.type == FilterType::DropShadow) {
+      auto rawDropShadow = static_cast<std::unordered_map<std::string, RawValue>>(rawFilterFunction.begin()->second);
+      DropShadowParams dropShadowParams{};
+
+      auto offsetX = rawDropShadow.find("offsetX");
+      react_native_expect(offsetX != rawDropShadow.end());
+      if (offsetX == rawDropShadow.end()) {
+        result = {};
+        return;
+      }
 
-        react_native_expect(offsetX->second.hasType<Float>());
-        if (!offsetX->second.hasType<Float>()) {
-          result = {};
-          return;
-        }
-        dropShadowParams.offsetX = (Float)offsetX->second;
+      react_native_expect(offsetX->second.hasType<Float>());
+      if (!offsetX->second.hasType<Float>()) {
+        result = {};
+        return;
+      }
+      dropShadowParams.offsetX = (Float)offsetX->second;
 
-        auto offsetY = rawDropShadow.find("offsetY");
-        react_native_expect(offsetY != rawDropShadow.end());
-        if (offsetY == rawDropShadow.end()) {
-          result = {};
-          return;
-        }
-        react_native_expect(offsetY->second.hasType<Float>());
-        if (!offsetY->second.hasType<Float>()) {
+      auto offsetY = rawDropShadow.find("offsetY");
+      react_native_expect(offsetY != rawDropShadow.end());
+      if (offsetY == rawDropShadow.end()) {
+        result = {};
+        return;
+      }
+      react_native_expect(offsetY->second.hasType<Float>());
+      if (!offsetY->second.hasType<Float>()) {
+        result = {};
+        return;
+      }
+      dropShadowParams.offsetY = (Float)offsetY->second;
+
+      auto standardDeviation = rawDropShadow.find("standardDeviation");
+      if (standardDeviation != rawDropShadow.end()) {
+        react_native_expect(standardDeviation->second.hasType<Float>());
+        if (!standardDeviation->second.hasType<Float>()) {
           result = {};
           return;
         }
-        dropShadowParams.offsetY = (Float)offsetY->second;
-
-        auto standardDeviation = rawDropShadow.find("standardDeviation");
-        if (standardDeviation != rawDropShadow.end()) {
-          react_native_expect(standardDeviation->second.hasType<Float>());
-          if (!standardDeviation->second.hasType<Float>()) {
-            result = {};
-            return;
-          }
-          dropShadowParams.standardDeviation = (Float)standardDeviation->second;
-        }
-
-        auto color = rawDropShadow.find("color");
-        if (color != rawDropShadow.end()) {
-          fromRawValue(context.contextContainer, context.surfaceId, color->second, dropShadowParams.color);
-        }
+        dropShadowParams.standardDeviation = (Float)standardDeviation->second;
+      }
 
-        filterFunction.parameters = dropShadowParams;
-      } else {
-        filterFunction.parameters = (float)rawFilterFunction.begin()->second;
+      auto color = rawDropShadow.find("color");
+      if (color != rawDropShadow.end()) {
+        fromRawValue(context.contextContainer, context.surfaceId, color->second, dropShadowParams.color);
       }
-      filter.push_back(std::move(filterFunction));
-    } catch (const std::exception &e) {
-      LOG(ERROR) << "Could not parse FilterFunction: " << e.what();
-      result = {};
-      return;
+
+      filterFunction.parameters = dropShadowParams;
+    } else {
+      filterFunction.parameters = (float)rawFilterFunction.begin()->second;
     }
+    filter.push_back(filterFunction);
   }
 
   result = filter;
 }
 
-inline FilterType filterTypeFromVariant(const CSSFilterFunctionVariant &filter)
+inline FilterType filterTypeFromVariant(const CSSFilterFunction &filter)
 {
   return std::visit(
       [](auto &&filter) -> FilterType {
@@ -148,7 +148,7 @@ inline FilterType filterTypeFromVariant(const CSSFilterFunctionVariant &filter)
       filter);
 }
 
-inline std::optional<FilterFunction> fromCSSFilter(const CSSFilterFunctionVariant &cssFilter)
+inline std::optional<FilterFunction> fromCSSFilter(const CSSFilterFunction &cssFilter)
 {
   return std::visit(
       [&](auto &&filter) -> std::optional<FilterFunction> {
@@ -313,11 +313,15 @@ inline std::optional<FilterFunction> parseFilterRawValue(const PropsParserContex
     }
     return {};
   } else {
+    auto filterType = filterTypeFromString(filterKey);
+    if (!filterType.has_value()) {
+      return {};
+    }
     if (auto amount = coerceAmount(rawFilter.begin()->second)) {
       if (*amount < 0.0f) {
         return {};
       }
-      return FilterFunction{.type = filterTypeFromString(filterKey), .parameters = *amount};
+      return FilterFunction{.type = *filterType, .parameters = *amount};
     }
     return {};
   }

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

@@ -48,6 +48,7 @@ void ViewShadowNode::initialize() noexcept {
   };
 
   bool formsStackingContext = !viewProps.collapsable ||
+      viewProps.pointerEvents == PointerEventsMode::BoxOnly ||
       viewProps.pointerEvents == PointerEventsMode::None ||
       !viewProps.nativeId.empty() || viewProps.accessible ||
       viewProps.opacity != 1.0 || viewProps.transform != Transform{} ||