react-native-tvos 0.84.1-0 → 0.85.0-0

package/ReactCommon/react/renderer/css/CSSColorFunction.h

@@ -17,7 +17,6 @@
 #include <react/renderer/css/CSSAngle.h>
 #include <react/renderer/css/CSSNumber.h>
 #include <react/renderer/css/CSSPercentage.h>
-#include <react/renderer/css/CSSSyntaxParser.h>
 #include <react/renderer/css/CSSValueParser.h>
 #include <react/utils/PackTraits.h>
 #include <react/utils/fnv1a.h>
@@ -154,16 +153,19 @@ constexpr std::optional<float> normalizeComponent(
 }
 
 template <CSSDataType... FirstComponentAllowedTypesT>
-constexpr bool isLegacyColorFunction(CSSSyntaxParser &parser)
+constexpr bool isLegacyColorFunction(CSSValueParser &parser)
 {
-  auto lookahead = parser;
-  auto next = parseNextCSSValue<FirstComponentAllowedTypesT...>(lookahead);
+  auto saved = parser.syntaxParser();
+  auto next = parser.parseNextValue<FirstComponentAllowedTypesT...>();
   if (std::holds_alternative<std::monostate>(next)) {
+    parser.syntaxParser() = saved;
     return false;
   }
 
-  return lookahead.consumeComponentValue<bool>(
-      CSSDelimiter::OptionalWhitespace, [](CSSPreservedToken token) { return token.type() == CSSTokenType::Comma; });
+  parser.syntaxParser().consumeWhitespace();
+  bool isLegacy = parser.syntaxParser().peek().type() == CSSTokenType::Comma;
+  parser.syntaxParser() = saved;
+  return isLegacy;
 }
 
 /**
@@ -172,9 +174,9 @@ constexpr bool isLegacyColorFunction(CSSSyntaxParser &parser)
  * https://www.w3.org/TR/css-color-4/#typedef-legacy-rgb-syntax
  */
 template <typename CSSColor>
-constexpr std::optional<CSSColor> parseLegacyRgbFunction(CSSSyntaxParser &parser)
+constexpr std::optional<CSSColor> parseLegacyRgbFunction(CSSValueParser &parser)
 {
-  auto rawRed = parseNextCSSValue<CSSNumber, CSSPercentage>(parser);
+  auto rawRed = parser.parseNextValue<CSSNumber, CSSPercentage>();
   bool usesNumber = std::holds_alternative<CSSNumber>(rawRed);
 
   auto red = normalizeComponent(rawRed, 255.0f);
@@ -182,19 +184,19 @@ constexpr std::optional<CSSColor> parseLegacyRgbFunction(CSSSyntaxParser &parser
     return {};
   }
 
-  auto green = usesNumber ? normalizeNumberComponent(parseNextCSSValue<CSSNumber>(parser, CSSDelimiter::Comma))
-                          : normalizeComponent(parseNextCSSValue<CSSPercentage>(parser, CSSDelimiter::Comma), 255.0f);
+  auto green = usesNumber ? normalizeNumberComponent(parser.parseNextValue<CSSNumber>(CSSDelimiter::Comma))
+                          : normalizeComponent(parser.parseNextValue<CSSPercentage>(CSSDelimiter::Comma), 255.0f);
   if (!green.has_value()) {
     return {};
   }
 
-  auto blue = usesNumber ? normalizeNumberComponent(parseNextCSSValue<CSSNumber>(parser, CSSDelimiter::Comma))
-                         : normalizeComponent(parseNextCSSValue<CSSPercentage>(parser, CSSDelimiter::Comma), 255.0f);
+  auto blue = usesNumber ? normalizeNumberComponent(parser.parseNextValue<CSSNumber>(CSSDelimiter::Comma))
+                         : normalizeComponent(parser.parseNextValue<CSSPercentage>(CSSDelimiter::Comma), 255.0f);
   if (!blue.has_value()) {
     return {};
   }
 
-  auto alpha = normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::Comma), 1.0f);
+  auto alpha = normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::Comma), 1.0f);
 
   return CSSColor{
       .r = clamp255Component(*red),
@@ -210,26 +212,25 @@ constexpr std::optional<CSSColor> parseLegacyRgbFunction(CSSSyntaxParser &parser
  * https://www.w3.org/TR/css-color-4/#typedef-modern-rgb-syntax
  */
 template <typename CSSColor>
-constexpr std::optional<CSSColor> parseModernRgbFunction(CSSSyntaxParser &parser)
+constexpr std::optional<CSSColor> parseModernRgbFunction(CSSValueParser &parser)
 {
-  auto red = normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser), 255.0f);
+  auto red = normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(), 255.0f);
   if (!red.has_value()) {
     return {};
   }
 
-  auto green =
-      normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::Whitespace), 255.0f);
+  auto green = normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::Whitespace), 255.0f);
   if (!green.has_value()) {
     return {};
   }
 
-  auto blue = normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::Whitespace), 255.0f);
+  auto blue = normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::Whitespace), 255.0f);
   if (!blue.has_value()) {
     return {};
   }
 
   auto alpha =
-      normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::SolidusOrWhitespace), 1.0f);
+      normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::SolidusOrWhitespace), 1.0f);
 
   return CSSColor{
       .r = clamp255Component(*red),
@@ -244,7 +245,7 @@ constexpr std::optional<CSSColor> parseModernRgbFunction(CSSSyntaxParser &parser
  * https://www.w3.org/TR/css-color-4/#funcdef-rgb
  */
 template <typename CSSColor>
-constexpr std::optional<CSSColor> parseRgbFunction(CSSSyntaxParser &parser)
+constexpr std::optional<CSSColor> parseRgbFunction(CSSValueParser &parser)
 {
   if (isLegacyColorFunction<CSSNumber, CSSPercentage>(parser)) {
     return parseLegacyRgbFunction<CSSColor>(parser);
@@ -259,24 +260,24 @@ constexpr std::optional<CSSColor> parseRgbFunction(CSSSyntaxParser &parser)
  * https://www.w3.org/TR/css-color-4/#typedef-legacy-hsl-syntax
  */
 template <typename CSSColor>
-inline std::optional<CSSColor> parseLegacyHslFunction(CSSSyntaxParser &parser)
+inline std::optional<CSSColor> parseLegacyHslFunction(CSSValueParser &parser)
 {
-  auto h = normalizeHueComponent(parseNextCSSValue<CSSNumber, CSSAngle>(parser));
+  auto h = normalizeHueComponent(parser.parseNextValue<CSSNumber, CSSAngle>());
   if (!h.has_value()) {
     return {};
   }
 
-  auto s = normalizeComponent(parseNextCSSValue<CSSPercentage>(parser, CSSDelimiter::Comma), 100.0f);
+  auto s = normalizeComponent(parser.parseNextValue<CSSPercentage>(CSSDelimiter::Comma), 100.0f);
   if (!s.has_value()) {
     return {};
   }
 
-  auto l = normalizeComponent(parseNextCSSValue<CSSPercentage>(parser, CSSDelimiter::Comma), 100.0f);
+  auto l = normalizeComponent(parser.parseNextValue<CSSPercentage>(CSSDelimiter::Comma), 100.0f);
   if (!l.has_value()) {
     return {};
   }
 
-  auto a = normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::Comma), 1.0f);
+  auto a = normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::Comma), 1.0f);
 
   auto [r, g, b] = hslToRgb(*h, *s, *l);
 
@@ -293,25 +294,24 @@ inline std::optional<CSSColor> parseLegacyHslFunction(CSSSyntaxParser &parser)
  * it is valid. https://www.w3.org/TR/css-color-4/#typedef-modern-hsl-syntax
  */
 template <typename CSSColor>
-inline std::optional<CSSColor> parseModernHslFunction(CSSSyntaxParser &parser)
+inline std::optional<CSSColor> parseModernHslFunction(CSSValueParser &parser)
 {
-  auto h = normalizeHueComponent(parseNextCSSValue<CSSNumber, CSSAngle>(parser));
+  auto h = normalizeHueComponent(parser.parseNextValue<CSSNumber, CSSAngle>());
   if (!h.has_value()) {
     return {};
   }
 
-  auto s = normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::Whitespace), 100.0f);
+  auto s = normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::Whitespace), 100.0f);
   if (!s.has_value()) {
     return {};
   }
 
-  auto l = normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::Whitespace), 100.0f);
+  auto l = normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::Whitespace), 100.0f);
   if (!l.has_value()) {
     return {};
   }
 
-  auto a =
-      normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::SolidusOrWhitespace), 1.0f);
+  auto a = normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::SolidusOrWhitespace), 1.0f);
 
   auto [r, g, b] = hslToRgb(*h, *s, *l);
 
@@ -328,7 +328,7 @@ inline std::optional<CSSColor> parseModernHslFunction(CSSSyntaxParser &parser)
  * https://www.w3.org/TR/css-color-4/#funcdef-hsl
  */
 template <typename CSSColor>
-inline std::optional<CSSColor> parseHslFunction(CSSSyntaxParser &parser)
+inline std::optional<CSSColor> parseHslFunction(CSSValueParser &parser)
 {
   if (isLegacyColorFunction<CSSNumber, CSSAngle>(parser)) {
     return parseLegacyHslFunction<CSSColor>(parser);
@@ -342,25 +342,24 @@ inline std::optional<CSSColor> parseHslFunction(CSSSyntaxParser &parser)
  * https://www.w3.org/TR/css-color-4/#funcdef-hwb
  */
 template <typename CSSColor>
-inline std::optional<CSSColor> parseHwbFunction(CSSSyntaxParser &parser)
+inline std::optional<CSSColor> parseHwbFunction(CSSValueParser &parser)
 {
-  auto h = normalizeHueComponent(parseNextCSSValue<CSSNumber, CSSAngle>(parser));
+  auto h = normalizeHueComponent(parser.parseNextValue<CSSNumber, CSSAngle>());
   if (!h.has_value()) {
     return {};
   }
 
-  auto w = normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::Whitespace), 100.0f);
+  auto w = normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::Whitespace), 100.0f);
   if (!w.has_value()) {
     return {};
   }
 
-  auto b = normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::Whitespace), 100.0f);
+  auto b = normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::Whitespace), 100.0f);
   if (!b.has_value()) {
     return {};
   }
 
-  auto a =
-      normalizeComponent(parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::SolidusOrWhitespace), 1.0f);
+  auto a = normalizeComponent(parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::SolidusOrWhitespace), 1.0f);
 
   auto [red, green, blue] = hwbToRgb(*h, *w, *b);
 
@@ -380,7 +379,7 @@ inline std::optional<CSSColor> parseHwbFunction(CSSSyntaxParser &parser)
  * https://www.w3.org/TR/css-color-4/#typedef-color-function
  */
 template <typename CSSColor>
-constexpr std::optional<CSSColor> parseCSSColorFunction(std::string_view colorFunction, CSSSyntaxParser &parser)
+constexpr std::optional<CSSColor> parseCSSColorFunction(std::string_view colorFunction, CSSValueParser &parser)
 {
   switch (fnv1aLowercase(colorFunction)) {
     // CSS Color Module Level 4 treats the alpha variants of functions as the

package/ReactCommon/react/renderer/css/CSSCompoundDataType.h

@@ -11,18 +11,24 @@
 
 namespace facebook::react {
 
-namespace detail {
-struct CSSCompoundDataTypeMarker {};
-} // namespace detail
-
 /**
  * Allows grouping together multiple possible CSSDataType to parse.
+ * CSSCompoundDataType is a std::variant of the allowed types, serving both
+ * as storage and for template parameter deduction during parsing.
  */
 template <CSSDataType... AllowedTypesT>
-struct CSSCompoundDataType : public detail::CSSCompoundDataTypeMarker {};
+using CSSCompoundDataType = std::variant<AllowedTypesT...>;
+
+namespace detail {
+template <typename T>
+struct is_variant_of_data_types : std::false_type {};
+
+template <CSSDataType... Ts>
+struct is_variant_of_data_types<std::variant<Ts...>> : std::true_type {};
+} // namespace detail
 
 template <typename T>
-concept CSSValidCompoundDataType = std::is_base_of_v<detail::CSSCompoundDataTypeMarker, T>;
+concept CSSValidCompoundDataType = detail::is_variant_of_data_types<T>::value;
 
 /**
  * A concrete data type, or a compound data type which represents multiple other
@@ -38,40 +44,40 @@ template <CSSMaybeCompoundDataType... AllowedTypesT>
 struct merge_data_types;
 
 template <CSSDataType... AlllowedTypes1T, CSSDataType... AlllowedTypes2T, CSSMaybeCompoundDataType... RestT>
-struct merge_data_types<CSSCompoundDataType<AlllowedTypes1T...>, CSSCompoundDataType<AlllowedTypes2T...>, RestT...> {
-  using type = typename merge_data_types<CSSCompoundDataType<AlllowedTypes1T..., AlllowedTypes2T...>, RestT...>::type;
+struct merge_data_types<std::variant<AlllowedTypes1T...>, std::variant<AlllowedTypes2T...>, RestT...> {
+  using type = typename merge_data_types<std::variant<AlllowedTypes1T..., AlllowedTypes2T...>, RestT...>::type;
 };
 
 template <CSSDataType AlllowedType1T, CSSDataType... AlllowedTypes2T, CSSMaybeCompoundDataType... RestT>
-struct merge_data_types<AlllowedType1T, CSSCompoundDataType<AlllowedTypes2T...>, RestT...> {
-  using type = typename merge_data_types<CSSCompoundDataType<AlllowedType1T, AlllowedTypes2T...>, RestT...>::type;
+struct merge_data_types<AlllowedType1T, std::variant<AlllowedTypes2T...>, RestT...> {
+  using type = typename merge_data_types<std::variant<AlllowedType1T, AlllowedTypes2T...>, RestT...>::type;
 };
 
 template <CSSDataType AlllowedType2T, CSSDataType... AlllowedTypes1T, CSSMaybeCompoundDataType... RestT>
-struct merge_data_types<CSSCompoundDataType<AlllowedTypes1T...>, AlllowedType2T, RestT...> {
-  using type = typename merge_data_types<CSSCompoundDataType<AlllowedTypes1T..., AlllowedType2T>, RestT...>::type;
+struct merge_data_types<std::variant<AlllowedTypes1T...>, AlllowedType2T, RestT...> {
+  using type = typename merge_data_types<std::variant<AlllowedTypes1T..., AlllowedType2T>, RestT...>::type;
 };
 
 template <CSSDataType AlllowedType1T, CSSDataType AlllowedType2T, CSSMaybeCompoundDataType... RestT>
 struct merge_data_types<AlllowedType1T, AlllowedType2T, RestT...> {
-  using type = typename merge_data_types<CSSCompoundDataType<AlllowedType1T, AlllowedType2T>, RestT...>::type;
+  using type = typename merge_data_types<std::variant<AlllowedType1T, AlllowedType2T>, RestT...>::type;
 };
 
 template <CSSDataType... AllowedTypesT>
-struct merge_data_types<CSSCompoundDataType<AllowedTypesT...>> {
-  using type = CSSCompoundDataType<AllowedTypesT...>;
+struct merge_data_types<std::variant<AllowedTypesT...>> {
+  using type = std::variant<AllowedTypesT...>;
 };
 
 template <CSSDataType AllowedTypeT>
 struct merge_data_types<AllowedTypeT> {
-  using type = CSSCompoundDataType<AllowedTypeT>;
+  using type = std::variant<AllowedTypeT>;
 };
 
 template <typename... T>
 struct merge_variant;
 
 template <CSSDataType... AllowedTypesT, typename... RestT>
-struct merge_variant<CSSCompoundDataType<AllowedTypesT...>, RestT...> {
+struct merge_variant<std::variant<AllowedTypesT...>, RestT...> {
   using type = std::variant<RestT..., AllowedTypesT...>;
 };
 } // namespace detail

package/ReactCommon/react/renderer/css/CSSDataType.h

@@ -16,6 +16,8 @@
 
 namespace facebook::react {
 
+class CSSValueParser;
+
 /**
  * May be specialized to instruct the CSS value parser how to parse a given data
  * type, according to CSSValidDataTypeParser.
@@ -24,26 +26,28 @@ template <typename CSSDataTypeT>
 struct CSSDataTypeParser {};
 
 /**
- * Accepts a CSS function block and may parse it (and future syntax) into a
- * concrete representation.
+ * Accepts a CSS function block and may parse it into a concrete representation.
+ * The CSSValueParser provides methods for parsing sub-values within the
+ * function block scope.
  */
 template <typename T, typename ReturnT = std::any>
-concept CSSFunctionBlockSink = requires(const CSSFunctionBlock &func, CSSSyntaxParser &parser) {
+concept CSSFunctionBlockSink = requires(const CSSFunctionBlock &func, CSSValueParser &parser) {
   { T::consumeFunctionBlock(func, parser) } -> std::convertible_to<ReturnT>;
 };
 
 /**
- * Accepts a CSS simple block and may parse it (and future syntax) into a
- * concrete representation.
+ * Accepts a CSS simple block and may parse it into a concrete representation.
+ * The CSSValueParser provides methods for parsing sub-values within the
+ * block scope.
  */
 template <typename T, typename ReturnT = std::any>
-concept CSSSimpleBlockSink = requires(const CSSSimpleBlock &block, CSSSyntaxParser &parser) {
+concept CSSSimpleBlockSink = requires(const CSSSimpleBlock &block, CSSValueParser &parser) {
   { T::consumeSimpleBlock(block, parser) } -> std::convertible_to<ReturnT>;
 };
 
 /**
- * Accepts a CSS preserved token and may parse it (and future syntax) into a
- * concrete representation.
+ * Accepts a CSS preserved token and may parse it into a concrete
+ * representation.
  */
 template <typename T, typename ReturnT = std::any>
 concept CSSPreservedTokenSink = requires(const CSSPreservedToken &token) {
@@ -51,10 +55,11 @@ concept CSSPreservedTokenSink = requires(const CSSPreservedToken &token) {
 };
 
 /**
- * Accepts a raw syntax parser, to be able to parse compounded values
+ * Accepts a CSSValueParser to be able to parse compounded values spanning
+ * multiple component values.
  */
 template <typename T, typename ReturnT = std::any>
-concept CSSParserSink = requires(CSSSyntaxParser &parser) {
+concept CSSParserSink = requires(CSSValueParser &parser) {
   { T::consume(parser) } -> std::convertible_to<ReturnT>;
 };
 

package/ReactCommon/react/renderer/css/CSSFilter.h

@@ -28,14 +28,14 @@ namespace detail {
 template <typename DataT, TemplateStringLiteral Name>
   requires(std::is_same_v<decltype(DataT::amount), float>)
 struct CSSFilterSimpleAmountParser {
-  static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
+  static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
       -> std::optional<DataT>
   {
     if (!iequals(func.name, Name)) {
       return {};
     }
 
-    auto amount = parseNextCSSValue<CSSNumber, CSSPercentage>(parser);
+    auto amount = parser.parseNextValue<CSSNumber, CSSPercentage>();
     if (std::holds_alternative<CSSNumber>(amount)) {
       if (std::get<CSSNumber>(amount).value < 0.0f) {
         return {};
@@ -65,14 +65,14 @@ struct CSSBlurFilter {
 
 template <>
 struct CSSDataTypeParser<CSSBlurFilter> {
-  static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
+  static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
       -> std::optional<CSSBlurFilter>
   {
     if (!iequals(func.name, "blur")) {
       return {};
     }
 
-    auto len = parseNextCSSValue<CSSLength>(parser);
+    auto len = parser.parseNextValue<CSSLength>();
     return CSSBlurFilter{std::holds_alternative<CSSLength>(len) ? std::get<CSSLength>(len) : CSSLength{}};
   }
 };
@@ -123,7 +123,7 @@ struct CSSDropShadowFilter {
 
 template <>
 struct CSSDataTypeParser<CSSDropShadowFilter> {
-  static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
+  static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
       -> std::optional<CSSDropShadowFilter>
   {
     if (!iequals(func.name, "drop-shadow")) {
@@ -133,7 +133,7 @@ struct CSSDataTypeParser<CSSDropShadowFilter> {
     std::optional<CSSColor> color{};
     std::optional<std::array<CSSLength, 3>> lengths{};
 
-    auto firstVal = parseNextCSSValue<CSSColor, CSSLength>(parser);
+    auto firstVal = parser.parseNextValue<CSSColor, CSSLength>();
     if (std::holds_alternative<std::monostate>(firstVal)) {
       return {};
     }
@@ -147,7 +147,7 @@ struct CSSDataTypeParser<CSSDropShadowFilter> {
       }
     }
 
-    auto secondVal = parseNextCSSValue<CSSColor, CSSLength>(parser, CSSDelimiter::Whitespace);
+    auto secondVal = parser.parseNextValue<CSSColor, CSSLength>(CSSDelimiter::Whitespace);
     if (std::holds_alternative<CSSColor>(secondVal)) {
       if (color.has_value()) {
         return {};
@@ -173,14 +173,14 @@ struct CSSDataTypeParser<CSSDropShadowFilter> {
   }
 
  private:
-  static constexpr std::optional<std::array<CSSLength, 3>> parseLengths(CSSLength offsetX, CSSSyntaxParser &parser)
+  static constexpr std::optional<std::array<CSSLength, 3>> parseLengths(CSSLength offsetX, CSSValueParser &parser)
   {
-    auto offsetY = parseNextCSSValue<CSSLength>(parser, CSSDelimiter::Whitespace);
+    auto offsetY = parser.parseNextValue<CSSLength>(CSSDelimiter::Whitespace);
     if (!std::holds_alternative<CSSLength>(offsetY)) {
       return {};
     }
 
-    auto standardDeviation = parseNextCSSValue<CSSLength>(parser, CSSDelimiter::Whitespace);
+    auto standardDeviation = parser.parseNextValue<CSSLength>(CSSDelimiter::Whitespace);
     if (std::holds_alternative<CSSLength>(standardDeviation) && std::get<CSSLength>(standardDeviation).value < 0.0f) {
       return {};
     }
@@ -220,14 +220,14 @@ struct CSSHueRotateFilter {
 
 template <>
 struct CSSDataTypeParser<CSSHueRotateFilter> {
-  static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
+  static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
       -> std::optional<CSSHueRotateFilter>
   {
     if (!iequals(func.name, "hue-rotate")) {
       return {};
     }
 
-    auto angle = parseNextCSSValue<CSSAngle, CSSZero>(parser);
+    auto angle = parser.parseNextValue<CSSAngle, CSSZero>();
     return CSSHueRotateFilter{std::holds_alternative<CSSAngle>(angle) ? std::get<CSSAngle>(angle).degrees : 0.0f};
   }
 };
@@ -307,11 +307,6 @@ using CSSFilterFunction = CSSCompoundDataType<
     CSSSaturateFilter,
     CSSSepiaFilter>;
 
-/**
- * Variant of possible CSS filter function types
- */
-using CSSFilterFunctionVariant = CSSVariantWithTypes<CSSFilterFunction>;
-
 /**
  * Representation of <filter-value-list>
  * https://www.w3.org/TR/filter-effects-1/#typedef-filter-value-list

package/ReactCommon/react/renderer/css/CSSKeyword.h

@@ -23,6 +23,7 @@ namespace facebook::react {
  */
 enum class CSSKeyword : uint8_t {
   Absolute,
+  At,
   Auto,
   Baseline,
   Block,
@@ -110,6 +111,7 @@ enum class CSSKeyword : uint8_t {
   TabularNums,
   Thick,
   Thin,
+  To,
   Top,
   Unset,
   Visible,
@@ -143,6 +145,7 @@ enum class CSSWideKeyword : std::underlying_type_t<CSSKeyword> {
   }
 
 CSS_DEFINE_KEYWORD(Absolute, "absolute")
+CSS_DEFINE_KEYWORD(At, "at")
 CSS_DEFINE_KEYWORD(Auto, "auto")
 CSS_DEFINE_KEYWORD(Baseline, "baseline")
 CSS_DEFINE_KEYWORD(Block, "block")
@@ -230,6 +233,7 @@ CSS_DEFINE_KEYWORD(StylisticTwo, "stylistic-two")
 CSS_DEFINE_KEYWORD(TabularNums, "tabular-nums")
 CSS_DEFINE_KEYWORD(Thick, "thick")
 CSS_DEFINE_KEYWORD(Thin, "thin")
+CSS_DEFINE_KEYWORD(To, "to")
 CSS_DEFINE_KEYWORD(Top, "top")
 CSS_DEFINE_KEYWORD(Unset, "unset")
 CSS_DEFINE_KEYWORD(Visible, "visible")
@@ -254,6 +258,7 @@ constexpr std::optional<KeywordT> parseCSSKeyword(std::string_view ident)
 {
   switch (fnv1aLowercase(ident)) {
     CSS_HANDLE_KEYWORD(Absolute)
+    CSS_HANDLE_KEYWORD(At)
     CSS_HANDLE_KEYWORD(Auto)
     CSS_HANDLE_KEYWORD(Baseline)
     CSS_HANDLE_KEYWORD(Block)
@@ -341,11 +346,14 @@ constexpr std::optional<KeywordT> parseCSSKeyword(std::string_view ident)
     CSS_HANDLE_KEYWORD(TabularNums)
     CSS_HANDLE_KEYWORD(Thick)
     CSS_HANDLE_KEYWORD(Thin)
+    CSS_HANDLE_KEYWORD(To)
     CSS_HANDLE_KEYWORD(Top)
     CSS_HANDLE_KEYWORD(Unset)
     CSS_HANDLE_KEYWORD(Visible)
     CSS_HANDLE_KEYWORD(Wrap)
     CSS_HANDLE_KEYWORD(WrapReverse)
+    default:
+      return std::nullopt;
   }
 
   return std::nullopt;

package/ReactCommon/react/renderer/css/CSSList.h

@@ -17,22 +17,22 @@
 
 namespace facebook::react {
 
-template <CSSMaybeCompoundDataType T, CSSDelimiter Delim>
+template <CSSMaybeCompoundDataType T, CSSDelimiter Delimeter>
 struct CSSList;
 
-template <CSSDataType AllowedTypeT, CSSDelimiter Delim>
-struct CSSList<AllowedTypeT, Delim> : public std::vector<AllowedTypeT> {};
+template <CSSDataType AllowedTypeT, CSSDelimiter Delimeter>
+struct CSSList<AllowedTypeT, Delimeter> : public std::vector<AllowedTypeT> {};
 
-template <CSSValidCompoundDataType AllowedTypesT, CSSDelimiter Delim>
-struct CSSList<AllowedTypesT, Delim> : public std::vector<CSSVariantWithTypes<AllowedTypesT>> {};
+template <CSSValidCompoundDataType AllowedTypesT, CSSDelimiter Delimeter>
+struct CSSList<AllowedTypesT, Delimeter> : public std::vector<AllowedTypesT> {};
 
-template <CSSMaybeCompoundDataType AllowedTypeT, CSSDelimiter Delim>
-struct CSSDataTypeParser<CSSList<AllowedTypeT, Delim>> {
-  static inline auto consume(CSSSyntaxParser &parser) -> std::optional<CSSList<AllowedTypeT, Delim>>
+template <CSSMaybeCompoundDataType AllowedTypeT, CSSDelimiter Delimeter>
+struct CSSDataTypeParser<CSSList<AllowedTypeT, Delimeter>> {
+  static inline auto consume(CSSValueParser &parser) -> std::optional<CSSList<AllowedTypeT, Delimeter>>
   {
-    CSSList<AllowedTypeT, Delim> result;
-    for (auto nextValue = parseNextCSSValue<AllowedTypeT>(parser); !std::holds_alternative<std::monostate>(nextValue);
-         nextValue = parseNextCSSValue<AllowedTypeT>(parser, Delim)) {
+    CSSList<AllowedTypeT, Delimeter> result;
+    for (auto nextValue = parser.parseNextValue<AllowedTypeT>(); !std::holds_alternative<std::monostate>(nextValue);
+         nextValue = parser.parseNextValue<AllowedTypeT>(Delimeter)) {
       // Copy from the variant of possible values to the element (either the
       // concrete type, or a variant of compound types which exlcudes the
       // possibility of std::monostate for parse error)

package/ReactCommon/react/renderer/css/CSSRatio.h

@@ -38,20 +38,20 @@ struct CSSRatio {
 
 template <>
 struct CSSDataTypeParser<CSSRatio> {
-  static constexpr auto consume(CSSSyntaxParser &parser) -> std::optional<CSSRatio>
+  static constexpr auto consume(CSSValueParser &parser) -> std::optional<CSSRatio>
   {
     // <ratio> = <number [0,∞]> [ / <number [0,∞]> ]?
     // https://www.w3.org/TR/css-values-4/#ratio
-    auto numerator = parseNextCSSValue<CSSNumber>(parser);
+    auto numerator = parser.parseNextValue<CSSNumber>();
     if (!std::holds_alternative<CSSNumber>(numerator)) {
       return {};
     }
 
     auto numeratorValue = std::get<CSSNumber>(numerator).value;
     if (numeratorValue >= 0) {
-      auto denominator = peekNextCSSValue<CSSNumber>(parser, CSSDelimiter::Solidus);
+      auto denominator = parser.peekNextValue<CSSNumber>(CSSDelimiter::Solidus);
       if (std::holds_alternative<CSSNumber>(denominator) && std::get<CSSNumber>(denominator).value >= 0) {
-        parseNextCSSValue<CSSNumber>(parser, CSSDelimiter::Solidus);
+        parser.parseNextValue<CSSNumber>(CSSDelimiter::Solidus);
         return CSSRatio{.numerator = numeratorValue, .denominator = std::get<CSSNumber>(denominator).value};
       }
 

package/ReactCommon/react/renderer/css/CSSShadow.h

@@ -46,15 +46,15 @@ static_assert(CSSDataType<CSSInsetShadowKeyword>);
 
 template <>
 struct CSSDataTypeParser<CSSShadow> {
-  static constexpr auto consume(CSSSyntaxParser &parser) -> std::optional<CSSShadow>
+  static constexpr auto consume(CSSValueParser &parser) -> std::optional<CSSShadow>
   {
     std::optional<CSSColor> color{};
     bool inset{false};
     std::optional<std::tuple<CSSLength, CSSLength, CSSLength, CSSLength>> lengths{};
 
-    for (auto nextValue = parseNextCSSValue<CSSLength, CSSColor, CSSInsetShadowKeyword>(parser);
+    for (auto nextValue = parser.parseNextValue<CSSLength, CSSColor, CSSInsetShadowKeyword>();
          !std::holds_alternative<std::monostate>(nextValue);
-         nextValue = parseNextCSSValue<CSSLength, CSSColor, CSSInsetShadowKeyword>(parser, CSSDelimiter::Whitespace)) {
+         nextValue = parser.parseNextValue<CSSLength, CSSColor, CSSInsetShadowKeyword>(CSSDelimiter::Whitespace)) {
       if (std::holds_alternative<CSSLength>(nextValue)) {
         if (lengths.has_value()) {
           return {};
@@ -98,15 +98,15 @@ struct CSSDataTypeParser<CSSShadow> {
   }
 
  private:
-  static constexpr auto parseRestLengths(CSSLength offsetX, CSSSyntaxParser &parser)
+  static constexpr auto parseRestLengths(CSSLength offsetX, CSSValueParser &parser)
       -> std::optional<std::tuple<CSSLength, CSSLength, CSSLength, CSSLength>>
   {
-    auto offsetY = parseNextCSSValue<CSSLength>(parser, CSSDelimiter::Whitespace);
+    auto offsetY = parser.parseNextValue<CSSLength>(CSSDelimiter::Whitespace);
     if (std::holds_alternative<std::monostate>(offsetY)) {
       return {};
     }
 
-    auto blurRadius = parseNextCSSValue<CSSLength>(parser, CSSDelimiter::Whitespace);
+    auto blurRadius = parser.parseNextValue<CSSLength>(CSSDelimiter::Whitespace);
     if (std::holds_alternative<std::monostate>(blurRadius)) {
       return std::make_tuple(offsetX, std::get<CSSLength>(offsetY), CSSLength{}, CSSLength{});
     }
@@ -114,7 +114,7 @@ struct CSSDataTypeParser<CSSShadow> {
       return {};
     }
 
-    auto spreadDistance = parseNextCSSValue<CSSLength>(parser, CSSDelimiter::Whitespace);
+    auto spreadDistance = parser.parseNextValue<CSSLength>(CSSDelimiter::Whitespace);
     if (std::holds_alternative<std::monostate>(spreadDistance)) {
       return std::make_tuple(offsetX, std::get<CSSLength>(offsetY), std::get<CSSLength>(blurRadius), CSSLength{});
     }