react-native-tvos 0.72.6-1 → 0.73.0-0

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

@@ -7,25 +7,24 @@
 
 #pragma once
 
-#include <butter/map.h>
 #include <folly/Conv.h>
 #include <folly/dynamic.h>
 #include <glog/logging.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/Transform.h>
+#include <react/renderer/graphics/ValueUnit.h>
 #include <stdlib.h>
 #include <yoga/YGEnums.h>
-#include <yoga/YGNode.h>
-#include <yoga/Yoga.h>
+#include <yoga/node/Node.h>
+#include <algorithm>
 #include <cmath>
 #include <optional>
+#include <unordered_map>
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 /*
  * Yoga's `float` <-> React Native's `Float` (can be `double` or `float`)
@@ -57,16 +56,16 @@ inline float yogaFloatFromFloat(Float value) {
 }
 
 /*
- * `YGFloatOptional` <-> React Native's `Float`
+ * `yoga::FloatOptional` <-> React Native's `Float`
  *
- * `YGFloatOptional` represents optional dimensionless float values in Yoga
+ * `yoga::FloatOptional` represents optional dimensionless float values in Yoga
  * Style object (e.g. `flex`). The most suitable analogy to empty
- * `YGFloatOptional` is `NaN` value.
- * `YGFloatOptional` values are usually parsed from some outside data source
+ * `yoga::FloatOptional` is `NaN` value.
+ * `yoga::FloatOptional` values are usually parsed from some outside data source
  * which usually has some special corresponding representation for an empty
  * value.
  */
-inline Float floatFromYogaOptionalFloat(YGFloatOptional value) {
+inline Float floatFromYogaOptionalFloat(yoga::FloatOptional value) {
   if (value.isUndefined()) {
     return std::numeric_limits<Float>::quiet_NaN();
   }
@@ -74,28 +73,12 @@ inline Float floatFromYogaOptionalFloat(YGFloatOptional value) {
   return floatFromYogaFloat(value.unwrap());
 }
 
-inline YGFloatOptional yogaOptionalFloatFromFloat(Float value) {
+inline yoga::FloatOptional yogaOptionalFloatFromFloat(Float value) {
   if (std::isnan(value)) {
-    return YGFloatOptional();
+    return yoga::FloatOptional();
   }
 
-  return YGFloatOptional((float)value);
-}
-
-/*
- * `YGValue` <-> `React Native's `Float`
- *
- * `YGValue` represents optional dimensionful (a real number and some unit, e.g.
- * pixels).
- */
-inline YGValue yogaStyleValueFromFloat(
-    const Float &value,
-    YGUnit unit = YGUnitPoint) {
-  if (!std::isfinite(value)) {
-    return YGValueUndefined;
-  }
-
-  return {(float)value, unit};
+  return yoga::FloatOptional((float)value);
 }
 
 inline std::optional<Float> optionalFloatFromYogaValue(
@@ -115,7 +98,7 @@ inline std::optional<Float> optionalFloatFromYogaValue(
   }
 }
 
-inline LayoutMetrics layoutMetricsFromYogaNode(YGNode &yogaNode) {
+inline LayoutMetrics layoutMetricsFromYogaNode(yoga::Node& yogaNode) {
   auto layoutMetrics = LayoutMetrics{};
 
   layoutMetrics.frame = Rect{
@@ -142,9 +125,9 @@ inline LayoutMetrics layoutMetricsFromYogaNode(YGNode &yogaNode) {
       layoutMetrics.borderWidth.bottom +
           floatFromYogaFloat(YGNodeLayoutGetPadding(&yogaNode, YGEdgeBottom))};
 
-  layoutMetrics.displayType = yogaNode.getStyle().display() == YGDisplayNone
-      ? DisplayType::None
-      : DisplayType::Flex;
+  layoutMetrics.displayType =
+      yogaNode.getStyle().display() == yoga::Display::None ? DisplayType::None
+                                                           : DisplayType::Flex;
 
   layoutMetrics.layoutDirection =
       YGNodeLayoutGetDirection(&yogaNode) == YGDirectionRTL
@@ -166,262 +149,257 @@ inline YGDirection yogaDirectionFromLayoutDirection(LayoutDirection direction) {
 }
 
 inline void fromRawValue(
-    const PropsParserContext &context,
-    const RawValue &value,
-    YGDirection &result) {
-  result = YGDirectionInherit;
+    const PropsParserContext& context,
+    const RawValue& value,
+    yoga::Direction& result) {
+  result = yoga::Direction::Inherit;
   react_native_expect(value.hasType<std::string>());
   if (!value.hasType<std::string>()) {
     return;
   }
   auto stringValue = (std::string)value;
   if (stringValue == "inherit") {
-    result = YGDirectionInherit;
+    result = yoga::Direction::Inherit;
     return;
   }
   if (stringValue == "ltr") {
-    result = YGDirectionLTR;
+    result = yoga::Direction::LTR;
     return;
   }
   if (stringValue == "rtl") {
-    result = YGDirectionRTL;
+    result = yoga::Direction::RTL;
     return;
   }
-  LOG(ERROR) << "Could not parse YGDirection:" << stringValue;
+  LOG(ERROR) << "Could not parse Direction:" << stringValue;
   react_native_expect(false);
 }
 
 inline void fromRawValue(
-    const PropsParserContext &context,
-    const RawValue &value,
-    YGFlexDirection &result) {
-  result = YGFlexDirectionColumn;
+    const PropsParserContext& context,
+    const RawValue& value,
+    yoga::FlexDirection& result) {
+  result = yoga::FlexDirection::Column;
   react_native_expect(value.hasType<std::string>());
   if (!value.hasType<std::string>()) {
     return;
   }
   auto stringValue = (std::string)value;
   if (stringValue == "row") {
-    result = YGFlexDirectionRow;
+    result = yoga::FlexDirection::Row;
     return;
   }
   if (stringValue == "column") {
-    result = YGFlexDirectionColumn;
+    result = yoga::FlexDirection::Column;
     return;
   }
   if (stringValue == "column-reverse") {
-    result = YGFlexDirectionColumnReverse;
+    result = yoga::FlexDirection::ColumnReverse;
     return;
   }
   if (stringValue == "row-reverse") {
-    result = YGFlexDirectionRowReverse;
+    result = yoga::FlexDirection::RowReverse;
     return;
   }
-  LOG(ERROR) << "Could not parse YGFlexDirection:" << stringValue;
+  LOG(ERROR) << "Could not parse yoga::FlexDirection:" << stringValue;
   react_native_expect(false);
 }
 
 inline void fromRawValue(
-    const PropsParserContext &context,
-    const RawValue &value,
-    YGJustify &result) {
-  result = YGJustifyFlexStart;
+    const PropsParserContext& context,
+    const RawValue& value,
+    yoga::Justify& result) {
+  result = yoga::Justify::FlexStart;
   react_native_expect(value.hasType<std::string>());
   if (!value.hasType<std::string>()) {
     return;
   }
   auto stringValue = (std::string)value;
   if (stringValue == "flex-start") {
-    result = YGJustifyFlexStart;
+    result = yoga::Justify::FlexStart;
     return;
   }
   if (stringValue == "center") {
-    result = YGJustifyCenter;
+    result = yoga::Justify::Center;
     return;
   }
   if (stringValue == "flex-end") {
-    result = YGJustifyFlexEnd;
+    result = yoga::Justify::FlexEnd;
     return;
   }
   if (stringValue == "space-between") {
-    result = YGJustifySpaceBetween;
+    result = yoga::Justify::SpaceBetween;
     return;
   }
   if (stringValue == "space-around") {
-    result = YGJustifySpaceAround;
+    result = yoga::Justify::SpaceAround;
     return;
   }
   if (stringValue == "space-evenly") {
-    result = YGJustifySpaceEvenly;
+    result = yoga::Justify::SpaceEvenly;
     return;
   }
-  LOG(ERROR) << "Could not parse YGJustify:" << stringValue;
+  LOG(ERROR) << "Could not parse yoga::Justify:" << stringValue;
   react_native_expect(false);
 }
 
 inline void fromRawValue(
-    const PropsParserContext &context,
-    const RawValue &value,
-    YGAlign &result) {
-  result = YGAlignStretch;
+    const PropsParserContext& context,
+    const RawValue& value,
+    yoga::Align& result) {
+  result = yoga::Align::Stretch;
   react_native_expect(value.hasType<std::string>());
   if (!value.hasType<std::string>()) {
     return;
   }
   auto stringValue = (std::string)value;
   if (stringValue == "auto") {
-    result = YGAlignAuto;
+    result = yoga::Align::Auto;
     return;
   }
   if (stringValue == "flex-start") {
-    result = YGAlignFlexStart;
+    result = yoga::Align::FlexStart;
     return;
   }
   if (stringValue == "center") {
-    result = YGAlignCenter;
+    result = yoga::Align::Center;
     return;
   }
   if (stringValue == "flex-end") {
-    result = YGAlignFlexEnd;
+    result = yoga::Align::FlexEnd;
     return;
   }
   if (stringValue == "stretch") {
-    result = YGAlignStretch;
+    result = yoga::Align::Stretch;
     return;
   }
   if (stringValue == "baseline") {
-    result = YGAlignBaseline;
+    result = yoga::Align::Baseline;
     return;
   }
   if (stringValue == "space-between") {
-    result = YGAlignSpaceBetween;
+    result = yoga::Align::SpaceBetween;
     return;
   }
   if (stringValue == "space-around") {
-    result = YGAlignSpaceAround;
+    result = yoga::Align::SpaceAround;
     return;
   }
-  LOG(ERROR) << "Could not parse YGAlign:" << stringValue;
+  LOG(ERROR) << "Could not parse yoga::Align:" << stringValue;
   react_native_expect(false);
 }
 
 inline void fromRawValue(
-    const PropsParserContext &context,
-    const RawValue &value,
-    YGPositionType &result) {
-  result = YGPositionTypeRelative;
+    const PropsParserContext& context,
+    const RawValue& value,
+    yoga::PositionType& result) {
+  result = yoga::PositionType::Relative;
   react_native_expect(value.hasType<std::string>());
   if (!value.hasType<std::string>()) {
     return;
   }
   auto stringValue = (std::string)value;
   if (stringValue == "static") {
-    result = YGPositionTypeStatic;
+    result = yoga::PositionType::Static;
     return;
   }
   if (stringValue == "relative") {
-    result = YGPositionTypeRelative;
+    result = yoga::PositionType::Relative;
     return;
   }
   if (stringValue == "absolute") {
-    result = YGPositionTypeAbsolute;
+    result = yoga::PositionType::Absolute;
     return;
   }
-  LOG(ERROR) << "Could not parse YGPositionType:" << stringValue;
+  LOG(ERROR) << "Could not parse yoga::PositionType:" << stringValue;
   react_native_expect(false);
 }
 
 inline void fromRawValue(
-    const PropsParserContext &context,
-    const RawValue &value,
-    YGWrap &result) {
-  result = YGWrapNoWrap;
+    const PropsParserContext& context,
+    const RawValue& value,
+    yoga::Wrap& result) {
+  result = yoga::Wrap::NoWrap;
   react_native_expect(value.hasType<std::string>());
   if (!value.hasType<std::string>()) {
     return;
   }
   auto stringValue = (std::string)value;
   if (stringValue == "nowrap") {
-    result = YGWrapNoWrap;
+    result = yoga::Wrap::NoWrap;
     return;
   }
   if (stringValue == "wrap") {
-    result = YGWrapWrap;
+    result = yoga::Wrap::Wrap;
     return;
   }
   if (stringValue == "wrap-reverse") {
-    result = YGWrapWrapReverse;
+    result = yoga::Wrap::WrapReverse;
     return;
   }
-  LOG(ERROR) << "Could not parse YGWrap:" << stringValue;
+  LOG(ERROR) << "Could not parse yoga::Wrap:" << stringValue;
   react_native_expect(false);
 }
 
 inline void fromRawValue(
-    const PropsParserContext &context,
-    const RawValue &value,
-    YGOverflow &result) {
-  result = YGOverflowVisible;
+    const PropsParserContext& context,
+    const RawValue& value,
+    yoga::Overflow& result) {
+  result = yoga::Overflow::Visible;
   react_native_expect(value.hasType<std::string>());
   if (!value.hasType<std::string>()) {
     return;
   }
   auto stringValue = (std::string)value;
   if (stringValue == "visible") {
-    result = YGOverflowVisible;
+    result = yoga::Overflow::Visible;
     return;
   }
   if (stringValue == "hidden") {
-    result = YGOverflowHidden;
+    result = yoga::Overflow::Hidden;
     return;
   }
   if (stringValue == "scroll") {
-    result = YGOverflowScroll;
+    result = yoga::Overflow::Scroll;
     return;
   }
-  LOG(ERROR) << "Could not parse YGOverflow:" << stringValue;
+  LOG(ERROR) << "Could not parse yoga::Overflow:" << stringValue;
   react_native_expect(false);
 }
 
 inline void fromRawValue(
-    const PropsParserContext &context,
-    const RawValue &value,
-    YGDisplay &result) {
-  result = YGDisplayFlex;
+    const PropsParserContext& context,
+    const RawValue& value,
+    yoga::Display& result) {
+  result = yoga::Display::Flex;
   react_native_expect(value.hasType<std::string>());
   if (!value.hasType<std::string>()) {
     return;
   }
   auto stringValue = (std::string)value;
   if (stringValue == "flex") {
-    result = YGDisplayFlex;
+    result = yoga::Display::Flex;
     return;
   }
   if (stringValue == "none") {
-    result = YGDisplayNone;
+    result = yoga::Display::None;
     return;
   }
-  LOG(ERROR) << "Could not parse YGDisplay:" << stringValue;
+  LOG(ERROR) << "Could not parse yoga::Display:" << 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");
-
+    const PropsParserContext& context,
+    const RawValue& value,
+    yoga::Style::ValueRepr& result) {
   if (value.hasType<Float>()) {
-    result = yogaStyleValueFromFloat((Float)value);
+    result = yoga::CompactValue::ofMaybe<YGUnitPoint>((float)value);
     return;
   } else if (value.hasType<std::string>()) {
     const auto stringValue = (std::string)value;
     if (stringValue == "auto") {
-      result = treatAutoAsUndefined ? YGValueUndefined : YGValueAuto;
+      result = context.treatAutoAsYGValueUndefined() ? YGValueUndefined
+                                                     : YGValueAuto;
       return;
     } else {
       if (stringValue.back() == '%') {
@@ -444,34 +422,24 @@ inline void fromRawValue(
 }
 
 inline void fromRawValue(
-    const PropsParserContext &context,
-    const RawValue &value,
-    YGValue &result) {
-  YGStyle::ValueRepr ygValue{};
+    const PropsParserContext& context,
+    const RawValue& value,
+    YGValue& result) {
+  yoga::Style::ValueRepr ygValue{};
   fromRawValue(context, value, ygValue);
   result = ygValue;
 }
 
 inline void fromRawValue(
-    const PropsParserContext &context,
-    const RawValue &value,
-    YGFloatOptional &result) {
-  if (value.hasType<float>()) {
-    result = YGFloatOptional((float)value);
-    return;
-  } else if (value.hasType<std::string>()) {
-    const auto stringValue = (std::string)value;
-    if (stringValue == "auto") {
-      result = YGFloatOptional();
-      return;
-    }
-  }
-  LOG(ERROR) << "Could not parse YGFloatOptional";
-  react_native_expect(false);
+    const PropsParserContext& context,
+    const RawValue& value,
+    yoga::FloatOptional& result) {
+  result = value.hasType<float>() ? yoga::FloatOptional((float)value)
+                                  : yoga::FloatOptional();
 }
 
 inline Float toRadians(
-    const RawValue &value,
+    const RawValue& value,
     std::optional<Float> defaultValue) {
   if (value.hasType<Float>()) {
     return (Float)value;
@@ -481,7 +449,7 @@ inline Float toRadians(
     return *defaultValue;
   }
   auto stringValue = (std::string)value;
-  char *suffixStart;
+  char* suffixStart;
   double num = strtod(
       stringValue.c_str(), &suffixStart); // can't use std::stod, probably
                                           // because of old Android NDKs
@@ -492,9 +460,9 @@ inline Float toRadians(
 }
 
 inline void fromRawValue(
-    const PropsParserContext &context,
-    const RawValue &value,
-    Transform &result) {
+    const PropsParserContext& context,
+    const RawValue& value,
+    Transform& result) {
   auto transformMatrix = Transform{};
   react_native_expect(value.hasType<std::vector<RawValue>>());
   if (!value.hasType<std::vector<RawValue>>()) {
@@ -503,18 +471,18 @@ inline void fromRawValue(
   }
 
   auto configurations = static_cast<std::vector<RawValue>>(value);
-  for (const auto &configuration : configurations) {
-    if (!configuration.hasType<butter::map<std::string, RawValue>>()) {
+  for (const auto& configuration : configurations) {
+    if (!configuration.hasType<std::unordered_map<std::string, RawValue>>()) {
       // TODO: The following checks have to be removed after codegen is shipped.
       // See T45151459.
       continue;
     }
 
     auto configurationPair =
-        static_cast<butter::map<std::string, RawValue>>(configuration);
+        static_cast<std::unordered_map<std::string, RawValue>>(configuration);
     auto pair = configurationPair.begin();
     auto operation = pair->first;
-    auto &parameters = pair->second;
+    auto& parameters = pair->second;
 
     if (operation == "matrix") {
       react_native_expect(parameters.hasType<std::vector<Float>>());
@@ -574,9 +542,50 @@ inline void fromRawValue(
 }
 
 inline void fromRawValue(
-    const PropsParserContext &context,
-    const RawValue &value,
-    PointerEventsMode &result) {
+    const PropsParserContext& /*context*/,
+    const RawValue& value,
+    TransformOrigin& result) {
+  react_native_expect(value.hasType<std::vector<RawValue>>());
+  auto origins = (std::vector<RawValue>)value;
+
+  TransformOrigin transformOrigin;
+
+  const size_t maxIndex = 2;
+
+  for (size_t i = 0; i < std::min(origins.size(), maxIndex); i++) {
+    const auto& origin = origins[i];
+    if (origin.hasType<Float>()) {
+      auto originFloat = (float)origin;
+      if (std::isfinite(originFloat)) {
+        transformOrigin.xy[i] = ValueUnit(originFloat, UnitType::Point);
+      } else {
+        transformOrigin.xy[i] = ValueUnit(0.0f, UnitType::Undefined);
+      }
+    } else if (origin.hasType<std::string>()) {
+      const auto stringValue = (std::string)origin;
+
+      if (stringValue.back() == '%') {
+        auto tryValue = folly::tryTo<float>(
+            std::string_view(stringValue).substr(0, stringValue.length() - 1));
+        if (tryValue.hasValue()) {
+          transformOrigin.xy[i] =
+              ValueUnit(tryValue.value(), UnitType::Percent);
+        }
+      }
+    }
+  }
+
+  if (origins.size() >= 3 && origins[2].hasType<Float>()) {
+    transformOrigin.z = (Float)origins[2];
+  }
+
+  result = transformOrigin;
+}
+
+inline void fromRawValue(
+    const PropsParserContext& context,
+    const RawValue& value,
+    PointerEventsMode& result) {
   result = PointerEventsMode::Auto;
   react_native_expect(value.hasType<std::string>());
   if (!value.hasType<std::string>()) {
@@ -604,9 +613,9 @@ inline void fromRawValue(
 }
 
 inline void fromRawValue(
-    const PropsParserContext &context,
-    const RawValue &value,
-    BackfaceVisibility &result) {
+    const PropsParserContext& context,
+    const RawValue& value,
+    BackfaceVisibility& result) {
   result = BackfaceVisibility::Auto;
   react_native_expect(value.hasType<std::string>());
   if (!value.hasType<std::string>()) {
@@ -630,9 +639,9 @@ inline void fromRawValue(
 }
 
 inline void fromRawValue(
-    const PropsParserContext &context,
-    const RawValue &value,
-    BorderCurve &result) {
+    const PropsParserContext& context,
+    const RawValue& value,
+    BorderCurve& result) {
   result = BorderCurve::Circular;
   react_native_expect(value.hasType<std::string>());
   if (!value.hasType<std::string>()) {
@@ -652,9 +661,9 @@ inline void fromRawValue(
 }
 
 inline void fromRawValue(
-    const PropsParserContext &context,
-    const RawValue &value,
-    BorderStyle &result) {
+    const PropsParserContext& context,
+    const RawValue& value,
+    BorderStyle& result) {
   result = BorderStyle::Solid;
   react_native_expect(value.hasType<std::string>());
   if (!value.hasType<std::string>()) {
@@ -677,130 +686,147 @@ inline void fromRawValue(
   react_native_expect(false);
 }
 
-inline std::string toString(
-    const std::array<float, yoga::enums::count<YGDimension>()> &dimensions) {
-  return "{" + folly::to<std::string>(dimensions[0]) + ", " +
-      folly::to<std::string>(dimensions[1]) + "}";
+inline void fromRawValue(
+    const PropsParserContext& /*context*/,
+    const RawValue& value,
+    LayoutConformance& result) {
+  result = LayoutConformance::Classic;
+  react_native_expect(value.hasType<std::string>());
+  if (!value.hasType<std::string>()) {
+    return;
+  }
+  auto stringValue = (std::string)value;
+  if (stringValue == "classic") {
+    result = LayoutConformance::Classic;
+    return;
+  }
+  if (stringValue == "strict") {
+    result = LayoutConformance::Strict;
+    return;
+  }
+  LOG(ERROR) << "Could not parse LayoutConformance:" << stringValue;
+  react_native_expect(false);
 }
 
-inline std::string toString(const std::array<float, 4> &position) {
-  return "{" + folly::to<std::string>(position[0]) + ", " +
-      folly::to<std::string>(position[1]) + "}";
-}
+template <size_t N>
+inline std::string toString(const std::array<float, N> vec) {
+  std::string s;
 
-inline std::string toString(
-    const std::array<float, yoga::enums::count<YGEdge>()> &edges) {
-  return "{" + folly::to<std::string>(edges[0]) + ", " +
-      folly::to<std::string>(edges[1]) + ", " +
-      folly::to<std::string>(edges[2]) + ", " +
-      folly::to<std::string>(edges[3]) + "}";
+  s.append("{");
+  for (size_t i = 0; i < N - 1; i++) {
+    s.append(std::to_string(vec[i]) + ", ");
+  }
+  s.append(std::to_string(vec[N - 1]));
+  s.append("}");
+
+  return s;
 }
 
-inline std::string toString(const YGDirection &value) {
+inline std::string toString(const yoga::Direction& value) {
   switch (value) {
-    case YGDirectionInherit:
+    case yoga::Direction::Inherit:
       return "inherit";
-    case YGDirectionLTR:
+    case yoga::Direction::LTR:
       return "ltr";
-    case YGDirectionRTL:
+    case yoga::Direction::RTL:
       return "rtl";
   }
 }
 
-inline std::string toString(const YGFlexDirection &value) {
+inline std::string toString(const yoga::FlexDirection& value) {
   switch (value) {
-    case YGFlexDirectionColumn:
+    case yoga::FlexDirection::Column:
       return "column";
-    case YGFlexDirectionColumnReverse:
+    case yoga::FlexDirection::ColumnReverse:
       return "column-reverse";
-    case YGFlexDirectionRow:
+    case yoga::FlexDirection::Row:
       return "row";
-    case YGFlexDirectionRowReverse:
+    case yoga::FlexDirection::RowReverse:
       return "row-reverse";
   }
 }
 
-inline std::string toString(const YGJustify &value) {
+inline std::string toString(const yoga::Justify& value) {
   switch (value) {
-    case YGJustifyFlexStart:
+    case yoga::Justify::FlexStart:
       return "flex-start";
-    case YGJustifyCenter:
+    case yoga::Justify::Center:
       return "center";
-    case YGJustifyFlexEnd:
+    case yoga::Justify::FlexEnd:
       return "flex-end";
-    case YGJustifySpaceBetween:
+    case yoga::Justify::SpaceBetween:
       return "space-between";
-    case YGJustifySpaceAround:
+    case yoga::Justify::SpaceAround:
       return "space-around";
-    case YGJustifySpaceEvenly:
+    case yoga::Justify::SpaceEvenly:
       return "space-evenly";
   }
 }
 
-inline std::string toString(const YGAlign &value) {
+inline std::string toString(const yoga::Align& value) {
   switch (value) {
-    case YGAlignAuto:
+    case yoga::Align::Auto:
       return "auto";
-    case YGAlignFlexStart:
+    case yoga::Align::FlexStart:
       return "flex-start";
-    case YGAlignCenter:
+    case yoga::Align::Center:
       return "center";
-    case YGAlignFlexEnd:
+    case yoga::Align::FlexEnd:
       return "flex-end";
-    case YGAlignStretch:
+    case yoga::Align::Stretch:
       return "stretch";
-    case YGAlignBaseline:
+    case yoga::Align::Baseline:
       return "baseline";
-    case YGAlignSpaceBetween:
+    case yoga::Align::SpaceBetween:
       return "space-between";
-    case YGAlignSpaceAround:
+    case yoga::Align::SpaceAround:
       return "space-around";
   }
 }
 
-inline std::string toString(const YGPositionType &value) {
+inline std::string toString(const yoga::PositionType& value) {
   switch (value) {
-    case YGPositionTypeStatic:
+    case yoga::PositionType::Static:
       return "static";
-    case YGPositionTypeRelative:
+    case yoga::PositionType::Relative:
       return "relative";
-    case YGPositionTypeAbsolute:
+    case yoga::PositionType::Absolute:
       return "absolute";
   }
 }
 
-inline std::string toString(const YGWrap &value) {
+inline std::string toString(const yoga::Wrap& value) {
   switch (value) {
-    case YGWrapNoWrap:
+    case yoga::Wrap::NoWrap:
       return "no-wrap";
-    case YGWrapWrap:
+    case yoga::Wrap::Wrap:
       return "wrap";
-    case YGWrapWrapReverse:
+    case yoga::Wrap::WrapReverse:
       return "wrap-reverse";
   }
 }
 
-inline std::string toString(const YGOverflow &value) {
+inline std::string toString(const yoga::Overflow& value) {
   switch (value) {
-    case YGOverflowVisible:
+    case yoga::Overflow::Visible:
       return "visible";
-    case YGOverflowScroll:
+    case yoga::Overflow::Scroll:
       return "scroll";
-    case YGOverflowHidden:
+    case yoga::Overflow::Hidden:
       return "hidden";
   }
 }
 
-inline std::string toString(const YGDisplay &value) {
+inline std::string toString(const yoga::Display& value) {
   switch (value) {
-    case YGDisplayFlex:
+    case yoga::Display::Flex:
       return "flex";
-    case YGDisplayNone:
+    case yoga::Display::None:
       return "none";
   }
 }
 
-inline std::string toString(const YGValue &value) {
+inline std::string toString(const YGValue& value) {
   switch (value.unit) {
     case YGUnitUndefined:
       return "undefined";
@@ -813,7 +839,7 @@ inline std::string toString(const YGValue &value) {
   }
 }
 
-inline std::string toString(const YGFloatOptional &value) {
+inline std::string toString(const yoga::FloatOptional& value) {
   if (value.isUndefined()) {
     return "undefined";
   }
@@ -821,12 +847,12 @@ inline std::string toString(const YGFloatOptional &value) {
   return folly::to<std::string>(floatFromYogaFloat(value.unwrap()));
 }
 
-inline std::string toString(const YGStyle::Dimensions &value) {
+inline std::string toString(const yoga::Style::Dimensions& value) {
   return "{" + toString(value[0]) + ", " + toString(value[1]) + "}";
 }
 
-inline std::string toString(const YGStyle::Edges &value) {
-  static std::array<std::string, yoga::enums::count<YGEdge>()> names = {
+inline std::string toString(const yoga::Style::Edges& value) {
+  static std::array<std::string, 9> names = {
       {"left",
        "top",
        "right",
@@ -840,7 +866,7 @@ inline std::string toString(const YGStyle::Edges &value) {
   auto result = std::string{};
   auto separator = std::string{", "};
 
-  for (auto i = 0; i < yoga::enums::count<YGEdge>(); i++) {
+  for (auto i = 0; i < names.size(); i++) {
     YGValue v = value[i];
     if (v.unit == YGUnitUndefined) {
       continue;
@@ -855,5 +881,15 @@ inline std::string toString(const YGStyle::Edges &value) {
   return "{" + result + "}";
 }
 
-} // namespace react
-} // namespace facebook
+inline std::string toString(const LayoutConformance& value) {
+  switch (value) {
+    case LayoutConformance::Undefined:
+      return "undefined";
+    case LayoutConformance::Classic:
+      return "classic";
+    case LayoutConformance::Strict:
+      return "strict";
+  }
+}
+
+} // namespace facebook::react