react-native-tvos 0.64.2-5 → 0.66.3-2

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

@@ -8,7 +8,10 @@
 #pragma once
 
 #include <folly/dynamic.h>
+#include <glog/logging.h>
+#include <react/debug/react_native_assert.h>
 #include <react/renderer/components/view/AccessibilityPrimitives.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/propsConversions.h>
 
 namespace facebook {
@@ -19,7 +22,7 @@ inline void fromString(const std::string &string, AccessibilityTraits &result) {
     result = AccessibilityTraits::None;
     return;
   }
-  if (string == "button") {
+  if (string == "button" || string == "togglebutton") {
     result = AccessibilityTraits::Button;
     return;
   }
@@ -91,37 +94,49 @@ inline void fromString(const std::string &string, AccessibilityTraits &result) {
     result = AccessibilityTraits::Switch;
     return;
   }
+  if (string == "tabbar") {
+    result = AccessibilityTraits::TabBar;
+    return;
+  }
   result = AccessibilityTraits::None;
 }
 
-inline void fromRawValue(const RawValue &value, AccessibilityTraits &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    AccessibilityTraits &result) {
   if (value.hasType<std::string>()) {
     fromString((std::string)value, result);
     return;
   }
 
+  result = {};
+
+  react_native_assert(value.hasType<std::vector<std::string>>());
   if (value.hasType<std::vector<std::string>>()) {
-    result = {};
     auto items = (std::vector<std::string>)value;
     for (auto &item : items) {
       AccessibilityTraits itemAccessibilityTraits;
       fromString(item, itemAccessibilityTraits);
       result = result | itemAccessibilityTraits;
     }
+  } else {
+    LOG(ERROR) << "AccessibilityTraits parsing: unsupported type";
   }
-
-  abort();
 }
 
-inline void fromRawValue(const RawValue &value, AccessibilityState &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    AccessibilityState &result) {
   auto map = (better::map<std::string, RawValue>)value;
   auto selected = map.find("selected");
   if (selected != map.end()) {
-    fromRawValue(selected->second, result.selected);
+    fromRawValue(context, selected->second, result.selected);
   }
   auto disabled = map.find("disabled");
   if (disabled != map.end()) {
-    fromRawValue(disabled->second, result.disabled);
+    fromRawValue(context, disabled->second, result.disabled);
   }
   auto checked = map.find("checked");
   if (checked != map.end()) {
@@ -143,11 +158,11 @@ inline void fromRawValue(const RawValue &value, AccessibilityState &result) {
   }
   auto busy = map.find("busy");
   if (busy != map.end()) {
-    fromRawValue(busy->second, result.busy);
+    fromRawValue(context, busy->second, result.busy);
   }
   auto expanded = map.find("expanded");
   if (expanded != map.end()) {
-    fromRawValue(expanded->second, result.expanded);
+    fromRawValue(context, expanded->second, result.expanded);
   }
 }
 
@@ -166,26 +181,82 @@ inline std::string toString(
 }
 
 inline void fromRawValue(
+    const PropsParserContext &context,
     const RawValue &value,
     ImportantForAccessibility &result) {
-  auto string = (std::string)value;
-  if (string == "auto") {
-    result = ImportantForAccessibility::Auto;
-    return;
+  react_native_assert(value.hasType<std::string>());
+  if (value.hasType<std::string>()) {
+    auto string = (std::string)value;
+    if (string == "auto") {
+      result = ImportantForAccessibility::Auto;
+    } else if (string == "yes") {
+      result = ImportantForAccessibility::Yes;
+    } else if (string == "no") {
+      result = ImportantForAccessibility::No;
+    } else if (string == "no-hide-descendants") {
+      result = ImportantForAccessibility::NoHideDescendants;
+    } else {
+      LOG(ERROR) << "Unsupported ImportantForAccessiblity value: " << string;
+      react_native_assert(false);
+    }
+  } else {
+    LOG(ERROR) << "Unsupported ImportantForAccessiblity type";
   }
-  if (string == "yes") {
-    result = ImportantForAccessibility::Yes;
-    return;
+}
+
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    AccessibilityAction &result) {
+  auto map = (better::map<std::string, RawValue>)value;
+
+  auto name = map.find("name");
+  react_native_assert(name != map.end() && name->second.hasType<std::string>());
+  if (name != map.end()) {
+    fromRawValue(context, name->second, result.name);
   }
-  if (string == "no") {
-    result = ImportantForAccessibility::No;
-    return;
+
+  auto label = map.find("label");
+  if (label != map.end()) {
+    if (label->second.hasType<std::string>()) {
+      result.label = (std::string)label->second;
+    }
   }
-  if (string == "no-hide-descendants") {
-    result = ImportantForAccessibility::NoHideDescendants;
-    return;
+}
+
+inline void fromRawValue(
+    const PropsParserContext &,
+    const RawValue &value,
+    AccessibilityValue &result) {
+  auto map = (better::map<std::string, RawValue>)value;
+
+  auto min = map.find("min");
+  if (min != map.end()) {
+    if (min->second.hasType<int>()) {
+      result.min = (int)min->second;
+    }
+  }
+
+  auto max = map.find("max");
+  if (max != map.end()) {
+    if (max->second.hasType<int>()) {
+      result.max = (int)max->second;
+    }
+  }
+
+  auto now = map.find("now");
+  if (now != map.end()) {
+    if (now->second.hasType<int>()) {
+      result.now = (int)now->second;
+    }
+  }
+
+  auto text = map.find("text");
+  if (text != map.end()) {
+    if (text->second.hasType<std::string>()) {
+      result.text = (std::string)text->second;
+    }
   }
-  abort();
 }
 
 } // namespace react

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

@@ -12,8 +12,10 @@
 #include <folly/Conv.h>
 #include <folly/dynamic.h>
 #include <glog/logging.h>
+#include <react/debug/react_native_assert.h>
 #include <react/renderer/components/view/primitives.h>
 #include <react/renderer/core/LayoutMetrics.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/graphics/Geometry.h>
 #include <react/renderer/graphics/Transform.h>
 #include <stdlib.h>
@@ -47,7 +49,7 @@ inline Float floatFromYogaFloat(float value) {
 }
 
 inline float yogaFloatFromFloat(Float value) {
-  if (std::isinf(value)) {
+  if (!std::isfinite(value)) {
     return YGUndefined;
   }
 
@@ -89,7 +91,7 @@ inline YGFloatOptional yogaOptionalFloatFromFloat(Float value) {
 inline YGValue yogaStyleValueFromFloat(
     const Float &value,
     YGUnit unit = YGUnitPoint) {
-  if (std::isnan(value)) {
+  if (!std::isfinite(value)) {
     return YGValueUndefined;
   }
 
@@ -117,11 +119,13 @@ inline better::optional<Float> optionalFloatFromYogaValue(
 inline LayoutMetrics layoutMetricsFromYogaNode(YGNode &yogaNode) {
   auto layoutMetrics = LayoutMetrics{};
 
-  layoutMetrics.frame =
-      Rect{Point{floatFromYogaFloat(YGNodeLayoutGetLeft(&yogaNode)),
-                 floatFromYogaFloat(YGNodeLayoutGetTop(&yogaNode))},
-           Size{floatFromYogaFloat(YGNodeLayoutGetWidth(&yogaNode)),
-                floatFromYogaFloat(YGNodeLayoutGetHeight(&yogaNode))}};
+  layoutMetrics.frame = Rect{
+      Point{
+          floatFromYogaFloat(YGNodeLayoutGetLeft(&yogaNode)),
+          floatFromYogaFloat(YGNodeLayoutGetTop(&yogaNode))},
+      Size{
+          floatFromYogaFloat(YGNodeLayoutGetWidth(&yogaNode)),
+          floatFromYogaFloat(YGNodeLayoutGetHeight(&yogaNode))}};
 
   layoutMetrics.borderWidth = EdgeInsets{
       floatFromYogaFloat(YGNodeLayoutGetBorder(&yogaNode, YGEdgeLeft)),
@@ -162,8 +166,11 @@ inline YGDirection yogaDirectionFromLayoutDirection(LayoutDirection direction) {
   }
 }
 
-inline void fromRawValue(const RawValue &value, YGDirection &result) {
-  assert(value.hasType<std::string>());
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    YGDirection &result) {
+  react_native_assert(value.hasType<std::string>());
   auto stringValue = (std::string)value;
   if (stringValue == "inherit") {
     result = YGDirectionInherit;
@@ -178,11 +185,14 @@ inline void fromRawValue(const RawValue &value, YGDirection &result) {
     return;
   }
   LOG(FATAL) << "Could not parse YGDirection:" << stringValue;
-  assert(false);
+  react_native_assert(false);
 }
 
-inline void fromRawValue(const RawValue &value, YGFlexDirection &result) {
-  assert(value.hasType<std::string>());
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    YGFlexDirection &result) {
+  react_native_assert(value.hasType<std::string>());
   auto stringValue = (std::string)value;
   if (stringValue == "row") {
     result = YGFlexDirectionRow;
@@ -201,11 +211,14 @@ inline void fromRawValue(const RawValue &value, YGFlexDirection &result) {
     return;
   }
   LOG(FATAL) << "Could not parse YGFlexDirection:" << stringValue;
-  assert(false);
+  react_native_assert(false);
 }
 
-inline void fromRawValue(const RawValue &value, YGJustify &result) {
-  assert(value.hasType<std::string>());
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    YGJustify &result) {
+  react_native_assert(value.hasType<std::string>());
   auto stringValue = (std::string)value;
   if (stringValue == "flex-start") {
     result = YGJustifyFlexStart;
@@ -232,11 +245,14 @@ inline void fromRawValue(const RawValue &value, YGJustify &result) {
     return;
   }
   LOG(FATAL) << "Could not parse YGJustify:" << stringValue;
-  assert(false);
+  react_native_assert(false);
 }
 
-inline void fromRawValue(const RawValue &value, YGAlign &result) {
-  assert(value.hasType<std::string>());
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    YGAlign &result) {
+  react_native_assert(value.hasType<std::string>());
   auto stringValue = (std::string)value;
   if (stringValue == "auto") {
     result = YGAlignAuto;
@@ -271,11 +287,14 @@ inline void fromRawValue(const RawValue &value, YGAlign &result) {
     return;
   }
   LOG(FATAL) << "Could not parse YGAlign:" << stringValue;
-  assert(false);
+  react_native_assert(false);
 }
 
-inline void fromRawValue(const RawValue &value, YGPositionType &result) {
-  assert(value.hasType<std::string>());
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    YGPositionType &result) {
+  react_native_assert(value.hasType<std::string>());
   auto stringValue = (std::string)value;
   if (stringValue == "static") {
     result = YGPositionTypeStatic;
@@ -290,11 +309,14 @@ inline void fromRawValue(const RawValue &value, YGPositionType &result) {
     return;
   }
   LOG(FATAL) << "Could not parse YGPositionType:" << stringValue;
-  assert(false);
+  react_native_assert(false);
 }
 
-inline void fromRawValue(const RawValue &value, YGWrap &result) {
-  assert(value.hasType<std::string>());
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    YGWrap &result) {
+  react_native_assert(value.hasType<std::string>());
   auto stringValue = (std::string)value;
   if (stringValue == "nowrap") {
     result = YGWrapNoWrap;
@@ -309,11 +331,14 @@ inline void fromRawValue(const RawValue &value, YGWrap &result) {
     return;
   }
   LOG(FATAL) << "Could not parse YGWrap:" << stringValue;
-  assert(false);
+  react_native_assert(false);
 }
 
-inline void fromRawValue(const RawValue &value, YGOverflow &result) {
-  assert(value.hasType<std::string>());
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    YGOverflow &result) {
+  react_native_assert(value.hasType<std::string>());
   auto stringValue = (std::string)value;
   if (stringValue == "visible") {
     result = YGOverflowVisible;
@@ -328,11 +353,14 @@ inline void fromRawValue(const RawValue &value, YGOverflow &result) {
     return;
   }
   LOG(FATAL) << "Could not parse YGOverflow:" << stringValue;
-  assert(false);
+  react_native_assert(false);
 }
 
-inline void fromRawValue(const RawValue &value, YGDisplay &result) {
-  assert(value.hasType<std::string>());
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    YGDisplay &result) {
+  react_native_assert(value.hasType<std::string>());
   auto stringValue = (std::string)value;
   if (stringValue == "flex") {
     result = YGDisplayFlex;
@@ -343,10 +371,13 @@ inline void fromRawValue(const RawValue &value, YGDisplay &result) {
     return;
   }
   LOG(FATAL) << "Could not parse YGDisplay:" << stringValue;
-  assert(false);
+  react_native_assert(false);
 }
 
-inline void fromRawValue(const RawValue &value, YGStyle::ValueRepr &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    YGStyle::ValueRepr &result) {
   if (value.hasType<Float>()) {
     result = yogaStyleValueFromFloat((Float)value);
     return;
@@ -370,7 +401,10 @@ inline void fromRawValue(const RawValue &value, YGStyle::ValueRepr &result) {
   result = YGValueUndefined;
 }
 
-inline void fromRawValue(const RawValue &value, YGFloatOptional &result) {
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    YGFloatOptional &result) {
   if (value.hasType<float>()) {
     result = YGFloatOptional((float)value);
     return;
@@ -382,27 +416,30 @@ inline void fromRawValue(const RawValue &value, YGFloatOptional &result) {
     }
   }
   LOG(FATAL) << "Could not parse YGFloatOptional";
-  assert(false);
+  react_native_assert(false);
 }
 
 inline Float toRadians(const RawValue &value) {
   if (value.hasType<Float>()) {
     return (Float)value;
   }
-  assert(value.hasType<std::string>());
+  react_native_assert(value.hasType<std::string>());
   auto stringValue = (std::string)value;
   char *suffixStart;
   double num = strtod(
       stringValue.c_str(), &suffixStart); // can't use std::stod, probably
                                           // because of old Android NDKs
   if (0 == strncmp(suffixStart, "deg", 3)) {
-    return num * M_PI / 180;
+    return static_cast<Float>(num * M_PI / 180.0f);
   }
-  return num; // assume suffix is "rad"
+  return static_cast<Float>(num); // assume suffix is "rad"
 }
 
-inline void fromRawValue(const RawValue &value, Transform &result) {
-  assert(value.hasType<std::vector<RawValue>>());
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    Transform &result) {
+  react_native_assert(value.hasType<std::vector<RawValue>>());
   auto transformMatrix = Transform{};
   auto configurations = static_cast<std::vector<RawValue>>(value);
 
@@ -420,9 +457,9 @@ inline void fromRawValue(const RawValue &value, Transform &result) {
     auto &parameters = pair->second;
 
     if (operation == "matrix") {
-      assert(parameters.hasType<std::vector<Float>>());
+      react_native_assert(parameters.hasType<std::vector<Float>>());
       auto numbers = (std::vector<Float>)parameters;
-      assert(numbers.size() == transformMatrix.matrix.size());
+      react_native_assert(numbers.size() == transformMatrix.matrix.size());
       auto i = 0;
       for (auto number : numbers) {
         transformMatrix.matrix[i++] = number;
@@ -476,8 +513,11 @@ inline void fromRawValue(const RawValue &value, Transform &result) {
   result = transformMatrix;
 }
 
-inline void fromRawValue(const RawValue &value, PointerEventsMode &result) {
-  assert(value.hasType<std::string>());
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    PointerEventsMode &result) {
+  react_native_assert(value.hasType<std::string>());
   auto stringValue = (std::string)value;
   if (stringValue == "auto") {
     result = PointerEventsMode::Auto;
@@ -496,11 +536,14 @@ inline void fromRawValue(const RawValue &value, PointerEventsMode &result) {
     return;
   }
   LOG(FATAL) << "Could not parse PointerEventsMode:" << stringValue;
-  assert(false);
+  react_native_assert(false);
 }
 
-inline void fromRawValue(const RawValue &value, BackfaceVisibility &result) {
-  assert(value.hasType<std::string>());
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    BackfaceVisibility &result) {
+  react_native_assert(value.hasType<std::string>());
   auto stringValue = (std::string)value;
   if (stringValue == "auto") {
     result = BackfaceVisibility::Auto;
@@ -515,11 +558,14 @@ inline void fromRawValue(const RawValue &value, BackfaceVisibility &result) {
     return;
   }
   LOG(FATAL) << "Could not parse BackfaceVisibility:" << stringValue;
-  assert(false);
+  react_native_assert(false);
 }
 
-inline void fromRawValue(const RawValue &value, BorderStyle &result) {
-  assert(value.hasType<std::string>());
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    BorderStyle &result) {
+  react_native_assert(value.hasType<std::string>());
   auto stringValue = (std::string)value;
   if (stringValue == "solid") {
     result = BorderStyle::Solid;
@@ -534,7 +580,7 @@ inline void fromRawValue(const RawValue &value, BorderStyle &result) {
     return;
   }
   LOG(FATAL) << "Could not parse BorderStyle:" << stringValue;
-  assert(false);
+  react_native_assert(false);
 }
 
 inline std::string toString(

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

@@ -38,18 +38,19 @@ struct CascadedRectangleEdges {
   OptionalT all{};
 
   Counterpart resolve(bool isRTL, T defaults) const {
-    const auto leading = isRTL ? end : start;
-    const auto trailing = isRTL ? start : end;
+    const auto leadingEdge = isRTL ? end : start;
+    const auto trailingEdge = isRTL ? start : end;
     const auto horizontalOrAllOrDefault =
         horizontal.value_or(all.value_or(defaults));
     const auto verticalOrAllOrDefault =
         vertical.value_or(all.value_or(defaults));
 
     return {
-        /* .left = */ left.value_or(leading.value_or(horizontalOrAllOrDefault)),
+        /* .left = */
+        left.value_or(leadingEdge.value_or(horizontalOrAllOrDefault)),
         /* .top = */ top.value_or(verticalOrAllOrDefault),
         /* .right = */
-        right.value_or(trailing.value_or(horizontalOrAllOrDefault)),
+        right.value_or(trailingEdge.value_or(horizontalOrAllOrDefault)),
         /* .bottom = */ bottom.value_or(verticalOrAllOrDefault),
     };
   }
@@ -177,5 +178,39 @@ struct BorderMetrics {
   }
 };
 
+#if TARGET_OS_TV
+
+struct TVParallaxProperties {
+  better::optional<bool> enabled{};
+  better::optional<float> shiftDistanceX{};
+  better::optional<float> shiftDistanceY{};
+  better::optional<float> tiltAngle{};
+  better::optional<float> magnification{};
+  better::optional<float> pressMagnification{};
+  better::optional<float> pressDuration{};
+  better::optional<float> pressDelay{};
+};
+
+constexpr bool operator==(
+    TVParallaxProperties const &lhs,
+    TVParallaxProperties const &rhs) {
+  return lhs.enabled == rhs.enabled &&
+    lhs.shiftDistanceX == rhs.shiftDistanceX &&
+    lhs.shiftDistanceY == rhs.shiftDistanceY &&
+    lhs.tiltAngle == rhs.tiltAngle &&
+    lhs.magnification == rhs.magnification &&
+    lhs.pressMagnification == rhs.pressMagnification &&
+    lhs.pressDuration == rhs.pressDuration &&
+    lhs.pressDelay == rhs.pressDelay;
+}
+
+constexpr bool operator!=(
+    TVParallaxProperties const &lhs,
+    TVParallaxProperties const &rhs) {
+  return !(rhs == lhs);
+}
+
+#endif
+
 } // namespace react
 } // namespace facebook