react-native 0.71.3 → 0.72.0-rc.0

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

@@ -11,11 +11,11 @@
 #include <folly/Conv.h>
 #include <folly/dynamic.h>
 #include <glog/logging.h>
-#include <react/debug/react_native_assert.h>
+#include <react/config/ReactNativeConfig.h>
+#include <react/debug/react_native_expect.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>
 #include <yoga/YGEnums.h>
@@ -169,7 +169,11 @@ inline void fromRawValue(
     const PropsParserContext &context,
     const RawValue &value,
     YGDirection &result) {
-  react_native_assert(value.hasType<std::string>());
+  result = YGDirectionInherit;
+  react_native_expect(value.hasType<std::string>());
+  if (!value.hasType<std::string>()) {
+    return;
+  }
   auto stringValue = (std::string)value;
   if (stringValue == "inherit") {
     result = YGDirectionInherit;
@@ -183,15 +187,19 @@ inline void fromRawValue(
     result = YGDirectionRTL;
     return;
   }
-  LOG(FATAL) << "Could not parse YGDirection:" << stringValue;
-  react_native_assert(false);
+  LOG(ERROR) << "Could not parse YGDirection:" << stringValue;
+  react_native_expect(false);
 }
 
 inline void fromRawValue(
     const PropsParserContext &context,
     const RawValue &value,
     YGFlexDirection &result) {
-  react_native_assert(value.hasType<std::string>());
+  result = YGFlexDirectionColumn;
+  react_native_expect(value.hasType<std::string>());
+  if (!value.hasType<std::string>()) {
+    return;
+  }
   auto stringValue = (std::string)value;
   if (stringValue == "row") {
     result = YGFlexDirectionRow;
@@ -209,15 +217,19 @@ inline void fromRawValue(
     result = YGFlexDirectionRowReverse;
     return;
   }
-  LOG(FATAL) << "Could not parse YGFlexDirection:" << stringValue;
-  react_native_assert(false);
+  LOG(ERROR) << "Could not parse YGFlexDirection:" << stringValue;
+  react_native_expect(false);
 }
 
 inline void fromRawValue(
     const PropsParserContext &context,
     const RawValue &value,
     YGJustify &result) {
-  react_native_assert(value.hasType<std::string>());
+  result = YGJustifyFlexStart;
+  react_native_expect(value.hasType<std::string>());
+  if (!value.hasType<std::string>()) {
+    return;
+  }
   auto stringValue = (std::string)value;
   if (stringValue == "flex-start") {
     result = YGJustifyFlexStart;
@@ -243,15 +255,19 @@ inline void fromRawValue(
     result = YGJustifySpaceEvenly;
     return;
   }
-  LOG(FATAL) << "Could not parse YGJustify:" << stringValue;
-  react_native_assert(false);
+  LOG(ERROR) << "Could not parse YGJustify:" << stringValue;
+  react_native_expect(false);
 }
 
 inline void fromRawValue(
     const PropsParserContext &context,
     const RawValue &value,
     YGAlign &result) {
-  react_native_assert(value.hasType<std::string>());
+  result = YGAlignStretch;
+  react_native_expect(value.hasType<std::string>());
+  if (!value.hasType<std::string>()) {
+    return;
+  }
   auto stringValue = (std::string)value;
   if (stringValue == "auto") {
     result = YGAlignAuto;
@@ -285,15 +301,19 @@ inline void fromRawValue(
     result = YGAlignSpaceAround;
     return;
   }
-  LOG(FATAL) << "Could not parse YGAlign:" << stringValue;
-  react_native_assert(false);
+  LOG(ERROR) << "Could not parse YGAlign:" << stringValue;
+  react_native_expect(false);
 }
 
 inline void fromRawValue(
     const PropsParserContext &context,
     const RawValue &value,
     YGPositionType &result) {
-  react_native_assert(value.hasType<std::string>());
+  result = YGPositionTypeRelative;
+  react_native_expect(value.hasType<std::string>());
+  if (!value.hasType<std::string>()) {
+    return;
+  }
   auto stringValue = (std::string)value;
   if (stringValue == "static") {
     result = YGPositionTypeStatic;
@@ -307,15 +327,19 @@ inline void fromRawValue(
     result = YGPositionTypeAbsolute;
     return;
   }
-  LOG(FATAL) << "Could not parse YGPositionType:" << stringValue;
-  react_native_assert(false);
+  LOG(ERROR) << "Could not parse YGPositionType:" << stringValue;
+  react_native_expect(false);
 }
 
 inline void fromRawValue(
     const PropsParserContext &context,
     const RawValue &value,
     YGWrap &result) {
-  react_native_assert(value.hasType<std::string>());
+  result = YGWrapNoWrap;
+  react_native_expect(value.hasType<std::string>());
+  if (!value.hasType<std::string>()) {
+    return;
+  }
   auto stringValue = (std::string)value;
   if (stringValue == "nowrap") {
     result = YGWrapNoWrap;
@@ -329,15 +353,19 @@ inline void fromRawValue(
     result = YGWrapWrapReverse;
     return;
   }
-  LOG(FATAL) << "Could not parse YGWrap:" << stringValue;
-  react_native_assert(false);
+  LOG(ERROR) << "Could not parse YGWrap:" << stringValue;
+  react_native_expect(false);
 }
 
 inline void fromRawValue(
     const PropsParserContext &context,
     const RawValue &value,
     YGOverflow &result) {
-  react_native_assert(value.hasType<std::string>());
+  result = YGOverflowVisible;
+  react_native_expect(value.hasType<std::string>());
+  if (!value.hasType<std::string>()) {
+    return;
+  }
   auto stringValue = (std::string)value;
   if (stringValue == "visible") {
     result = YGOverflowVisible;
@@ -351,15 +379,19 @@ inline void fromRawValue(
     result = YGOverflowScroll;
     return;
   }
-  LOG(FATAL) << "Could not parse YGOverflow:" << stringValue;
-  react_native_assert(false);
+  LOG(ERROR) << "Could not parse YGOverflow:" << stringValue;
+  react_native_expect(false);
 }
 
 inline void fromRawValue(
     const PropsParserContext &context,
     const RawValue &value,
     YGDisplay &result) {
-  react_native_assert(value.hasType<std::string>());
+  result = YGDisplayFlex;
+  react_native_expect(value.hasType<std::string>());
+  if (!value.hasType<std::string>()) {
+    return;
+  }
   auto stringValue = (std::string)value;
   if (stringValue == "flex") {
     result = YGDisplayFlex;
@@ -369,28 +401,36 @@ inline void fromRawValue(
     result = YGDisplayNone;
     return;
   }
-  LOG(FATAL) << "Could not parse YGDisplay:" << stringValue;
-  react_native_assert(false);
+  LOG(ERROR) << "Could not parse YGDisplay:" << stringValue;
+  react_native_expect(false);
 }
 
 inline void fromRawValue(
     const PropsParserContext &context,
     const RawValue &value,
     YGStyle::ValueRepr &result) {
+  // For bug compatibility, pass "auto" as YGValueUndefined
+  static bool treatAutoAsUndefined =
+      context.contextContainer
+          .at<std::shared_ptr<ReactNativeConfig const>>("ReactNativeConfig")
+          ->getBool("react_fabric:treat_auto_as_undefined");
+
   if (value.hasType<Float>()) {
     result = yogaStyleValueFromFloat((Float)value);
     return;
   } else if (value.hasType<std::string>()) {
     const auto stringValue = (std::string)value;
     if (stringValue == "auto") {
-      result = YGValueUndefined;
+      result = treatAutoAsUndefined ? YGValueUndefined : YGValueAuto;
       return;
     } else {
       if (stringValue.back() == '%') {
-        result = YGValue{
-            folly::to<float>(stringValue.substr(0, stringValue.length() - 1)),
-            YGUnitPercent};
-        return;
+        auto tryValue = folly::tryTo<float>(
+            std::string_view(stringValue).substr(0, stringValue.length() - 1));
+        if (tryValue.hasValue()) {
+          result = YGValue{tryValue.value(), YGUnitPercent};
+          return;
+        }
       } else {
         auto tryValue = folly::tryTo<float>(stringValue);
         if (tryValue.hasValue()) {
@@ -403,6 +443,15 @@ inline void fromRawValue(
   result = YGValueUndefined;
 }
 
+inline void fromRawValue(
+    const PropsParserContext &context,
+    const RawValue &value,
+    YGValue &result) {
+  YGStyle::ValueRepr ygValue{};
+  fromRawValue(context, value, ygValue);
+  result = ygValue;
+}
+
 inline void fromRawValue(
     const PropsParserContext &context,
     const RawValue &value,
@@ -417,15 +466,20 @@ inline void fromRawValue(
       return;
     }
   }
-  LOG(FATAL) << "Could not parse YGFloatOptional";
-  react_native_assert(false);
+  LOG(ERROR) << "Could not parse YGFloatOptional";
+  react_native_expect(false);
 }
 
-inline Float toRadians(const RawValue &value) {
+inline Float toRadians(
+    const RawValue &value,
+    std::optional<Float> defaultValue) {
   if (value.hasType<Float>()) {
     return (Float)value;
   }
-  react_native_assert(value.hasType<std::string>());
+  react_native_expect(value.hasType<std::string>());
+  if (!value.hasType<std::string>() && defaultValue.has_value()) {
+    return *defaultValue;
+  }
   auto stringValue = (std::string)value;
   char *suffixStart;
   double num = strtod(
@@ -441,10 +495,14 @@ 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);
+  react_native_expect(value.hasType<std::vector<RawValue>>());
+  if (!value.hasType<std::vector<RawValue>>()) {
+    result = transformMatrix;
+    return;
+  }
 
+  auto configurations = static_cast<std::vector<RawValue>>(value);
   for (const auto &configuration : configurations) {
     if (!configuration.hasType<butter::map<std::string, RawValue>>()) {
       // TODO: The following checks have to be removed after codegen is shipped.
@@ -459,9 +517,9 @@ inline void fromRawValue(
     auto &parameters = pair->second;
 
     if (operation == "matrix") {
-      react_native_assert(parameters.hasType<std::vector<Float>>());
+      react_native_expect(parameters.hasType<std::vector<Float>>());
       auto numbers = (std::vector<Float>)parameters;
-      react_native_assert(numbers.size() == transformMatrix.matrix.size());
+      react_native_expect(numbers.size() == transformMatrix.matrix.size());
       auto i = 0;
       for (auto number : numbers) {
         transformMatrix.matrix[i++] = number;
@@ -472,14 +530,14 @@ inline void fromRawValue(
       transformMatrix =
           transformMatrix * Transform::Perspective((Float)parameters);
     } else if (operation == "rotateX") {
-      transformMatrix =
-          transformMatrix * Transform::Rotate(toRadians(parameters), 0, 0);
+      transformMatrix = transformMatrix *
+          Transform::Rotate(toRadians(parameters, 0.0f), 0, 0);
     } else if (operation == "rotateY") {
-      transformMatrix =
-          transformMatrix * Transform::Rotate(0, toRadians(parameters), 0);
+      transformMatrix = transformMatrix *
+          Transform::Rotate(0, toRadians(parameters, 0.0f), 0);
     } else if (operation == "rotateZ" || operation == "rotate") {
-      transformMatrix =
-          transformMatrix * Transform::Rotate(0, 0, toRadians(parameters));
+      transformMatrix = transformMatrix *
+          Transform::Rotate(0, 0, toRadians(parameters, 0.0f));
     } else if (operation == "scale") {
       auto number = (Float)parameters;
       transformMatrix =
@@ -505,10 +563,10 @@ inline void fromRawValue(
           transformMatrix * Transform::Translate(0, (Float)parameters, 0);
     } else if (operation == "skewX") {
       transformMatrix =
-          transformMatrix * Transform::Skew(toRadians(parameters), 0);
+          transformMatrix * Transform::Skew(toRadians(parameters, 0.0f), 0);
     } else if (operation == "skewY") {
       transformMatrix =
-          transformMatrix * Transform::Skew(0, toRadians(parameters));
+          transformMatrix * Transform::Skew(0, toRadians(parameters, 0.0f));
     }
   }
 
@@ -519,7 +577,11 @@ inline void fromRawValue(
     const PropsParserContext &context,
     const RawValue &value,
     PointerEventsMode &result) {
-  react_native_assert(value.hasType<std::string>());
+  result = PointerEventsMode::Auto;
+  react_native_expect(value.hasType<std::string>());
+  if (!value.hasType<std::string>()) {
+    return;
+  }
   auto stringValue = (std::string)value;
   if (stringValue == "auto") {
     result = PointerEventsMode::Auto;
@@ -537,15 +599,19 @@ inline void fromRawValue(
     result = PointerEventsMode::BoxOnly;
     return;
   }
-  LOG(FATAL) << "Could not parse PointerEventsMode:" << stringValue;
-  react_native_assert(false);
+  LOG(ERROR) << "Could not parse PointerEventsMode:" << stringValue;
+  react_native_expect(false);
 }
 
 inline void fromRawValue(
     const PropsParserContext &context,
     const RawValue &value,
     BackfaceVisibility &result) {
-  react_native_assert(value.hasType<std::string>());
+  result = BackfaceVisibility::Auto;
+  react_native_expect(value.hasType<std::string>());
+  if (!value.hasType<std::string>()) {
+    return;
+  }
   auto stringValue = (std::string)value;
   if (stringValue == "auto") {
     result = BackfaceVisibility::Auto;
@@ -559,15 +625,19 @@ inline void fromRawValue(
     result = BackfaceVisibility::Hidden;
     return;
   }
-  LOG(FATAL) << "Could not parse BackfaceVisibility:" << stringValue;
-  react_native_assert(false);
+  LOG(ERROR) << "Could not parse BackfaceVisibility:" << stringValue;
+  react_native_expect(false);
 }
 
 inline void fromRawValue(
     const PropsParserContext &context,
     const RawValue &value,
     BorderCurve &result) {
-  react_native_assert(value.hasType<std::string>());
+  result = BorderCurve::Circular;
+  react_native_expect(value.hasType<std::string>());
+  if (!value.hasType<std::string>()) {
+    return;
+  }
   auto stringValue = (std::string)value;
   if (stringValue == "circular") {
     result = BorderCurve::Circular;
@@ -577,15 +647,19 @@ inline void fromRawValue(
     result = BorderCurve::Continuous;
     return;
   }
-  LOG(FATAL) << "Could not parse BorderCurve:" << stringValue;
-  react_native_assert(false);
+  LOG(ERROR) << "Could not parse BorderCurve:" << stringValue;
+  react_native_expect(false);
 }
 
 inline void fromRawValue(
     const PropsParserContext &context,
     const RawValue &value,
     BorderStyle &result) {
-  react_native_assert(value.hasType<std::string>());
+  result = BorderStyle::Solid;
+  react_native_expect(value.hasType<std::string>());
+  if (!value.hasType<std::string>()) {
+    return;
+  }
   auto stringValue = (std::string)value;
   if (stringValue == "solid") {
     result = BorderStyle::Solid;
@@ -599,8 +673,8 @@ inline void fromRawValue(
     result = BorderStyle::Dashed;
     return;
   }
-  LOG(FATAL) << "Could not parse BorderStyle:" << stringValue;
-  react_native_assert(false);
+  LOG(ERROR) << "Could not parse BorderStyle:" << stringValue;
+  react_native_expect(false);
 }
 
 inline std::string toString(

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

@@ -8,7 +8,8 @@
 #pragma once
 
 #include <react/renderer/graphics/Color.h>
-#include <react/renderer/graphics/Geometry.h>
+#include <react/renderer/graphics/RectangleCorners.h>
+#include <react/renderer/graphics/RectangleEdges.h>
 
 #include <array>
 #include <bitset>
@@ -18,7 +19,7 @@
 namespace facebook {
 namespace react {
 
-enum class PointerEventsMode { Auto, None, BoxNone, BoxOnly };
+enum class PointerEventsMode : uint8_t { Auto, None, BoxNone, BoxOnly };
 
 struct ViewEvents {
   std::bitset<32> bits{};
@@ -78,11 +79,11 @@ inline static bool operator!=(ViewEvents const &lhs, ViewEvents const &rhs) {
   return lhs.bits != rhs.bits;
 }
 
-enum class BackfaceVisibility { Auto, Visible, Hidden };
+enum class BackfaceVisibility : uint8_t { Auto, Visible, Hidden };
 
-enum class BorderCurve { Circular, Continuous };
+enum class BorderCurve : uint8_t { Circular, Continuous };
 
-enum class BorderStyle { Solid, Dotted, Dashed };
+enum class BorderStyle : uint8_t { Solid, Dotted, Dashed };
 
 template <typename T>
 struct CascadedRectangleEdges {
@@ -98,6 +99,9 @@ struct CascadedRectangleEdges {
   OptionalT horizontal{};
   OptionalT vertical{};
   OptionalT all{};
+  OptionalT block{};
+  OptionalT blockStart{};
+  OptionalT blockEnd{};
 
   Counterpart resolve(bool isRTL, T defaults) const {
     const auto leadingEdge = isRTL ? end : start;
@@ -110,10 +114,14 @@ struct CascadedRectangleEdges {
     return {
         /* .left = */
         left.value_or(leadingEdge.value_or(horizontalOrAllOrDefault)),
-        /* .top = */ top.value_or(verticalOrAllOrDefault),
+        /* .top = */
+        blockStart.value_or(
+            block.value_or(top.value_or(verticalOrAllOrDefault))),
         /* .right = */
         right.value_or(trailingEdge.value_or(horizontalOrAllOrDefault)),
-        /* .bottom = */ bottom.value_or(verticalOrAllOrDefault),
+        /* .bottom = */
+        blockEnd.value_or(
+            block.value_or(bottom.value_or(verticalOrAllOrDefault))),
     };
   }
 
@@ -127,7 +135,10 @@ struct CascadedRectangleEdges {
                this->end,
                this->horizontal,
                this->vertical,
-               this->all) ==
+               this->all,
+               this->block,
+               this->blockStart,
+               this->blockEnd) ==
         std::tie(
                rhs.left,
                rhs.top,
@@ -137,7 +148,10 @@ struct CascadedRectangleEdges {
                rhs.end,
                rhs.horizontal,
                rhs.vertical,
-               rhs.all);
+               rhs.all,
+               rhs.block,
+               rhs.blockStart,
+               rhs.blockEnd);
   }
 
   bool operator!=(const CascadedRectangleEdges<T> &rhs) const {
@@ -159,12 +173,21 @@ struct CascadedRectangleCorners {
   OptionalT bottomStart{};
   OptionalT bottomEnd{};
   OptionalT all{};
+  OptionalT endEnd{};
+  OptionalT endStart{};
+  OptionalT startEnd{};
+  OptionalT startStart{};
 
   Counterpart resolve(bool isRTL, T defaults) const {
-    const auto topLeading = isRTL ? topEnd : topStart;
-    const auto topTrailing = isRTL ? topStart : topEnd;
-    const auto bottomLeading = isRTL ? bottomEnd : bottomStart;
-    const auto bottomTrailing = isRTL ? bottomStart : bottomEnd;
+    const auto logicalTopStart = topStart ? topStart : startStart;
+    const auto logicalTopEnd = topEnd ? topEnd : startEnd;
+    const auto logicalBottomStart = bottomStart ? bottomStart : endStart;
+    const auto logicalBottomEnd = bottomEnd ? bottomEnd : endEnd;
+
+    const auto topLeading = isRTL ? logicalTopEnd : logicalTopStart;
+    const auto topTrailing = isRTL ? logicalTopStart : logicalTopEnd;
+    const auto bottomLeading = isRTL ? logicalBottomEnd : logicalBottomStart;
+    const auto bottomTrailing = isRTL ? logicalBottomStart : logicalBottomEnd;
 
     return {
         /* .topLeft = */ topLeft.value_or(
@@ -188,7 +211,11 @@ struct CascadedRectangleCorners {
                this->topEnd,
                this->bottomStart,
                this->bottomEnd,
-               this->all) ==
+               this->all,
+               this->endEnd,
+               this->endStart,
+               this->startEnd,
+               this->startStart) ==
         std::tie(
                rhs.topLeft,
                rhs.topRight,
@@ -198,7 +225,11 @@ struct CascadedRectangleCorners {
                rhs.topEnd,
                rhs.bottomStart,
                rhs.bottomEnd,
-               rhs.all);
+               rhs.all,
+               rhs.endEnd,
+               rhs.endStart,
+               rhs.startEnd,
+               rhs.startStart);
   }
 
   bool operator!=(const CascadedRectangleCorners<T> &rhs) const {
@@ -248,15 +279,15 @@ struct BorderMetrics {
 #ifdef ANDROID
 
 struct NativeDrawable {
-  enum class Kind {
+  enum class Kind : uint8_t {
     Ripple,
     ThemeAttr,
   };
 
   struct Ripple {
     std::optional<int32_t> color{};
-    bool borderless{false};
     std::optional<Float> rippleRadius{};
+    bool borderless{false};
 
     bool operator==(const Ripple &rhs) const {
       return std::tie(this->color, this->borderless, this->rippleRadius) ==
@@ -264,9 +295,9 @@ struct NativeDrawable {
     }
   };
 
-  Kind kind;
   std::string themeAttr;
   Ripple ripple;
+  Kind kind;
 
   bool operator==(const NativeDrawable &rhs) const {
     if (this->kind != rhs.kind)