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

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

@@ -22,10 +22,9 @@
 
 namespace facebook::react {
 
-inline void parseProcessedFilter(
-    const PropsParserContext& context,
-    const RawValue& value,
-    std::vector<FilterFunction>& result) {
+inline void
+parseProcessedFilter(const PropsParserContext &context, const RawValue &value, std::vector<FilterFunction> &result)
+{
   react_native_expect(value.hasType<std::vector<RawValue>>());
   if (!value.hasType<std::vector<RawValue>>()) {
     result = {};
@@ -34,9 +33,8 @@ inline void parseProcessedFilter(
 
   std::vector<FilterFunction> filter{};
   auto rawFilter = static_cast<std::vector<RawValue>>(value);
-  for (const auto& rawFilterPrimitive : rawFilter) {
-    bool isMap =
-        rawFilterPrimitive.hasType<std::unordered_map<std::string, RawValue>>();
+  for (const auto &rawFilterPrimitive : rawFilter) {
+    bool isMap = rawFilterPrimitive.hasType<std::unordered_map<std::string, RawValue>>();
     react_native_expect(isMap);
     if (!isMap) {
       // If a filter is malformed then we should not apply any of them which
@@ -45,17 +43,12 @@ inline void parseProcessedFilter(
       return;
     }
 
-    auto rawFilterFunction =
-        static_cast<std::unordered_map<std::string, RawValue>>(
-            rawFilterPrimitive);
+    auto rawFilterFunction = static_cast<std::unordered_map<std::string, RawValue>>(rawFilterPrimitive);
     FilterFunction filterFunction{};
     try {
-      filterFunction.type =
-          filterTypeFromString(rawFilterFunction.begin()->first);
+      filterFunction.type = filterTypeFromString(rawFilterFunction.begin()->first);
       if (filterFunction.type == FilterType::DropShadow) {
-        auto rawDropShadow =
-            static_cast<std::unordered_map<std::string, RawValue>>(
-                rawFilterFunction.begin()->second);
+        auto rawDropShadow = static_cast<std::unordered_map<std::string, RawValue>>(rawFilterFunction.begin()->second);
         DropShadowParams dropShadowParams{};
 
         auto offsetX = rawDropShadow.find("offsetX");
@@ -97,11 +90,7 @@ inline void parseProcessedFilter(
 
         auto color = rawDropShadow.find("color");
         if (color != rawDropShadow.end()) {
-          fromRawValue(
-              context.contextContainer,
-              context.surfaceId,
-              color->second,
-              dropShadowParams.color);
+          fromRawValue(context.contextContainer, context.surfaceId, color->second, dropShadowParams.color);
         }
 
         filterFunction.parameters = dropShadowParams;
@@ -109,7 +98,7 @@ inline void parseProcessedFilter(
         filterFunction.parameters = (float)rawFilterFunction.begin()->second;
       }
       filter.push_back(std::move(filterFunction));
-    } catch (const std::exception& e) {
+    } catch (const std::exception &e) {
       LOG(ERROR) << "Could not parse FilterFunction: " << e.what();
       result = {};
       return;
@@ -119,10 +108,10 @@ inline void parseProcessedFilter(
   result = filter;
 }
 
-inline FilterType filterTypeFromVariant(
-    const CSSFilterFunctionVariant& filter) {
+inline FilterType filterTypeFromVariant(const CSSFilterFunctionVariant &filter)
+{
   return std::visit(
-      [](auto&& filter) -> FilterType {
+      [](auto &&filter) -> FilterType {
         using FilterT = std::decay_t<decltype(filter)>;
 
         if constexpr (std::is_same_v<FilterT, CSSBlurFilter>) {
@@ -159,10 +148,10 @@ inline FilterType filterTypeFromVariant(
       filter);
 }
 
-inline std::optional<FilterFunction> fromCSSFilter(
-    const CSSFilterFunctionVariant& cssFilter) {
+inline std::optional<FilterFunction> fromCSSFilter(const CSSFilterFunctionVariant &cssFilter)
+{
   return std::visit(
-      [&](auto&& filter) -> std::optional<FilterFunction> {
+      [&](auto &&filter) -> std::optional<FilterFunction> {
         using FilterT = std::decay_t<decltype(filter)>;
 
         if constexpr (std::is_same_v<FilterT, CSSBlurFilter>) {
@@ -178,8 +167,7 @@ inline std::optional<FilterFunction> fromCSSFilter(
 
         if constexpr (std::is_same_v<FilterT, CSSDropShadowFilter>) {
           // TODO: support non-px values
-          if (filter.offsetX.unit != CSSLengthUnit::Px ||
-              filter.offsetY.unit != CSSLengthUnit::Px ||
+          if (filter.offsetX.unit != CSSLengthUnit::Px || filter.offsetY.unit != CSSLengthUnit::Px ||
               filter.standardDeviation.unit != CSSLengthUnit::Px) {
             return {};
           }
@@ -195,12 +183,9 @@ inline std::optional<FilterFunction> fromCSSFilter(
         }
 
         if constexpr (
-            std::is_same_v<FilterT, CSSBrightnessFilter> ||
-            std::is_same_v<FilterT, CSSContrastFilter> ||
-            std::is_same_v<FilterT, CSSGrayscaleFilter> ||
-            std::is_same_v<FilterT, CSSInvertFilter> ||
-            std::is_same_v<FilterT, CSSOpacityFilter> ||
-            std::is_same_v<FilterT, CSSSaturateFilter> ||
+            std::is_same_v<FilterT, CSSBrightnessFilter> || std::is_same_v<FilterT, CSSContrastFilter> ||
+            std::is_same_v<FilterT, CSSGrayscaleFilter> || std::is_same_v<FilterT, CSSInvertFilter> ||
+            std::is_same_v<FilterT, CSSOpacityFilter> || std::is_same_v<FilterT, CSSSaturateFilter> ||
             std::is_same_v<FilterT, CSSSepiaFilter>) {
           return FilterFunction{
               .type = filterTypeFromVariant(cssFilter),
@@ -218,16 +203,15 @@ inline std::optional<FilterFunction> fromCSSFilter(
       cssFilter);
 }
 
-inline void parseUnprocessedFilterString(
-    std::string&& value,
-    std::vector<FilterFunction>& result) {
+inline void parseUnprocessedFilterString(std::string &&value, std::vector<FilterFunction> &result)
+{
   auto filterList = parseCSSProperty<CSSFilterList>((std::string)value);
   if (!std::holds_alternative<CSSFilterList>(filterList)) {
     result = {};
     return;
   }
 
-  for (const auto& cssFilter : std::get<CSSFilterList>(filterList)) {
+  for (const auto &cssFilter : std::get<CSSFilterList>(filterList)) {
     if (auto filter = fromCSSFilter(cssFilter)) {
       result.push_back(*filter);
     } else {
@@ -237,12 +221,10 @@ inline void parseUnprocessedFilterString(
   }
 }
 
-inline std::optional<FilterFunction> parseDropShadow(
-    const PropsParserContext& context,
-    const RawValue& value) {
+inline std::optional<FilterFunction> parseDropShadow(const PropsParserContext &context, const RawValue &value)
+{
   if (value.hasType<std::string>()) {
-    auto val = parseCSSProperty<CSSDropShadowFilter>(
-        std::string("drop-shadow(") + (std::string)value + ")");
+    auto val = parseCSSProperty<CSSDropShadowFilter>(std::string("drop-shadow(") + (std::string)value + ")");
     if (std::holds_alternative<CSSDropShadowFilter>(val)) {
       return fromCSSFilter(std::get<CSSDropShadowFilter>(val));
     }
@@ -252,8 +234,7 @@ inline std::optional<FilterFunction> parseDropShadow(
   if (!value.hasType<std::unordered_map<std::string, RawValue>>()) {
     return {};
   }
-  auto rawDropShadow =
-      static_cast<std::unordered_map<std::string, RawValue>>(value);
+  auto rawDropShadow = static_cast<std::unordered_map<std::string, RawValue>>(value);
 
   DropShadowParams dropShadowParams{};
 
@@ -281,8 +262,7 @@ inline std::optional<FilterFunction> parseDropShadow(
 
   auto standardDeviation = rawDropShadow.find("standardDeviation");
   if (standardDeviation != rawDropShadow.end()) {
-    if (auto parsedStandardDeviation =
-            coerceLength(standardDeviation->second)) {
+    if (auto parsedStandardDeviation = coerceLength(standardDeviation->second)) {
       if (*parsedStandardDeviation < 0.0f) {
         return {};
       }
@@ -301,23 +281,21 @@ inline std::optional<FilterFunction> parseDropShadow(
     }
   }
 
-  return FilterFunction{FilterType::DropShadow, dropShadowParams};
+  return FilterFunction{.type = FilterType::DropShadow, .parameters = dropShadowParams};
 }
 
-inline std::optional<FilterFunction> parseFilterRawValue(
-    const PropsParserContext& context,
-    const RawValue& value) {
+inline std::optional<FilterFunction> parseFilterRawValue(const PropsParserContext &context, const RawValue &value)
+{
   if (!value.hasType<std::unordered_map<std::string, RawValue>>()) {
     return {};
   }
-  auto rawFilter =
-      static_cast<std::unordered_map<std::string, RawValue>>(value);
+  auto rawFilter = static_cast<std::unordered_map<std::string, RawValue>>(value);
 
   if (rawFilter.size() != 1) {
     return {};
   }
 
-  const auto& filterKey = rawFilter.begin()->first;
+  const auto &filterKey = rawFilter.begin()->first;
 
   if (filterKey == "drop-shadow") {
     return parseDropShadow(context, rawFilter.begin()->second);
@@ -326,12 +304,12 @@ inline std::optional<FilterFunction> parseFilterRawValue(
       if (*length < 0.0f) {
         return {};
       }
-      return FilterFunction{FilterType::Blur, *length};
+      return FilterFunction{.type = FilterType::Blur, .parameters = *length};
     }
     return {};
   } else if (filterKey == "hue-rotate") {
     if (auto angle = coerceAngle(rawFilter.begin()->second)) {
-      return FilterFunction{FilterType::HueRotate, *angle};
+      return FilterFunction{.type = FilterType::HueRotate, .parameters = *angle};
     }
     return {};
   } else {
@@ -339,17 +317,18 @@ inline std::optional<FilterFunction> parseFilterRawValue(
       if (*amount < 0.0f) {
         return {};
       }
-      return FilterFunction{filterTypeFromString(filterKey), *amount};
+      return FilterFunction{.type = filterTypeFromString(filterKey), .parameters = *amount};
     }
     return {};
   }
 }
 
 inline void parseUnprocessedFilterList(
-    const PropsParserContext& context,
-    std::vector<RawValue>&& value,
-    std::vector<FilterFunction>& result) {
-  for (const auto& rawValue : value) {
+    const PropsParserContext &context,
+    std::vector<RawValue> &&value,
+    std::vector<FilterFunction> &result)
+{
+  for (const auto &rawValue : value) {
     if (auto Filter = parseFilterRawValue(context, rawValue)) {
       result.push_back(*Filter);
     } else {
@@ -359,10 +338,9 @@ inline void parseUnprocessedFilterList(
   }
 }
 
-inline void parseUnprocessedFilter(
-    const PropsParserContext& context,
-    const RawValue& value,
-    std::vector<FilterFunction>& result) {
+inline void
+parseUnprocessedFilter(const PropsParserContext &context, const RawValue &value, std::vector<FilterFunction> &result)
+{
   if (value.hasType<std::string>()) {
     parseUnprocessedFilterString((std::string)value, result);
   } else if (value.hasType<std::vector<RawValue>>()) {
@@ -372,10 +350,8 @@ inline void parseUnprocessedFilter(
   }
 }
 
-inline void fromRawValue(
-    const PropsParserContext& context,
-    const RawValue& value,
-    std::vector<FilterFunction>& result) {
+inline void fromRawValue(const PropsParserContext &context, const RawValue &value, std::vector<FilterFunction> &result)
+{
   if (ReactNativeFeatureFlags::enableNativeCSSParsing()) {
     parseUnprocessedFilter(context, value, result);
   } else {

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

@@ -12,7 +12,6 @@
 
 namespace facebook::react {
 
-using LayoutConformanceComponentDescriptor =
-    ConcreteComponentDescriptor<LayoutConformanceShadowNode>;
+using LayoutConformanceComponentDescriptor = ConcreteComponentDescriptor<LayoutConformanceShadowNode>;
 
 } // namespace facebook::react

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

@@ -21,16 +21,13 @@ struct LayoutConformanceProps final : public YogaStylableProps {
 
   LayoutConformanceProps() = default;
   LayoutConformanceProps(
-      const PropsParserContext& context,
-      const LayoutConformanceProps& sourceProps,
-      const RawProps& rawProps)
+      const PropsParserContext &context,
+      const LayoutConformanceProps &sourceProps,
+      const RawProps &rawProps)
       : YogaStylableProps(context, sourceProps, rawProps),
-        mode{convertRawProp(
-            context,
-            rawProps,
-            "mode",
-            mode,
-            LayoutConformance::Strict)} {}
+        mode{convertRawProp(context, rawProps, "mode", mode, LayoutConformance::Strict)}
+  {
+  }
 };
 
 } // namespace facebook::react

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

@@ -13,14 +13,13 @@
 
 namespace facebook::react {
 
-constexpr const char LayoutConformanceShadowNodeComponentName[] =
-    "LayoutConformance";
+// NOLINTNEXTLINE(facebook-hte-CArray,modernize-avoid-c-arrays)
+constexpr const char LayoutConformanceShadowNodeComponentName[] = "LayoutConformance";
 
-class LayoutConformanceShadowNode final
-    : public ConcreteShadowNode<
-          LayoutConformanceShadowNodeComponentName,
-          YogaLayoutableShadowNode,
-          LayoutConformanceProps> {
+class LayoutConformanceShadowNode final : public ConcreteShadowNode<
+                                              LayoutConformanceShadowNodeComponentName,
+                                              YogaLayoutableShadowNode,
+                                              LayoutConformanceProps> {
  public:
   using ConcreteShadowNode::ConcreteShadowNode;
 };

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

@@ -58,27 +58,46 @@ std::vector<DebugStringConvertibleObject> getDebugProps(
     const PointerEvent& pointerEvent,
     DebugStringConvertibleOptions options) {
   return {
-      {"pointerId", getDebugDescription(pointerEvent.pointerId, options)},
-      {"pressure", getDebugDescription(pointerEvent.pressure, options)},
-      {"pointerType", getDebugDescription(pointerEvent.pointerType, options)},
-      {"clientPoint", getDebugDescription(pointerEvent.clientPoint, options)},
-      {"screenPoint", getDebugDescription(pointerEvent.screenPoint, options)},
-      {"offsetPoint", getDebugDescription(pointerEvent.offsetPoint, options)},
-      {"width", getDebugDescription(pointerEvent.width, options)},
-      {"height", getDebugDescription(pointerEvent.height, options)},
-      {"tiltX", getDebugDescription(pointerEvent.tiltX, options)},
-      {"tiltY", getDebugDescription(pointerEvent.tiltY, options)},
-      {"detail", getDebugDescription(pointerEvent.detail, options)},
-      {"buttons", getDebugDescription(pointerEvent.buttons, options)},
-      {"tangentialPressure",
-       getDebugDescription(pointerEvent.tangentialPressure, options)},
-      {"twist", getDebugDescription(pointerEvent.twist, options)},
-      {"ctrlKey", getDebugDescription(pointerEvent.ctrlKey, options)},
-      {"shiftKey", getDebugDescription(pointerEvent.shiftKey, options)},
-      {"altKey", getDebugDescription(pointerEvent.altKey, options)},
-      {"metaKey", getDebugDescription(pointerEvent.metaKey, options)},
-      {"isPrimary", getDebugDescription(pointerEvent.isPrimary, options)},
-      {"button", getDebugDescription(pointerEvent.button, options)},
+      {.name = "pointerId",
+       .value = getDebugDescription(pointerEvent.pointerId, options)},
+      {.name = "pressure",
+       .value = getDebugDescription(pointerEvent.pressure, options)},
+      {.name = "pointerType",
+       .value = getDebugDescription(pointerEvent.pointerType, options)},
+      {.name = "clientPoint",
+       .value = getDebugDescription(pointerEvent.clientPoint, options)},
+      {.name = "screenPoint",
+       .value = getDebugDescription(pointerEvent.screenPoint, options)},
+      {.name = "offsetPoint",
+       .value = getDebugDescription(pointerEvent.offsetPoint, options)},
+      {.name = "width",
+       .value = getDebugDescription(pointerEvent.width, options)},
+      {.name = "height",
+       .value = getDebugDescription(pointerEvent.height, options)},
+      {.name = "tiltX",
+       .value = getDebugDescription(pointerEvent.tiltX, options)},
+      {.name = "tiltY",
+       .value = getDebugDescription(pointerEvent.tiltY, options)},
+      {.name = "detail",
+       .value = getDebugDescription(pointerEvent.detail, options)},
+      {.name = "buttons",
+       .value = getDebugDescription(pointerEvent.buttons, options)},
+      {.name = "tangentialPressure",
+       .value = getDebugDescription(pointerEvent.tangentialPressure, options)},
+      {.name = "twist",
+       .value = getDebugDescription(pointerEvent.twist, options)},
+      {.name = "ctrlKey",
+       .value = getDebugDescription(pointerEvent.ctrlKey, options)},
+      {.name = "shiftKey",
+       .value = getDebugDescription(pointerEvent.shiftKey, options)},
+      {.name = "altKey",
+       .value = getDebugDescription(pointerEvent.altKey, options)},
+      {.name = "metaKey",
+       .value = getDebugDescription(pointerEvent.metaKey, options)},
+      {.name = "isPrimary",
+       .value = getDebugDescription(pointerEvent.isPrimary, options)},
+      {.name = "button",
+       .value = getDebugDescription(pointerEvent.button, options)},
   };
 }
 

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

@@ -114,15 +114,15 @@ struct PointerEvent : public EventPayload {
   /*
    * EventPayload implementations
    */
-  jsi::Value asJSIValue(jsi::Runtime& runtime) const override;
+  jsi::Value asJSIValue(jsi::Runtime &runtime) const override;
   EventPayloadType getType() const override;
 };
 
 #if RN_DEBUG_STRING_CONVERTIBLE
 
-std::string getDebugName(const PointerEvent& pointerEvent);
+std::string getDebugName(const PointerEvent &pointerEvent);
 std::vector<DebugStringConvertibleObject> getDebugProps(
-    const PointerEvent& pointerEvent,
+    const PointerEvent &pointerEvent,
     DebugStringConvertibleOptions options);
 
 #endif

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

@@ -19,10 +19,12 @@ std::vector<DebugStringConvertibleObject> getDebugProps(
     const TouchEvent& touchEvent,
     DebugStringConvertibleOptions options) {
   return {
-      {"touches", getDebugDescription(touchEvent.touches, options)},
-      {"changedTouches",
-       getDebugDescription(touchEvent.changedTouches, options)},
-      {"targetTouches", getDebugDescription(touchEvent.targetTouches, options)},
+      {.name = "touches",
+       .value = getDebugDescription(touchEvent.touches, options)},
+      {.name = "changedTouches",
+       .value = getDebugDescription(touchEvent.changedTouches, options)},
+      {.name = "targetTouches",
+       .value = getDebugDescription(touchEvent.targetTouches, options)},
   };
 }
 

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

@@ -41,9 +41,9 @@ struct TouchEvent {
 
 #if RN_DEBUG_STRING_CONVERTIBLE
 
-std::string getDebugName(const TouchEvent& touchEvent);
+std::string getDebugName(const TouchEvent &touchEvent);
 std::vector<DebugStringConvertibleObject> getDebugProps(
-    const TouchEvent& touchEvent,
+    const TouchEvent &touchEvent,
     DebugStringConvertibleOptions options);
 
 #endif

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

@@ -42,14 +42,8 @@ class TouchEventEmitter : public EventEmitter {
   void onLostPointerCapture(PointerEvent event) const;
 
  private:
-  void dispatchTouchEvent(
-      std::string type,
-      TouchEvent event,
-      RawEvent::Category category) const;
-  void dispatchPointerEvent(
-      std::string type,
-      PointerEvent event,
-      RawEvent::Category category) const;
+  void dispatchTouchEvent(std::string type, TouchEvent event, RawEvent::Category category) const;
+  void dispatchPointerEvent(std::string type, PointerEvent event, RawEvent::Category category) const;
 };
 
 } // namespace facebook::react

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

@@ -12,11 +12,12 @@
 
 namespace facebook::react {
 
-class ViewComponentDescriptor
-    : public ConcreteComponentDescriptor<ViewShadowNode> {
+class ViewComponentDescriptor : public ConcreteComponentDescriptor<ViewShadowNode> {
  public:
-  ViewComponentDescriptor(const ComponentDescriptorParameters& parameters)
-      : ConcreteComponentDescriptor<ViewShadowNode>(parameters) {}
+  ViewComponentDescriptor(const ComponentDescriptorParameters &parameters)
+      : ConcreteComponentDescriptor<ViewShadowNode>(parameters)
+  {
+  }
 };
 
 } // namespace facebook::react

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

@@ -23,24 +23,19 @@ namespace facebook::react {
  */
 static inline void interpolateViewProps(
     Float animationProgress,
-    const Props::Shared& oldPropsShared,
-    const Props::Shared& newPropsShared,
-    Props::Shared& interpolatedPropsShared,
-    const Size& size) {
-  const ViewProps* oldViewProps =
-      static_cast<const ViewProps*>(oldPropsShared.get());
-  const ViewProps* newViewProps =
-      static_cast<const ViewProps*>(newPropsShared.get());
-  ViewProps* interpolatedProps = const_cast<ViewProps*>(
-      static_cast<const ViewProps*>(interpolatedPropsShared.get()));
-
-  interpolatedProps->opacity = oldViewProps->opacity +
-      (newViewProps->opacity - oldViewProps->opacity) * animationProgress;
-  interpolatedProps->transform = Transform::Interpolate(
-      animationProgress,
-      oldViewProps->transform,
-      newViewProps->transform,
-      size);
+    const Props::Shared &oldPropsShared,
+    const Props::Shared &newPropsShared,
+    Props::Shared &interpolatedPropsShared,
+    const Size &size)
+{
+  const ViewProps *oldViewProps = static_cast<const ViewProps *>(oldPropsShared.get());
+  const ViewProps *newViewProps = static_cast<const ViewProps *>(newPropsShared.get());
+  ViewProps *interpolatedProps = const_cast<ViewProps *>(static_cast<const ViewProps *>(interpolatedPropsShared.get()));
+
+  interpolatedProps->opacity =
+      oldViewProps->opacity + (newViewProps->opacity - oldViewProps->opacity) * animationProgress;
+  interpolatedProps->transform =
+      Transform::Interpolate(animationProgress, oldViewProps->transform, newViewProps->transform, size);
 
   // Android uses RawProps, not props, to update props on the platform...
   // Since interpolated props don't interpolate at all using RawProps, we need
@@ -53,8 +48,7 @@ static inline void interpolateViewProps(
   if (!interpolatedProps->rawProps.isNull()) {
     interpolatedProps->rawProps["opacity"] = interpolatedProps->opacity;
 
-    interpolatedProps->rawProps["transform"] =
-        (folly::dynamic)interpolatedProps->transform;
+    interpolatedProps->rawProps["transform"] = (folly::dynamic)interpolatedProps->transform;
   }
 #endif
 }

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

@@ -18,7 +18,7 @@ ViewShadowNodeProps::ViewShadowNodeProps(
     const PropsParserContext& context,
     const ViewShadowNodeProps& sourceProps,
     const RawProps& rawProps)
-    : ViewProps(context, sourceProps, rawProps){};
+    : ViewProps(context, sourceProps, rawProps) {};
 
 ViewShadowNode::ViewShadowNode(
     const ShadowNodeFragment& fragment,

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

@@ -22,27 +22,19 @@ class ViewShadowNodeProps final : public ViewProps {
  public:
   ViewShadowNodeProps() = default;
   ViewShadowNodeProps(
-      const PropsParserContext& context,
-      const ViewShadowNodeProps& sourceProps,
-      const RawProps& rawProps);
+      const PropsParserContext &context,
+      const ViewShadowNodeProps &sourceProps,
+      const RawProps &rawProps);
 };
 
 /*
  * `ShadowNode` for <View> component.
  */
-class ViewShadowNode final : public ConcreteViewShadowNode<
-                                 ViewComponentName,
-                                 ViewShadowNodeProps,
-                                 ViewEventEmitter> {
+class ViewShadowNode final : public ConcreteViewShadowNode<ViewComponentName, ViewShadowNodeProps, ViewEventEmitter> {
  public:
-  ViewShadowNode(
-      const ShadowNodeFragment& fragment,
-      const ShadowNodeFamily::Shared& family,
-      ShadowNodeTraits traits);
-
-  ViewShadowNode(
-      const ShadowNode& sourceShadowNode,
-      const ShadowNodeFragment& fragment);
+  ViewShadowNode(const ShadowNodeFragment &fragment, const ShadowNodeFamily::Shared &family, ShadowNodeTraits traits);
+
+  ViewShadowNode(const ShadowNode &sourceShadowNode, const ShadowNodeFragment &fragment);
 
  private:
   void initialize() noexcept;

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

@@ -97,8 +97,9 @@ YogaLayoutableShadowNode::YogaLayoutableShadowNode(
     const ShadowNodeFragment& fragment)
     : LayoutableShadowNode(sourceShadowNode, fragment),
       yogaConfig_(FabricDefaultYogaLog),
-      yogaNode_(static_cast<const YogaLayoutableShadowNode&>(sourceShadowNode)
-                    .yogaNode_) {
+      yogaNode_(
+          static_cast<const YogaLayoutableShadowNode&>(sourceShadowNode)
+              .yogaNode_) {
 // Note, cloned `yoga::Node` instance (copied using copy-constructor) inherits
 // dirty flag, measure function, and other properties being set originally in
 // the `YogaLayoutableShadowNode` constructor above.
@@ -531,9 +532,9 @@ YogaLayoutableShadowNode& YogaLayoutableShadowNode::cloneChildInPlace(
   // TODO: Why does this not use `ShadowNodeFragment::statePlaceholder()` like
   // `adoptYogaChild()`?
   auto clonedChildNode = childNode.clone(
-      {ShadowNodeFragment::propsPlaceholder(),
-       ShadowNodeFragment::childrenPlaceholder(),
-       childNode.getState()});
+      {.props = ShadowNodeFragment::propsPlaceholder(),
+       .children = ShadowNodeFragment::childrenPlaceholder(),
+       .state = childNode.getState()});
 
   replaceChild(childNode, clonedChildNode, layoutableChildIndex);
   return static_cast<YogaLayoutableShadowNode&>(*clonedChildNode);
@@ -814,10 +815,10 @@ YGSize YogaLayoutableShadowNode::yogaNodeMeasureCallbackConnector(
 
   auto& shadowNode = shadowNodeFromContext(yogaNode);
 
-  auto minimumSize = Size{0, 0};
+  auto minimumSize = Size{.width = 0, .height = 0};
   auto maximumSize = Size{
-      std::numeric_limits<Float>::infinity(),
-      std::numeric_limits<Float>::infinity()};
+      .width = std::numeric_limits<Float>::infinity(),
+      .height = std::numeric_limits<Float>::infinity()};
 
   switch (widthMode) {
     case YGMeasureModeUndefined:
@@ -844,7 +845,8 @@ YGSize YogaLayoutableShadowNode::yogaNodeMeasureCallbackConnector(
   }
 
   auto size = shadowNode.measureContent(
-      threadLocalLayoutContext, {minimumSize, maximumSize});
+      threadLocalLayoutContext,
+      {.minimumSize = minimumSize, .maximumSize = maximumSize});
 
 #ifdef REACT_NATIVE_DEBUG
   bool widthInBounds = size.width + kDefaultEpsilon >= minimumSize.width &&