react-native-tvos 0.84.0-0rc5 → 0.85.0-0

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

@@ -113,6 +113,7 @@ enum class CSSDelimiter {
 class CSSSyntaxParser {
   template <CSSSyntaxVisitorReturn ReturnT, CSSComponentValueVisitor<ReturnT>... VisitorsT>
   friend struct CSSComponentValueVisitorDispatcher;
+  friend class CSSValueParser;
 
  public:
   /**
@@ -226,9 +227,17 @@ class CSSSyntaxParser {
         return hasWhiteSpace;
       case CSSDelimiter::None:
         return true;
+      default:
+        return false;
     }
+  }
 
-    return false;
+  /**
+   * Returns the current token without consuming it.
+   */
+  constexpr const CSSToken &peek() const
+  {
+    return currentToken_;
   }
 
  private:
@@ -237,11 +246,6 @@ class CSSSyntaxParser {
   {
   }
 
-  constexpr const CSSToken &peek() const
-  {
-    return currentToken_;
-  }
-
   constexpr CSSToken consumeToken()
   {
     auto prevToken = currentToken_;

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

@@ -67,6 +67,8 @@ class CSSTokenizer {
         } else {
           return consumeDelim();
         }
+      default:
+        break;
     }
 
     if (isDigit(nextChar)) {

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

@@ -29,14 +29,14 @@ namespace detail {
 template <typename DataT, TemplateStringLiteral Name, CSSDataType... AllowedComponentsT>
   requires(std::is_same_v<decltype(DataT::value), std::variant<AllowedComponentsT...>>)
 struct CSSVariantComponentTransformParser {
-  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 val = parseNextCSSValue<AllowedComponentsT...>(parser);
+    auto val = parser.parseNextValue<AllowedComponentsT...>();
 
     return std::visit(
         [&](auto &&v) -> std::optional<DataT> {
@@ -53,14 +53,14 @@ struct CSSVariantComponentTransformParser {
 template <typename DataT, TemplateStringLiteral Name>
   requires(std::is_same_v<decltype(DataT::value), float>)
 struct CSSNumberPercentTransformParser {
-  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 val = parseNextCSSValue<CSSNumber, CSSPercentage>(parser);
+    auto val = parser.parseNextValue<CSSNumber, CSSPercentage>();
     if (std::holds_alternative<std::monostate>(val)) {
       return {};
     }
@@ -74,14 +74,14 @@ struct CSSNumberPercentTransformParser {
 template <typename DataT, TemplateStringLiteral Name>
   requires(std::is_same_v<decltype(DataT::degrees), float>)
 struct CSSAngleTransformParser {
-  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 value = parseNextCSSValue<CSSAngle, CSSZero>(parser);
+    auto value = parser.parseNextValue<CSSAngle, CSSZero>();
     if (std::holds_alternative<std::monostate>(value)) {
       return {};
     }
@@ -105,7 +105,7 @@ struct CSSMatrix {
 
 template <>
 struct CSSDataTypeParser<CSSMatrix> {
-  static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
+  static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
       -> std::optional<CSSMatrix>
   {
     if (!iequals(func.name, "matrix")) {
@@ -114,7 +114,7 @@ struct CSSDataTypeParser<CSSMatrix> {
 
     CSSMatrix matrix{};
     for (int i = 0; i < 6; i++) {
-      auto value = parseNextCSSValue<CSSNumber>(parser, i == 0 ? CSSDelimiter::None : CSSDelimiter::Comma);
+      auto value = parser.parseNextValue<CSSNumber>(i == 0 ? CSSDelimiter::None : CSSDelimiter::Comma);
       if (std::holds_alternative<std::monostate>(value)) {
         return {};
       }
@@ -139,19 +139,19 @@ struct CSSTranslate {
 
 template <>
 struct CSSDataTypeParser<CSSTranslate> {
-  static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
+  static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
       -> std::optional<CSSTranslate>
   {
     if (!iequals(func.name, "translate")) {
       return {};
     }
 
-    auto x = parseNextCSSValue<CSSLengthPercentage>(parser);
+    auto x = parser.parseNextValue<CSSLengthPercentage>();
     if (std::holds_alternative<std::monostate>(x)) {
       return {};
     }
 
-    auto y = parseNextCSSValue<CSSLengthPercentage>(parser, CSSDelimiter::Comma);
+    auto y = parser.parseNextValue<CSSLengthPercentage>(CSSDelimiter::Comma);
 
     CSSTranslate translate{};
     translate.x = std::holds_alternative<CSSLength>(x)
@@ -183,24 +183,24 @@ struct CSSTranslate3D {
 
 template <>
 struct CSSDataTypeParser<CSSTranslate3D> {
-  static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
+  static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
       -> std::optional<CSSTranslate3D>
   {
     if (!iequals(func.name, "translate3d")) {
       return {};
     }
 
-    auto x = parseNextCSSValue<CSSLengthPercentage>(parser);
+    auto x = parser.parseNextValue<CSSLengthPercentage>();
     if (std::holds_alternative<std::monostate>(x)) {
       return {};
     }
 
-    auto y = parseNextCSSValue<CSSLengthPercentage>(parser, CSSDelimiter::Comma);
+    auto y = parser.parseNextValue<CSSLengthPercentage>(CSSDelimiter::Comma);
     if (std::holds_alternative<std::monostate>(y)) {
       return {};
     }
 
-    auto z = parseNextCSSValue<CSSLength>(parser, CSSDelimiter::Comma);
+    auto z = parser.parseNextValue<CSSLength>(CSSDelimiter::Comma);
     if (std::holds_alternative<std::monostate>(z)) {
       return {};
     }
@@ -259,7 +259,7 @@ struct CSSScale {
 
 template <>
 struct CSSDataTypeParser<CSSScale> {
-  static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
+  static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
       -> std::optional<CSSScale>
   {
     if (!iequals(func.name, "scale")) {
@@ -268,12 +268,12 @@ struct CSSDataTypeParser<CSSScale> {
 
     // Transforms module level 2 allows percentage syntax
     // https://drafts.csswg.org/css-transforms-2/#transform-functions
-    auto x = parseNextCSSValue<CSSNumber, CSSPercentage>(parser);
+    auto x = parser.parseNextValue<CSSNumber, CSSPercentage>();
     if (std::holds_alternative<std::monostate>(x)) {
       return {};
     }
 
-    auto y = parseNextCSSValue<CSSNumber, CSSPercentage>(parser, CSSDelimiter::Comma);
+    auto y = parser.parseNextValue<CSSNumber, CSSPercentage>(CSSDelimiter::Comma);
 
     auto normX =
         std::holds_alternative<CSSNumber>(x) ? std::get<CSSNumber>(x).value : std::get<CSSPercentage>(x).value / 100.0f;
@@ -411,14 +411,14 @@ struct CSSPerspective {
 
 template <>
 struct CSSDataTypeParser<CSSPerspective> {
-  static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
+  static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
       -> std::optional<CSSPerspective>
   {
     if (!iequals(func.name, "perspective")) {
       return {};
     }
 
-    auto value = parseNextCSSValue<CSSLength>(parser);
+    auto value = parser.parseNextValue<CSSLength>();
     if (std::holds_alternative<std::monostate>(value) || std::get<CSSLength>(value).value < 0) {
       return {};
     }

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

@@ -45,7 +45,7 @@ struct CSSTransformOrigin {
 
 template <>
 struct CSSDataTypeParser<CSSTransformOrigin> {
-  static constexpr auto consume(CSSSyntaxParser &parser) -> std::optional<CSSTransformOrigin>
+  static constexpr auto consume(CSSValueParser &parser) -> std::optional<CSSTransformOrigin>
   {
     //  [ left | center | right | top | bottom | <length-percentage> ]
     // |
@@ -54,19 +54,18 @@ struct CSSDataTypeParser<CSSTransformOrigin> {
     // |
     //   [ [ center | left | right ] && [ center | top | bottom ] ] <length>?
 
-    auto firstValue = parseNextCSSValue<CSSLengthPercentage, CSSTransformOriginKeyword>(parser);
+    auto firstValue = parser.parseNextValue<CSSLengthPercentage, CSSTransformOriginKeyword>();
     if (std::holds_alternative<std::monostate>(firstValue)) {
       return {};
     }
 
-    auto secondValue =
-        parseNextCSSValue<CSSLengthPercentage, CSSTransformOriginKeyword>(parser, CSSDelimiter::Whitespace);
+    auto secondValue = parser.parseNextValue<CSSLengthPercentage, CSSTransformOriginKeyword>(CSSDelimiter::Whitespace);
 
     if (std::holds_alternative<std::monostate>(secondValue)) {
       return singleValue(firstValue);
     }
 
-    auto thirdValue = parseNextCSSValue<CSSLength>(parser, CSSDelimiter::Whitespace);
+    auto thirdValue = parser.parseNextValue<CSSLength>(CSSDelimiter::Whitespace);
 
     if (std::holds_alternative<CSSLength>(firstValue) || std::holds_alternative<CSSPercentage>(firstValue) ||
         std::holds_alternative<CSSLength>(secondValue) || std::holds_alternative<CSSPercentage>(secondValue)) {

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

@@ -18,12 +18,54 @@
 
 namespace facebook::react {
 
-namespace detail {
-
 class CSSValueParser {
  public:
-  explicit constexpr CSSValueParser(CSSSyntaxParser &parser) : parser_{parser} {}
+  explicit constexpr CSSValueParser(CSSSyntaxParser &parser) : parser_{&parser} {}
+
+  constexpr CSSValueParser(const CSSValueParser &) = default;
+  constexpr CSSValueParser &operator=(const CSSValueParser &) = default;
+
+  /**
+   * Attempts to parse the next CSS value of a given set of data types, at the
+   * current location of the parser, advancing the parser.
+   */
+  template <CSSMaybeCompoundDataType... AllowedTypesT>
+  constexpr auto parseNextValue(CSSDelimiter delimiter = CSSDelimiter::None)
+      -> CSSVariantWithTypes<CSSMergedDataTypes<AllowedTypesT...>, std::monostate>
+  {
+    return consumeValue(delimiter, CSSMergedDataTypes<AllowedTypesT...>{});
+  }
+
+  /**
+   * Attempts to parse the next CSS value of a given set of data types, at the
+   * current location of the parser, without advancing the parser.
+   */
+  template <CSSMaybeCompoundDataType... AllowedTypesT>
+  constexpr auto peekNextValue(CSSDelimiter delimiter = CSSDelimiter::None)
+      -> CSSVariantWithTypes<CSSMergedDataTypes<AllowedTypesT...>, std::monostate>
+  {
+    auto savedParser = *parser_;
+    auto ret = consumeValue(delimiter, CSSMergedDataTypes<AllowedTypesT...>{});
+    *parser_ = savedParser;
+    return ret;
+  }
+
+  /**
+   * Returns a reference to the underlying CSSSyntaxParser. Use this for
+   * syntax-level operations like consumeWhitespace(), consumeDelimiter(),
+   * and isFinished().
+   */
+  constexpr CSSSyntaxParser &syntaxParser()
+  {
+    return *parser_;
+  }
 
+  constexpr const CSSSyntaxParser &syntaxParser() const
+  {
+    return *parser_;
+  }
+
+ private:
   /*
    * Attempts to parse the characters starting at the current component value
    * into one of the given data types. Types are attempted in order, which the
@@ -32,41 +74,32 @@ class CSSValueParser {
    */
   template <CSSDataType... AllowedTypesT>
   constexpr std::variant<std::monostate, AllowedTypesT...> consumeValue(
-      CSSDelimiter delimeter,
-      CSSCompoundDataType<AllowedTypesT...> /*unused*/)
+      CSSDelimiter delimiter,
+      std::variant<AllowedTypesT...> /*unused*/)
   {
     using ReturnT = std::variant<std::monostate, AllowedTypesT...>;
 
-    auto consumedValue = tryConsumeParser<ReturnT, CSSDataTypeParser<AllowedTypesT>...>(delimeter);
+    auto consumedValue = tryConsumeParser<ReturnT, CSSDataTypeParser<AllowedTypesT>...>(delimiter);
 
     if (!std::holds_alternative<std::monostate>(consumedValue)) {
       return consumedValue;
     }
 
-    return parser_.consumeComponentValue<ReturnT>(
-        delimeter,
+    return parser_->consumeComponentValue<ReturnT>(
+        delimiter,
         [&](const CSSPreservedToken &token) {
           return tryConsumePreservedToken<ReturnT, CSSDataTypeParser<AllowedTypesT>...>(token);
         },
         [&](const CSSSimpleBlock &block, CSSSyntaxParser &blockParser) {
-          return tryConsumeSimpleBlock<ReturnT, CSSDataTypeParser<AllowedTypesT>...>(block, blockParser);
+          CSSValueParser valueParser(blockParser);
+          return tryConsumeSimpleBlock<ReturnT, CSSDataTypeParser<AllowedTypesT>...>(block, valueParser);
         },
         [&](const CSSFunctionBlock &func, CSSSyntaxParser &blockParser) {
-          return tryConsumeFunctionBlock<ReturnT, CSSDataTypeParser<AllowedTypesT>...>(func, blockParser);
+          CSSValueParser valueParser(blockParser);
+          return tryConsumeFunctionBlock<ReturnT, CSSDataTypeParser<AllowedTypesT>...>(func, valueParser);
         });
   }
 
-  constexpr bool isFinished() const
-  {
-    return parser_.isFinished();
-  }
-
-  constexpr void consumeWhitespace()
-  {
-    parser_.consumeWhitespace();
-  }
-
- private:
   template <typename ReturnT>
   constexpr ReturnT tryConsumePreservedToken(const CSSPreservedToken & /*token*/)
   {
@@ -86,13 +119,13 @@ class CSSValueParser {
   }
 
   template <typename ReturnT>
-  constexpr ReturnT tryConsumeSimpleBlock(const CSSSimpleBlock & /*token*/, CSSSyntaxParser & /*blockParser*/)
+  constexpr ReturnT tryConsumeSimpleBlock(const CSSSimpleBlock & /*token*/, CSSValueParser & /*blockParser*/)
   {
     return {};
   }
 
   template <typename ReturnT, CSSValidDataTypeParser ParserT, CSSValidDataTypeParser... RestParserT>
-  constexpr ReturnT tryConsumeSimpleBlock(const CSSSimpleBlock &block, CSSSyntaxParser &blockParser)
+  constexpr ReturnT tryConsumeSimpleBlock(const CSSSimpleBlock &block, CSSValueParser &blockParser)
   {
     if constexpr (CSSSimpleBlockSink<ParserT>) {
       auto currentParser = blockParser;
@@ -106,13 +139,13 @@ class CSSValueParser {
   }
 
   template <typename ReturnT>
-  constexpr ReturnT tryConsumeFunctionBlock(const CSSFunctionBlock & /*func*/, CSSSyntaxParser & /*blockParser*/)
+  constexpr ReturnT tryConsumeFunctionBlock(const CSSFunctionBlock & /*func*/, CSSValueParser & /*blockParser*/)
   {
     return {};
   }
 
   template <typename ReturnT, CSSValidDataTypeParser ParserT, CSSValidDataTypeParser... RestParserT>
-  constexpr ReturnT tryConsumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &blockParser)
+  constexpr ReturnT tryConsumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &blockParser)
   {
     if constexpr (CSSFunctionBlockSink<ParserT>) {
       auto currentParser = blockParser;
@@ -126,32 +159,30 @@ class CSSValueParser {
   }
 
   template <typename ReturnT>
-  constexpr ReturnT tryConsumeParser(CSSDelimiter /*delimeter*/)
+  constexpr ReturnT tryConsumeParser(CSSDelimiter /*delimiter*/)
   {
     return {};
   }
 
   template <typename ReturnT, CSSValidDataTypeParser ParserT, CSSValidDataTypeParser... RestParserT>
-  constexpr ReturnT tryConsumeParser(CSSDelimiter delimeter)
+  constexpr ReturnT tryConsumeParser(CSSDelimiter delimiter)
   {
     if constexpr (CSSParserSink<ParserT>) {
-      auto originalParser = parser_;
-      if (parser_.consumeDelimiter(delimeter)) {
-        if (auto ret = ParserT::consume(parser_)) {
+      auto originalParser = *parser_;
+      if (parser_->consumeDelimiter(delimiter)) {
+        if (auto ret = ParserT::consume(*this)) {
           return *ret;
         }
       }
-      parser_ = originalParser;
+      *parser_ = originalParser;
     }
 
-    return tryConsumeParser<ReturnT, RestParserT...>(delimeter);
+    return tryConsumeParser<ReturnT, RestParserT...>(delimiter);
   }
 
-  CSSSyntaxParser &parser_;
+  CSSSyntaxParser *parser_;
 };
 
-} // namespace detail
-
 /**
  * Parse a single CSS property value. Returns a variant holding std::monostate
  * on syntax error.
@@ -161,44 +192,17 @@ constexpr auto parseCSSProperty(std::string_view css)
     -> CSSVariantWithTypes<CSSMergedDataTypes<CSSWideKeyword, AllowedTypesT...>, std::monostate>
 {
   CSSSyntaxParser syntaxParser(css);
-  detail::CSSValueParser parser(syntaxParser);
+  CSSValueParser parser(syntaxParser);
 
-  parser.consumeWhitespace();
-  auto value = parser.consumeValue(CSSDelimiter::None, CSSMergedDataTypes<CSSWideKeyword, AllowedTypesT...>{});
-  parser.consumeWhitespace();
+  syntaxParser.consumeWhitespace();
+  auto value = parser.parseNextValue<CSSWideKeyword, AllowedTypesT...>();
+  syntaxParser.consumeWhitespace();
 
-  if (parser.isFinished()) {
+  if (syntaxParser.isFinished()) {
     return value;
   }
 
   return {};
 };
 
-/**
- * Attempts to parse the next CSS value of a given set of data types, at the
- * current location of the syntax parser, advancing the syntax parser
- */
-template <CSSMaybeCompoundDataType... AllowedTypesT>
-constexpr auto parseNextCSSValue(CSSSyntaxParser &syntaxParser, CSSDelimiter delimeter = CSSDelimiter::None)
-    -> CSSVariantWithTypes<CSSMergedDataTypes<AllowedTypesT...>, std::monostate>
-{
-  detail::CSSValueParser valueParser(syntaxParser);
-  return valueParser.consumeValue(delimeter, CSSMergedDataTypes<AllowedTypesT...>{});
-}
-
-/**
- * Attempts to parse the next CSS value of a given set of data types, at the
- * current location of the syntax parser, without advancing the syntax parser
- */
-template <CSSMaybeCompoundDataType... AllowedTypesT>
-constexpr auto peekNextCSSValue(CSSSyntaxParser &syntaxParser, CSSDelimiter delimeter = CSSDelimiter::None)
-    -> CSSVariantWithTypes<CSSMergedDataTypes<AllowedTypesT...>, std::monostate>
-{
-  auto savedParser = syntaxParser;
-  detail::CSSValueParser valueParser(syntaxParser);
-  auto ret = valueParser.consumeValue(delimeter, CSSMergedDataTypes<AllowedTypesT...>{});
-  syntaxParser = savedParser;
-  return ret;
-}
-
 } // namespace facebook::react

package/ReactCommon/react/renderer/css/tests/CSSValueParserTest.cpp

@@ -21,8 +21,8 @@ struct ConsumeDataType {
 template <>
 struct CSSDataTypeParser<ConsumeDataType> {
   constexpr static std::optional<ConsumeDataType> consume(
-      CSSSyntaxParser& parser) {
-    auto val = parseNextCSSValue<CSSNumber>(parser);
+      CSSValueParser& parser) {
+    auto val = parser.parseNextValue<CSSNumber>();
     if (std::holds_alternative<CSSNumber>(val)) {
       return ConsumeDataType{std::get<CSSNumber>(val).value};
     }
@@ -34,32 +34,33 @@ struct CSSDataTypeParser<ConsumeDataType> {
 static_assert(CSSDataType<ConsumeDataType>);
 
 TEST(CSSValueParser, consume_multiple_with_delimeter) {
-  CSSSyntaxParser parser{"1 2, 3, 4 / 5"};
+  CSSSyntaxParser syntaxParser{"1 2, 3, 4 / 5"};
+  CSSValueParser parser{syntaxParser};
 
-  auto next = parseNextCSSValue<ConsumeDataType>(parser);
+  auto next = parser.parseNextValue<ConsumeDataType>();
   EXPECT_TRUE(std::holds_alternative<ConsumeDataType>(next));
   EXPECT_EQ(std::get<ConsumeDataType>(next).number, 1);
 
-  next = parseNextCSSValue<ConsumeDataType>(parser, CSSDelimiter::None);
+  next = parser.parseNextValue<ConsumeDataType>(CSSDelimiter::None);
   EXPECT_FALSE(std::holds_alternative<ConsumeDataType>(next));
 
-  next = parseNextCSSValue<ConsumeDataType>(parser, CSSDelimiter::Whitespace);
+  next = parser.parseNextValue<ConsumeDataType>(CSSDelimiter::Whitespace);
   EXPECT_TRUE(std::holds_alternative<ConsumeDataType>(next));
   EXPECT_EQ(std::get<ConsumeDataType>(next).number, 2);
 
-  next = parseNextCSSValue<ConsumeDataType>(parser, CSSDelimiter::Comma);
+  next = parser.parseNextValue<ConsumeDataType>(CSSDelimiter::Comma);
   EXPECT_TRUE(std::holds_alternative<ConsumeDataType>(next));
   EXPECT_EQ(std::get<ConsumeDataType>(next).number, 3);
 
-  next = parseNextCSSValue<ConsumeDataType>(parser, CSSDelimiter::Comma);
+  next = parser.parseNextValue<ConsumeDataType>(CSSDelimiter::Comma);
   EXPECT_TRUE(std::holds_alternative<ConsumeDataType>(next));
   EXPECT_EQ(std::get<ConsumeDataType>(next).number, 4);
 
-  next = parseNextCSSValue<ConsumeDataType>(parser, CSSDelimiter::Solidus);
+  next = parser.parseNextValue<ConsumeDataType>(CSSDelimiter::Solidus);
   EXPECT_TRUE(std::holds_alternative<ConsumeDataType>(next));
   EXPECT_EQ(std::get<ConsumeDataType>(next).number, 5);
 
-  next = parseNextCSSValue<ConsumeDataType>(parser);
+  next = parser.parseNextValue<ConsumeDataType>();
   EXPECT_FALSE(std::holds_alternative<ConsumeDataType>(next));
 }
 

package/ReactCommon/react/renderer/graphics/BackgroundPosition.h

@@ -21,7 +21,6 @@ struct BackgroundPosition {
   BackgroundPosition() : top(ValueUnit{0.0f, UnitType::Point}), left(ValueUnit{0.0f, UnitType::Point}) {}
 
   bool operator==(const BackgroundPosition &other) const = default;
-  bool operator!=(const BackgroundPosition &other) const = default;
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/graphics/BackgroundRepeat.h

@@ -23,7 +23,6 @@ struct BackgroundRepeat {
   BackgroundRepeat() {}
 
   bool operator==(const BackgroundRepeat &other) const = default;
-  bool operator!=(const BackgroundRepeat &other) const = default;
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/graphics/BackgroundSize.h

@@ -28,7 +28,6 @@ struct BackgroundSizeLengthPercentage {
   }
 
   bool operator==(const BackgroundSizeLengthPercentage &other) const = default;
-  bool operator!=(const BackgroundSizeLengthPercentage &other) const = default;
 };
 
 enum class BackgroundSizeKeyword { Cover, Contain };

package/ReactCommon/react/renderer/graphics/Filter.h

@@ -10,6 +10,7 @@
 #include <react/renderer/graphics/Color.h>
 #include <react/renderer/graphics/Float.h>
 
+#include <optional>
 #include <string>
 #include <string_view>
 #include <variant>
@@ -29,7 +30,7 @@ enum class FilterType {
   DropShadow
 };
 
-inline FilterType filterTypeFromString(std::string_view filterName)
+inline std::optional<FilterType> filterTypeFromString(std::string_view filterName)
 {
   if (filterName == "blur") {
     return FilterType::Blur;
@@ -52,7 +53,7 @@ inline FilterType filterTypeFromString(std::string_view filterName)
   } else if (filterName == "dropShadow") {
     return FilterType::DropShadow;
   } else {
-    throw std::invalid_argument(std::string(filterName));
+    return std::nullopt;
   }
 }
 

package/ReactCommon/react/renderer/graphics/LinearGradient.cpp

@@ -10,21 +10,14 @@
 namespace facebook::react {
 
 #ifdef RN_SERIALIZABLE_STATE
-folly::dynamic GradientDirection::toDynamic() const {
+namespace {
+folly::dynamic directionToDynamic(const GradientDirection& value) {
   folly::dynamic result = folly::dynamic::object();
-  result["type"] = [&]() {
-    switch (type) {
-      case GradientDirectionType::Angle:
-        return "angle";
-      case GradientDirectionType::Keyword:
-        return "keyword";
-    }
-    return "";
-  }();
-
   if (std::holds_alternative<Float>(value)) {
+    result["type"] = "angle";
     result["value"] = std::get<Float>(value);
   } else if (std::holds_alternative<GradientKeyword>(value)) {
+    result["type"] = "keyword";
     result["value"] = [&]() {
       switch (std::get<GradientKeyword>(value)) {
         case GradientKeyword::ToTopRight:
@@ -41,11 +34,12 @@ folly::dynamic GradientDirection::toDynamic() const {
   }
   return result;
 }
+} // namespace
 
 folly::dynamic LinearGradient::toDynamic() const {
   folly::dynamic result = folly::dynamic::object();
   result["type"] = "linear-gradient";
-  result["direction"] = direction.toDynamic();
+  result["direction"] = directionToDynamic(direction);
 
   folly::dynamic colorStopsArray = folly::dynamic::array();
   for (const auto& colorStop : colorStops) {
@@ -60,10 +54,10 @@ folly::dynamic LinearGradient::toDynamic() const {
 void LinearGradient::toString(std::stringstream& ss) const {
   ss << "linear-gradient(";
 
-  if (direction.type == GradientDirectionType::Angle) {
-    ss << std::get<Float>(direction.value) << "deg";
+  if (std::holds_alternative<Float>(direction)) {
+    ss << std::get<Float>(direction) << "deg";
   } else {
-    auto keyword = std::get<GradientKeyword>(direction.value);
+    auto keyword = std::get<GradientKeyword>(direction);
     switch (keyword) {
       case GradientKeyword::ToTopRight:
         ss << "to top right";