react-native-tvos 0.82.1-0 → 0.83.0-0

package/ReactCommon/react/renderer/core/LayoutConstraints.h

@@ -19,29 +19,25 @@ namespace facebook::react {
  * Unified layout constraints for measuring.
  */
 struct LayoutConstraints {
-  Size minimumSize{0, 0};
-  Size maximumSize{
-      std::numeric_limits<Float>::infinity(),
-      std::numeric_limits<Float>::infinity()};
+  Size minimumSize{.width = 0, .height = 0};
+  Size maximumSize{.width = std::numeric_limits<Float>::infinity(), .height = std::numeric_limits<Float>::infinity()};
   LayoutDirection layoutDirection{LayoutDirection::Undefined};
 
   /*
    * Clamps the provided `Size` between the `minimumSize` and `maximumSize`
    * bounds of this `LayoutConstraints`.
    */
-  Size clamp(const Size& size) const;
+  Size clamp(const Size &size) const;
 };
 
-inline bool operator==(
-    const LayoutConstraints& lhs,
-    const LayoutConstraints& rhs) {
+inline bool operator==(const LayoutConstraints &lhs, const LayoutConstraints &rhs)
+{
   return std::tie(lhs.minimumSize, lhs.maximumSize, lhs.layoutDirection) ==
       std::tie(rhs.minimumSize, rhs.maximumSize, rhs.layoutDirection);
 }
 
-inline bool operator!=(
-    const LayoutConstraints& lhs,
-    const LayoutConstraints& rhs) {
+inline bool operator!=(const LayoutConstraints &lhs, const LayoutConstraints &rhs)
+{
   return !(lhs == rhs);
 }
 
@@ -50,12 +46,9 @@ inline bool operator!=(
 namespace std {
 template <>
 struct hash<facebook::react::LayoutConstraints> {
-  size_t operator()(
-      const facebook::react::LayoutConstraints& constraints) const {
-    return facebook::react::hash_combine(
-        constraints.minimumSize,
-        constraints.maximumSize,
-        constraints.layoutDirection);
+  size_t operator()(const facebook::react::LayoutConstraints &constraints) const
+  {
+    return facebook::react::hash_combine(constraints.minimumSize, constraints.maximumSize, constraints.layoutDirection);
   }
 };
 } // namespace std

package/ReactCommon/react/renderer/core/LayoutContext.h

@@ -33,7 +33,7 @@ struct LayoutContext {
    * list. The order is not specified. Nothing in this collection is owing (on
    * purpose), make sure the memory is managed responsibly.
    */
-  std::vector<const LayoutableShadowNode*>* affectedNodes{};
+  std::vector<const LayoutableShadowNode *> *affectedNodes{};
 
   /*
    * Flag indicating whether in reassignment of direction
@@ -61,7 +61,8 @@ struct LayoutContext {
   Point viewportOffset{};
 };
 
-inline bool operator==(const LayoutContext& lhs, const LayoutContext& rhs) {
+inline bool operator==(const LayoutContext &lhs, const LayoutContext &rhs)
+{
   return std::tie(
              lhs.pointScaleFactor,
              lhs.affectedNodes,
@@ -76,7 +77,8 @@ inline bool operator==(const LayoutContext& lhs, const LayoutContext& rhs) {
              rhs.viewportOffset);
 }
 
-inline bool operator!=(const LayoutContext& lhs, const LayoutContext& rhs) {
+inline bool operator!=(const LayoutContext &lhs, const LayoutContext &rhs)
+{
   return !(lhs == rhs);
 }
 

package/ReactCommon/react/renderer/core/LayoutMetrics.cpp

@@ -22,39 +22,39 @@ std::vector<DebugStringConvertibleObject> getDebugProps(
     const LayoutMetrics& object,
     DebugStringConvertibleOptions options) {
   return {
-      {"frame",
-       "{x:" + getDebugDescription(object.frame.origin.x, {}) +
+      {.name = "frame",
+       .value = "{x:" + getDebugDescription(object.frame.origin.x, {}) +
            ",y:" + getDebugDescription(object.frame.origin.y, {}) +
            ",width:" + getDebugDescription(object.frame.size.width, {}) +
            ",height:" + getDebugDescription(object.frame.size.height, {}) +
            "}"},
-      {"contentInsets",
-       "{top:" + getDebugDescription(object.contentInsets.top, {}) +
+      {.name = "contentInsets",
+       .value = "{top:" + getDebugDescription(object.contentInsets.top, {}) +
            ",right:" + getDebugDescription(object.contentInsets.right, {}) +
            ",bottom:" + getDebugDescription(object.contentInsets.bottom, {}) +
            ",left:" + getDebugDescription(object.contentInsets.left, {}) + "}"},
-      {"borderWidth",
-       "{top:" + getDebugDescription(object.borderWidth.top, {}) +
+      {.name = "borderWidth",
+       .value = "{top:" + getDebugDescription(object.borderWidth.top, {}) +
            ",right:" + getDebugDescription(object.borderWidth.right, {}) +
            ",bottom:" + getDebugDescription(object.borderWidth.bottom, {}) +
            ",left:" + getDebugDescription(object.borderWidth.left, {}) + "}"},
-      {"overflowInset",
-       "{top:" + getDebugDescription(object.overflowInset.top, {}) +
+      {.name = "overflowInset",
+       .value = "{top:" + getDebugDescription(object.overflowInset.top, {}) +
            ",right:" + getDebugDescription(object.overflowInset.right, {}) +
            ",bottom:" + getDebugDescription(object.overflowInset.bottom, {}) +
            ",left:" + getDebugDescription(object.overflowInset.left, {}) + "}"},
-      {"displayType",
-       object.displayType == DisplayType::None
+      {.name = "displayType",
+       .value = object.displayType == DisplayType::None
            ? "None"
            : (object.displayType == DisplayType::Flex ? "Flex" : "Inline")},
-      {"layoutDirection",
-       object.layoutDirection == LayoutDirection::Undefined
+      {.name = "layoutDirection",
+       .value = object.layoutDirection == LayoutDirection::Undefined
            ? "Undefined"
            : (object.layoutDirection == LayoutDirection::LeftToRight
                   ? "LeftToRight"
                   : "RightToLeft")},
-      {"pointScaleFactor",
-       getDebugDescription(object.pointScaleFactor, options)},
+      {.name = "pointScaleFactor",
+       .value = getDebugDescription(object.pointScaleFactor, options)},
   };
 }
 

package/ReactCommon/react/renderer/core/LayoutMetrics.h

@@ -48,42 +48,46 @@ struct LayoutMetrics {
 
   // Origin: the outer border of the node.
   // Size: includes content only.
-  Rect getContentFrame() const {
+  Rect getContentFrame() const
+  {
     return Rect{
-        Point{contentInsets.left, contentInsets.top},
-        Size{
-            frame.size.width - contentInsets.left - contentInsets.right,
-            frame.size.height - contentInsets.top - contentInsets.bottom}};
+        .origin = Point{.x = contentInsets.left, .y = contentInsets.top},
+        .size = Size{
+            .width = frame.size.width - contentInsets.left - contentInsets.right,
+            .height = frame.size.height - contentInsets.top - contentInsets.bottom}};
   }
 
   // Calculates the frame of the node including overflow insets.
   // If the frame was drawn on screen, it would include all the children of the
   // node (and their children, recursively).
-  Rect getOverflowInsetFrame() const {
+  Rect getOverflowInsetFrame() const
+  {
     return Rect{
-        Point{
-            frame.origin.x + std::min(Float{0}, overflowInset.left),
-            frame.origin.y + std::min(Float{0}, overflowInset.top)},
-        Size{
-            frame.size.width - std::min(Float{0}, overflowInset.left) +
-                -std::min(Float{0}, overflowInset.right),
-            frame.size.height - std::min(Float{0}, overflowInset.top) +
-                -std::min(Float{0}, overflowInset.bottom)}};
+        .origin =
+            Point{
+                .x = frame.origin.x + std::min(Float{0}, overflowInset.left),
+                .y = frame.origin.y + std::min(Float{0}, overflowInset.top)},
+        .size = Size{
+            .width =
+                frame.size.width - std::min(Float{0}, overflowInset.left) + -std::min(Float{0}, overflowInset.right),
+            .height =
+                frame.size.height - std::min(Float{0}, overflowInset.top) + -std::min(Float{0}, overflowInset.bottom)}};
   }
 
   // Origin: the outer border of the node.
   // Size: includes content and padding (but no borders).
-  Rect getPaddingFrame() const {
+  Rect getPaddingFrame() const
+  {
     return Rect{
-        Point{borderWidth.left, borderWidth.top},
-        Size{
-            frame.size.width - borderWidth.left - borderWidth.right,
-            frame.size.height - borderWidth.top - borderWidth.bottom}};
+        .origin = Point{.x = borderWidth.left, .y = borderWidth.top},
+        .size = Size{
+            .width = frame.size.width - borderWidth.left - borderWidth.right,
+            .height = frame.size.height - borderWidth.top - borderWidth.bottom}};
   }
 
-  bool operator==(const LayoutMetrics& rhs) const = default;
+  bool operator==(const LayoutMetrics &rhs) const = default;
 
-  bool operator!=(const LayoutMetrics& rhs) const = default;
+  bool operator!=(const LayoutMetrics &rhs) const = default;
 };
 
 /*
@@ -92,13 +96,13 @@ struct LayoutMetrics {
  * The value is comparable by equality with any other `LayoutMetrics` value.
  */
 static const LayoutMetrics EmptyLayoutMetrics = {
-    /* .frame = */ {{0, 0}, {-1.0, -1.0}}};
+    /* .frame = */ .frame = {.origin = {.x = 0, .y = 0}, .size = {.width = -1.0, .height = -1.0}}};
 
 #if RN_DEBUG_STRING_CONVERTIBLE
 
-std::string getDebugName(const LayoutMetrics& object);
+std::string getDebugName(const LayoutMetrics &object);
 std::vector<DebugStringConvertibleObject> getDebugProps(
-    const LayoutMetrics& object,
+    const LayoutMetrics &object,
     DebugStringConvertibleOptions options);
 
 #endif
@@ -109,7 +113,8 @@ namespace std {
 
 template <>
 struct hash<facebook::react::LayoutMetrics> {
-  size_t operator()(const facebook::react::LayoutMetrics& layoutMetrics) const {
+  size_t operator()(const facebook::react::LayoutMetrics &layoutMetrics) const
+  {
     return facebook::react::hash_combine(
         layoutMetrics.frame,
         layoutMetrics.contentInsets,

package/ReactCommon/react/renderer/core/LayoutableShadowNode.cpp

@@ -29,8 +29,9 @@ LayoutableShadowNode::LayoutableShadowNode(
     const ShadowNode& sourceShadowNode,
     const ShadowNodeFragment& fragment)
     : ShadowNode(sourceShadowNode, fragment),
-      layoutMetrics_(static_cast<const LayoutableShadowNode&>(sourceShadowNode)
-                         .layoutMetrics_) {}
+      layoutMetrics_(
+          static_cast<const LayoutableShadowNode&>(sourceShadowNode)
+              .layoutMetrics_) {}
 
 LayoutMetrics LayoutableShadowNode::computeLayoutMetricsFromRoot(
     const ShadowNodeFamily& descendantNodeFamily,
@@ -70,7 +71,7 @@ LayoutMetrics LayoutableShadowNode::computeRelativeLayoutMetrics(
     if (policy.includeTransform) {
       layoutMetrics.frame = layoutMetrics.frame * ancestorNode.getTransform();
     }
-    layoutMetrics.frame.origin = {0, 0};
+    layoutMetrics.frame.origin = {.x = 0, .y = 0};
     return layoutMetrics;
   }
 
@@ -130,7 +131,7 @@ LayoutMetrics LayoutableShadowNode::computeRelativeLayoutMetrics(
 
   auto layoutMetrics = descendantLayoutableNode->getLayoutMetrics();
   auto& resultFrame = layoutMetrics.frame;
-  resultFrame.origin = {0, 0};
+  resultFrame.origin = {.x = 0, .y = 0};
 
   // Step 3.
   // Iterating on a list of nodes computing compound offset and size.
@@ -152,7 +153,7 @@ LayoutMetrics LayoutableShadowNode::computeRelativeLayoutMetrics(
     auto currentFrame = currentShadowNode->getLayoutMetrics().frame;
     if (i == size - 1) {
       // If it's the last element, its origin is irrelevant.
-      currentFrame.origin = {0, 0};
+      currentFrame.origin = {.x = 0, .y = 0};
     }
 
     auto isRootNode = currentShadowNode->getTraits().check(
@@ -216,7 +217,7 @@ Transform LayoutableShadowNode::getTransform() const {
 
 Point LayoutableShadowNode::getContentOriginOffset(
     bool /*includeTransform*/) const {
-  return {0, 0};
+  return {.x = 0, .y = 0};
 }
 
 bool LayoutableShadowNode::canBeTouchTarget() const {
@@ -356,17 +357,20 @@ SharedDebugStringConvertibleList LayoutableShadowNode::getDebugProps() const {
   auto layoutMetrics = getLayoutMetrics();
   auto defaultLayoutMetrics = LayoutMetrics();
 
-  layoutInfo.push_back(std::make_shared<DebugStringConvertibleItem>(
-      "frame", toString(layoutMetrics.frame)));
+  layoutInfo.push_back(
+      std::make_shared<DebugStringConvertibleItem>(
+          "frame", toString(layoutMetrics.frame)));
 
   if (layoutMetrics.borderWidth != defaultLayoutMetrics.borderWidth) {
-    layoutInfo.push_back(std::make_shared<DebugStringConvertibleItem>(
-        "borderWidth", toString(layoutMetrics.borderWidth)));
+    layoutInfo.push_back(
+        std::make_shared<DebugStringConvertibleItem>(
+            "borderWidth", toString(layoutMetrics.borderWidth)));
   }
 
   if (layoutMetrics.contentInsets != defaultLayoutMetrics.contentInsets) {
-    layoutInfo.push_back(std::make_shared<DebugStringConvertibleItem>(
-        "contentInsets", toString(layoutMetrics.contentInsets)));
+    layoutInfo.push_back(
+        std::make_shared<DebugStringConvertibleItem>(
+            "contentInsets", toString(layoutMetrics.contentInsets)));
   }
 
   if (layoutMetrics.displayType == DisplayType::None) {

package/ReactCommon/react/renderer/core/LayoutableShadowNode.h

@@ -31,13 +31,11 @@ struct LayoutContext;
 class LayoutableShadowNode : public ShadowNode {
  public:
   LayoutableShadowNode(
-      const ShadowNodeFragment& fragment,
-      const ShadowNodeFamily::Shared& family,
+      const ShadowNodeFragment &fragment,
+      const ShadowNodeFamily::Shared &family,
       ShadowNodeTraits traits);
 
-  LayoutableShadowNode(
-      const ShadowNode& sourceShadowNode,
-      const ShadowNodeFragment& fragment);
+  LayoutableShadowNode(const ShadowNode &sourceShadowNode, const ShadowNodeFragment &fragment);
 
   struct LayoutInspectingPolicy {
     bool includeTransform{true};
@@ -45,7 +43,7 @@ class LayoutableShadowNode : public ShadowNode {
     bool enableOverflowClipping{false};
   };
 
-  using UnsharedList = std::vector<LayoutableShadowNode*>;
+  using UnsharedList = std::vector<LayoutableShadowNode *>;
 
   /*
    * Returns layout metrics of a node represented as `descendantNodeFamily`
@@ -53,8 +51,8 @@ class LayoutableShadowNode : public ShadowNode {
    * transform for node if used as root.
    */
   static LayoutMetrics computeLayoutMetricsFromRoot(
-      const ShadowNodeFamily& descendantNodeFamily,
-      const LayoutableShadowNode& rootNode,
+      const ShadowNodeFamily &descendantNodeFamily,
+      const LayoutableShadowNode &rootNode,
       LayoutInspectingPolicy policy);
 
   /*
@@ -64,43 +62,35 @@ class LayoutableShadowNode : public ShadowNode {
    * tree.
    */
   static LayoutMetrics computeRelativeLayoutMetrics(
-      const ShadowNodeFamily& descendantNodeFamily,
-      const LayoutableShadowNode& ancestorNode,
+      const ShadowNodeFamily &descendantNodeFamily,
+      const LayoutableShadowNode &ancestorNode,
       LayoutInspectingPolicy policy);
 
   /*
    * Computes the layout metrics of a node relative to its specified ancestors.
    */
-  static LayoutMetrics computeRelativeLayoutMetrics(
-      const AncestorList& ancestors,
-      LayoutInspectingPolicy policy);
+  static LayoutMetrics computeRelativeLayoutMetrics(const AncestorList &ancestors, LayoutInspectingPolicy policy);
 
   /*
    * Performs layout of the tree starting from this node. Usually is being
    * called on the root node.
    * Default implementation does nothing.
    */
-  virtual void layoutTree(
-      LayoutContext layoutContext,
-      LayoutConstraints layoutConstraints) = 0;
+  virtual void layoutTree(LayoutContext layoutContext, LayoutConstraints layoutConstraints) = 0;
 
   /*
    * Measures the node (and node content, probably recursively) with
    * given constrains and relying on possible layout.
    * Default implementation returns zero size.
    */
-  virtual Size measureContent(
-      const LayoutContext& layoutContext,
-      const LayoutConstraints& layoutConstraints) const;
+  virtual Size measureContent(const LayoutContext &layoutContext, const LayoutConstraints &layoutConstraints) const;
 
   /*
    * Measures the node with given `layoutContext` and `layoutConstraints`.
    * The size of nested content and the padding should be included, the margin
    * should *not* be included. Default implementation returns zero size.
    */
-  virtual Size measure(
-      const LayoutContext& layoutContext,
-      const LayoutConstraints& layoutConstraints) const;
+  virtual Size measure(const LayoutContext &layoutContext, const LayoutConstraints &layoutConstraints) const;
 
   /*
    * Computes layout recursively.
@@ -147,9 +137,7 @@ class LayoutableShadowNode : public ShadowNode {
    * Returns the ShadowNode that is rendered at the Point received as a
    * parameter.
    */
-  static std::shared_ptr<const ShadowNode> findNodeAtPoint(
-      const std::shared_ptr<const ShadowNode>& node,
-      Point point);
+  static std::shared_ptr<const ShadowNode> findNodeAtPoint(const std::shared_ptr<const ShadowNode> &node, Point point);
 
   /*
    * Clean or Dirty layout state:
@@ -162,7 +150,7 @@ class LayoutableShadowNode : public ShadowNode {
   /*
    * Unifed methods to access text layout metrics.
    */
-  virtual Float baseline(const LayoutContext& layoutContext, Size size) const;
+  virtual Float baseline(const LayoutContext &layoutContext, Size size) const;
 
   virtual bool canBeTouchTarget() const;
   virtual bool canChildrenBeTouchTarget() const;

package/ReactCommon/react/renderer/core/Props.h

@@ -30,11 +30,10 @@ class Props : public virtual Sealable, public virtual DebugStringConvertible {
 
   Props() = default;
   Props(
-      const PropsParserContext& context,
-      const Props& sourceProps,
-      const RawProps& rawProps,
-      const std::function<bool(const std::string&)>& filterObjectKeys =
-          nullptr);
+      const PropsParserContext &context,
+      const Props &sourceProps,
+      const RawProps &rawProps,
+      const std::function<bool(const std::string &)> &filterObjectKeys = nullptr);
 
 #if RN_DEBUG_STRING_CONVERTIBLE
   virtual ~Props() override = default;
@@ -42,8 +41,8 @@ class Props : public virtual Sealable, public virtual DebugStringConvertible {
   virtual ~Props() = default;
 #endif
 
-  Props(const Props& other) = delete;
-  Props& operator=(const Props& other) = delete;
+  Props(const Props &other) = delete;
+  Props &operator=(const Props &other) = delete;
 
   /**
    * Set a prop value via iteration (see enableIterator above).
@@ -55,22 +54,21 @@ class Props : public virtual Sealable, public virtual DebugStringConvertible {
    * multiple times for different values in the hierarchy. For example, if
    * ViewProps uses "propX", Props may also use "propX".
    */
-  void setProp(
-      const PropsParserContext& context,
-      RawPropsPropNameHash hash,
-      const char* propName,
-      const RawValue& value);
+  void
+  setProp(const PropsParserContext &context, RawPropsPropNameHash hash, const char *propName, const RawValue &value);
 
   std::string nativeId;
 
 #ifdef RN_SERIALIZABLE_STATE
   folly::dynamic rawProps = folly::dynamic::object();
 
-  virtual ComponentName getDiffPropsImplementationTarget() const {
+  virtual ComponentName getDiffPropsImplementationTarget() const
+  {
     return "";
   }
 
-  virtual folly::dynamic getDiffProps(const Props* prevProps) const {
+  virtual folly::dynamic getDiffProps(const Props *prevProps) const
+  {
     return folly::dynamic::object();
   }
 #endif
@@ -86,15 +84,14 @@ class Props : public virtual Sealable, public virtual DebugStringConvertible {
  protected:
   /** Initialize member variables of Props instance */
   void initialize(
-      const PropsParserContext& context,
-      const Props& sourceProps,
-      const RawProps& rawProps,
+      const PropsParserContext &context,
+      const Props &sourceProps,
+      const RawProps &rawProps,
       /**
        * Filter object keys to be excluded when converting the RawProps to
        * folly::dynamic (android only)
        */
-      const std::function<bool(const std::string&)>& filterObjectKeys =
-          nullptr);
+      const std::function<bool(const std::string &)> &filterObjectKeys = nullptr);
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/core/PropsMacros.h

@@ -40,89 +40,60 @@
 
 // Convenience for building setProps switch statements where the field name is
 // the same as the string identifier
-#define RAW_SET_PROP_SWITCH_CASE_BASIC(field) \
-  RAW_SET_PROP_SWITCH_CASE(field, #field)
+#define RAW_SET_PROP_SWITCH_CASE_BASIC(field) RAW_SET_PROP_SWITCH_CASE(field, #field)
 
-#define CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(         \
-    struct, field, fieldNameString, value)              \
-  case CONSTEXPR_RAW_PROPS_KEY_HASH(fieldNameString): { \
-    if (!value.hasValue()) {                            \
-      decltype(struct) defaultValues{};                 \
-      struct.field = defaultValues.field;               \
-      return;                                           \
-    }                                                   \
-    fromRawValue(context, value, struct.field);         \
-    return;                                             \
+#define CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, field, fieldNameString, value) \
+  case CONSTEXPR_RAW_PROPS_KEY_HASH(fieldNameString): {                               \
+    if (!value.hasValue()) {                                                          \
+      decltype(struct) defaultValues{};                                               \
+      struct.field = defaultValues.field;                                             \
+      return;                                                                         \
+    }                                                                                 \
+    fromRawValue(context, value, struct.field);                                       \
+    return;                                                                           \
   }
 
-#define SET_CASCADED_RECTANGLE_CORNERS(struct, prefix, suffix, rawValue) \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
-      struct, topLeft, prefix "TopLeft" suffix, rawValue)                \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
-      struct, topRight, prefix "TopRight" suffix, rawValue)              \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
-      struct, bottomLeft, prefix "BottomLeft" suffix, rawValue)          \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
-      struct, bottomRight, prefix "BottomRight" suffix, rawValue)        \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
-      struct, topStart, prefix "TopStart" suffix, rawValue)              \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
-      struct, topEnd, prefix "TopEnd" suffix, rawValue)                  \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
-      struct, bottomStart, prefix "BottomStart" suffix, rawValue)        \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
-      struct, bottomEnd, prefix "BottomEnd" suffix, rawValue)            \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
-      struct, all, prefix "" suffix, rawValue)                           \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
-      struct, endEnd, prefix "EndEnd" suffix, rawValue)                  \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
-      struct, endStart, prefix "EndStart" suffix, rawValue)              \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
-      struct, startEnd, prefix "StartEnd" suffix, rawValue)              \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                                \
-      struct, startStart, prefix "StartStart" suffix, rawValue)
+#define SET_CASCADED_RECTANGLE_CORNERS(struct, prefix, suffix, rawValue)                             \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, topLeft, prefix "TopLeft" suffix, rawValue)         \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, topRight, prefix "TopRight" suffix, rawValue)       \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, bottomLeft, prefix "BottomLeft" suffix, rawValue)   \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, bottomRight, prefix "BottomRight" suffix, rawValue) \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, topStart, prefix "TopStart" suffix, rawValue)       \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, topEnd, prefix "TopEnd" suffix, rawValue)           \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, bottomStart, prefix "BottomStart" suffix, rawValue) \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, bottomEnd, prefix "BottomEnd" suffix, rawValue)     \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, all, prefix "" suffix, rawValue)                    \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, endEnd, prefix "EndEnd" suffix, rawValue)           \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, endStart, prefix "EndStart" suffix, rawValue)       \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, startEnd, prefix "StartEnd" suffix, rawValue)       \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, startStart, prefix "StartStart" suffix, rawValue)
 
-#define SET_CASCADED_RECTANGLE_EDGES(struct, prefix, suffix, rawValue) \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
-      struct, left, prefix "Left" suffix, rawValue)                    \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
-      struct, right, prefix "Right" suffix, rawValue)                  \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
-      struct, top, prefix "Top" suffix, rawValue)                      \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
-      struct, bottom, prefix "Bottom" suffix, rawValue)                \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
-      struct, start, prefix "Start" suffix, rawValue)                  \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
-      struct, end, prefix "End" suffix, rawValue)                      \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
-      struct, horizontal, prefix "Horizontal" suffix, rawValue)        \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
-      struct, vertical, prefix "Vertical" suffix, rawValue)            \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
-      struct, all, prefix "" suffix, rawValue)                         \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
-      struct, block, prefix "Block" suffix, rawValue)                  \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
-      struct, blockEnd, prefix "BlockEnd" suffix, rawValue)            \
-  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(                              \
-      struct, blockStart, prefix "BlockStart" suffix, rawValue)
+#define SET_CASCADED_RECTANGLE_EDGES(struct, prefix, suffix, rawValue)                             \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, left, prefix "Left" suffix, rawValue)             \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, right, prefix "Right" suffix, rawValue)           \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, top, prefix "Top" suffix, rawValue)               \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, bottom, prefix "Bottom" suffix, rawValue)         \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, start, prefix "Start" suffix, rawValue)           \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, end, prefix "End" suffix, rawValue)               \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, horizontal, prefix "Horizontal" suffix, rawValue) \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, vertical, prefix "Vertical" suffix, rawValue)     \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, all, prefix "" suffix, rawValue)                  \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, block, prefix "Block" suffix, rawValue)           \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, blockEnd, prefix "BlockEnd" suffix, rawValue)     \
+  CASE_STATEMENT_SET_FIELD_VALUE_INDEXED(struct, blockStart, prefix "BlockStart" suffix, rawValue)
 
 // Rebuild a type that contains multiple fields from a single field value
-#define REBUILD_FIELD_SWITCH_CASE(                                 \
-    defaults, rawValue, property, field, fieldName)                \
-  case CONSTEXPR_RAW_PROPS_KEY_HASH(fieldName): {                  \
-    if ((rawValue).hasValue()) [[likely]] {                        \
-      try {                                                        \
-        fromRawValue(context, rawValue, (property).field);         \
-      } catch (const std::exception& e) {                          \
-        LOG(ERROR) << "Error while converting prop '" << fieldName \
-                   << "': " << e.what();                           \
-        (property).field = (defaults).field;                       \
-      }                                                            \
-    } else {                                                       \
-      (property).field = (defaults).field;                         \
-    }                                                              \
-    return;                                                        \
+#define REBUILD_FIELD_SWITCH_CASE(defaults, rawValue, property, field, fieldName)        \
+  case CONSTEXPR_RAW_PROPS_KEY_HASH(fieldName): {                                        \
+    if ((rawValue).hasValue()) [[likely]] {                                              \
+      try {                                                                              \
+        fromRawValue(context, rawValue, (property).field);                               \
+      } catch (const std::exception &e) {                                                \
+        LOG(ERROR) << "Error while converting prop '" << fieldName << "': " << e.what(); \
+        (property).field = (defaults).field;                                             \
+      }                                                                                  \
+    } else {                                                                             \
+      (property).field = (defaults).field;                                               \
+    }                                                                                    \
+    return;                                                                              \
   }