Replace CSSSyntaxParser with CSSValueParser in data type sinks

Summary:
Previously, CSSDataTypeParser sinks received a raw CSSSyntaxParser& reference,
which exposed low-level tokenization APIs (consumeComponentValue with lambdas,
consumeToken, etc.) that data type parsers should not use directly. This made
it unclear what operations are appropriate when implementing a new CSS data
type.

This change promotes detail::CSSValueParser to a public CSSValueParser class
that wraps CSSSyntaxParser and exposes only value-level parsing operations:
parseNextValue, peekNextValue, consumeWhitespace, consumeDelimiter, isFinished,
peekNextTokenIs, and saveState/restoreState for lookahead patterns.

All CSSDataTypeParser sink methods now receive CSSValueParser& instead of
CSSSyntaxParser&, and use parser.parseNextValue<T>() instead of the free
function parseNextCSSValue<T>(parser). Direct consumeComponentValue calls in
gradient parsers (CSSBackgroundImage.h) are replaced with keyword set parsing
via parseNextValue<KeywordEnum>, with new To/At keywords added to CSSKeyword.

The free functions parseCSSProperty, parseNextCSSValue, and peekNextCSSValue
remain as convenience wrappers for backward compatibility.

Changelog: [Internal]

Reviewed By: jorge-cab

Differential Revision: D94357104

fbshipit-source-id: 3ba2ba236c9c6e82673e2759a6c7af803599b7f0
This commit is contained in:
Nick Gerleman authored and meta-codesync[bot] committed 2026-02-25 12:39:16 -08:00
1 parent 36212c248b
commit 4d66a26a67
15 files changed
+310 -308

No files matched your search

@@ -25,6 +25,37 @@
namespace facebook::react {
enum class CSSGradientToKeyword : std::underlying_type_t<CSSKeyword> {
To = to_underlying(CSSKeyword::To),
};
static_assert(CSSDataType<CSSGradientToKeyword>);
enum class CSSGradientDirectionKeyword : std::underlying_type_t<CSSKeyword> {
Top = to_underlying(CSSKeyword::Top),
Bottom = to_underlying(CSSKeyword::Bottom),
Left = to_underlying(CSSKeyword::Left),
Right = to_underlying(CSSKeyword::Right),
};
static_assert(CSSDataType<CSSGradientDirectionKeyword>);
enum class CSSGradientAtKeyword : std::underlying_type_t<CSSKeyword> {
At = to_underlying(CSSKeyword::At),
};
static_assert(CSSDataType<CSSGradientAtKeyword>);
enum class CSSGradientPositionKeyword : std::underlying_type_t<CSSKeyword> {
Top = to_underlying(CSSKeyword::Top),
Bottom = to_underlying(CSSKeyword::Bottom),
Left = to_underlying(CSSKeyword::Left),
Right = to_underlying(CSSKeyword::Right),
Center = to_underlying(CSSKeyword::Center),
};
static_assert(CSSDataType<CSSGradientPositionKeyword>);
enum class CSSLinearGradientDirectionKeyword : uint8_t {
ToTopLeft,
ToTopRight,
@@ -41,115 +72,81 @@ struct CSSLinearGradientDirection {
template <>
struct CSSDataTypeParser<CSSLinearGradientDirection> {
static constexpr auto consume(CSSSyntaxParser &parser) -> std::optional<CSSLinearGradientDirection>
static constexpr auto consume(CSSValueParser &parser) -> std::optional<CSSLinearGradientDirection>
{
return parseLinearGradientDirection(parser);
}
private:
static constexpr std::optional<CSSLinearGradientDirection> parseLinearGradientDirection(CSSSyntaxParser &parser)
static constexpr std::optional<CSSLinearGradientDirection> parseLinearGradientDirection(CSSValueParser &parser)
{
auto angle = parseNextCSSValue<CSSAngle>(parser);
auto angle = parser.parseNextValue<CSSAngle>();
if (std::holds_alternative<CSSAngle>(angle)) {
return CSSLinearGradientDirection{std::get<CSSAngle>(angle)};
}
auto toResult = parser.consumeComponentValue<bool>([](const CSSPreservedToken &token) -> bool {
return token.type() == CSSTokenType::Ident && fnv1aLowercase(token.stringValue()) == fnv1a("to");
});
if (!toResult) {
auto toResult = parser.parseNextValue<CSSGradientToKeyword>();
if (!std::holds_alternative<CSSGradientToKeyword>(toResult)) {
// no direction found, default to 180 degrees (to bottom)
return CSSLinearGradientDirection{CSSAngle{180.0f}};
}
parser.consumeWhitespace();
parser.syntaxParser().consumeWhitespace();
std::optional<CSSKeyword> primaryDir;
auto primaryResult = parser.consumeComponentValue<std::optional<CSSKeyword>>(
[](const CSSPreservedToken &token) -> std::optional<CSSKeyword> {
if (token.type() == CSSTokenType::Ident) {
switch (fnv1aLowercase(token.stringValue())) {
case fnv1a("top"):
return CSSKeyword::Top;
case fnv1a("bottom"):
return CSSKeyword::Bottom;
case fnv1a("left"):
return CSSKeyword::Left;
case fnv1a("right"):
return CSSKeyword::Right;
}
}
return {};
});
if (!primaryResult) {
auto primaryResult = parser.parseNextValue<CSSGradientDirectionKeyword>();
if (std::holds_alternative<std::monostate>(primaryResult)) {
return {};
}
auto primaryDir = std::get<CSSGradientDirectionKeyword>(primaryResult);
primaryDir = primaryResult;
parser.consumeWhitespace();
parser.syntaxParser().consumeWhitespace();
std::optional<CSSKeyword> secondaryDir;
auto secondaryResult = parser.consumeComponentValue<std::optional<CSSKeyword>>(
[&](const CSSPreservedToken &token) -> std::optional<CSSKeyword> {
if (token.type() == CSSTokenType::Ident) {
auto hash = fnv1aLowercase(token.stringValue());
// validate compatible combinations
if (primaryDir == CSSKeyword::Top || primaryDir == CSSKeyword::Bottom) {
if (hash == fnv1a("left")) {
return CSSKeyword::Left;
}
if (hash == fnv1a("right")) {
return CSSKeyword::Right;
}
}
if (primaryDir == CSSKeyword::Left || primaryDir == CSSKeyword::Right) {
if (hash == fnv1a("top")) {
return CSSKeyword::Top;
}
if (hash == fnv1a("bottom")) {
return CSSKeyword::Bottom;
}
}
}
return {};
});
if (secondaryResult) {
secondaryDir = secondaryResult;
auto secondaryPeek = parser.peekNextValue<CSSGradientDirectionKeyword>();
std::optional<CSSGradientDirectionKeyword> secondaryDir;
if (std::holds_alternative<CSSGradientDirectionKeyword>(secondaryPeek)) {
auto kw = std::get<CSSGradientDirectionKeyword>(secondaryPeek);
bool isCompatible = false;
if (primaryDir == CSSGradientDirectionKeyword::Top || primaryDir == CSSGradientDirectionKeyword::Bottom) {
isCompatible = (kw == CSSGradientDirectionKeyword::Left || kw == CSSGradientDirectionKeyword::Right);
} else if (primaryDir == CSSGradientDirectionKeyword::Left || primaryDir == CSSGradientDirectionKeyword::Right) {
isCompatible = (kw == CSSGradientDirectionKeyword::Top || kw == CSSGradientDirectionKeyword::Bottom);
}
if (isCompatible) {
parser.parseNextValue<CSSGradientDirectionKeyword>();
secondaryDir = kw;
}
}
if (primaryDir == CSSKeyword::Top) {
if (secondaryDir == CSSKeyword::Left) {
if (primaryDir == CSSGradientDirectionKeyword::Top) {
if (secondaryDir == CSSGradientDirectionKeyword::Left) {
return CSSLinearGradientDirection{CSSLinearGradientDirectionKeyword::ToTopLeft};
} else if (secondaryDir == CSSKeyword::Right) {
} else if (secondaryDir == CSSGradientDirectionKeyword::Right) {
return CSSLinearGradientDirection{CSSLinearGradientDirectionKeyword::ToTopRight};
} else {
// "to top" = 0 degrees
return CSSLinearGradientDirection{CSSAngle{0.0f}};
}
} else if (primaryDir == CSSKeyword::Bottom) {
if (secondaryDir == CSSKeyword::Left) {
} else if (primaryDir == CSSGradientDirectionKeyword::Bottom) {
if (secondaryDir == CSSGradientDirectionKeyword::Left) {
return CSSLinearGradientDirection{CSSLinearGradientDirectionKeyword::ToBottomLeft};
} else if (secondaryDir == CSSKeyword::Right) {
} else if (secondaryDir == CSSGradientDirectionKeyword::Right) {
return CSSLinearGradientDirection{CSSLinearGradientDirectionKeyword::ToBottomRight};
} else {
// "to bottom" = 180 degrees
return CSSLinearGradientDirection{CSSAngle{180.0f}};
}
} else if (primaryDir == CSSKeyword::Left) {
if (secondaryDir == CSSKeyword::Top) {
} else if (primaryDir == CSSGradientDirectionKeyword::Left) {
if (secondaryDir == CSSGradientDirectionKeyword::Top) {
return CSSLinearGradientDirection{CSSLinearGradientDirectionKeyword::ToTopLeft};
} else if (secondaryDir == CSSKeyword::Bottom) {
} else if (secondaryDir == CSSGradientDirectionKeyword::Bottom) {
return CSSLinearGradientDirection{CSSLinearGradientDirectionKeyword::ToBottomLeft};
} else {
// "to left" = 270 degrees
return CSSLinearGradientDirection{CSSAngle{270.0f}};
}
} else if (primaryDir == CSSKeyword::Right) {
if (secondaryDir == CSSKeyword::Top) {
} else if (primaryDir == CSSGradientDirectionKeyword::Right) {
if (secondaryDir == CSSGradientDirectionKeyword::Top) {
return CSSLinearGradientDirection{CSSLinearGradientDirectionKeyword::ToTopRight};
} else if (secondaryDir == CSSKeyword::Bottom) {
} else if (secondaryDir == CSSGradientDirectionKeyword::Bottom) {
return CSSLinearGradientDirection{CSSLinearGradientDirectionKeyword::ToBottomRight};
} else {
// "to right" = 90 degrees
@@ -174,15 +171,15 @@ struct CSSColorHint {
template <>
struct CSSDataTypeParser<CSSColorHint> {
static auto consume(CSSSyntaxParser &parser) -> std::optional<CSSColorHint>
static auto consume(CSSValueParser &parser) -> std::optional<CSSColorHint>
{
return parseCSSColorHint(parser);
}
private:
static std::optional<CSSColorHint> parseCSSColorHint(CSSSyntaxParser &parser)
static std::optional<CSSColorHint> parseCSSColorHint(CSSValueParser &parser)
{
auto position = parseNextCSSValue<CSSLengthPercentage>(parser);
auto position = parser.parseNextValue<CSSLengthPercentage>();
if (std::holds_alternative<CSSLength>(position)) {
return CSSColorHint{std::get<CSSLength>(position)};
} else if (std::holds_alternative<CSSPercentage>(position)) {
@@ -235,15 +232,15 @@ struct CSSColorStop {
template <>
struct CSSDataTypeParser<CSSColorStop> {
static constexpr auto consume(CSSSyntaxParser &parser) -> std::optional<CSSColorStop>
static constexpr auto consume(CSSValueParser &parser) -> std::optional<CSSColorStop>
{
return parseCSSColorStop(parser);
}
private:
static constexpr std::optional<CSSColorStop> parseCSSColorStop(CSSSyntaxParser &parser)
static constexpr std::optional<CSSColorStop> parseCSSColorStop(CSSValueParser &parser)
{
auto color = parseNextCSSValue<CSSColor>(parser);
auto color = parser.parseNextValue<CSSColor>();
if (!std::holds_alternative<CSSColor>(color)) {
return {};
}
@@ -251,7 +248,7 @@ struct CSSDataTypeParser<CSSColorStop> {
CSSColorStop colorStop;
colorStop.color = std::get<CSSColor>(color);
auto startPosition = parseNextCSSValue<CSSLengthPercentage>(parser, CSSDelimiter::Whitespace);
auto startPosition = parser.parseNextValue<CSSLengthPercentage>(CSSDelimiter::Whitespace);
if (std::holds_alternative<CSSLength>(startPosition)) {
colorStop.startPosition = std::get<CSSLength>(startPosition);
} else if (std::holds_alternative<CSSPercentage>(startPosition)) {
@@ -261,7 +258,7 @@ struct CSSDataTypeParser<CSSColorStop> {
if (colorStop.startPosition) {
// Try to parse second optional position (supports both lengths and
// percentages)
auto endPosition = parseNextCSSValue<CSSLengthPercentage>(parser, CSSDelimiter::Whitespace);
auto endPosition = parser.parseNextValue<CSSLengthPercentage>(CSSDelimiter::Whitespace);
if (std::holds_alternative<CSSLength>(endPosition)) {
colorStop.endPosition = std::get<CSSLength>(endPosition);
} else if (std::holds_alternative<CSSPercentage>(endPosition)) {
@@ -281,27 +278,27 @@ struct CSSLinearGradientFunction {
bool operator==(const CSSLinearGradientFunction &rhs) const = default;
static std::pair<std::vector<std::variant<CSSColorStop, CSSColorHint>>, int> parseGradientColorStopsAndHints(
CSSSyntaxParser &parser)
CSSValueParser &parser)
{
std::vector<std::variant<CSSColorStop, CSSColorHint>> items;
int colorStopCount = 0;
std::optional<CSSColorStop> prevColorStop = std::nullopt;
do {
auto colorStop = parseNextCSSValue<CSSColorStop>(parser);
auto colorStop = parser.parseNextValue<CSSColorStop>();
if (std::holds_alternative<CSSColorStop>(colorStop)) {
auto parsedColorStop = std::get<CSSColorStop>(colorStop);
items.emplace_back(parsedColorStop);
prevColorStop = parsedColorStop;
colorStopCount++;
} else {
auto colorHint = parseNextCSSValue<CSSColorHint>(parser);
auto colorHint = parser.parseNextValue<CSSColorHint>();
if (std::holds_alternative<CSSColorHint>(colorHint)) {
// color hint must be between two color stops
if (!prevColorStop) {
return {};
}
auto nextColorStop = peekNextCSSValue<CSSColorStop>(parser, CSSDelimiter::Comma);
auto nextColorStop = parser.peekNextValue<CSSColorStop>(CSSDelimiter::Comma);
if (!std::holds_alternative<CSSColorStop>(nextColorStop)) {
return {};
}
@@ -310,7 +307,7 @@ struct CSSLinearGradientFunction {
break; // No more valid items
}
}
} while (parser.consumeDelimiter(CSSDelimiter::Comma));
} while (parser.syntaxParser().consumeDelimiter(CSSDelimiter::Comma));
return {items, colorStopCount};
}
@@ -378,16 +375,16 @@ struct CSSRadialGradientExplicitSize {
template <>
struct CSSDataTypeParser<CSSRadialGradientExplicitSize> {
static auto consume(CSSSyntaxParser &syntaxParser) -> std::optional<CSSRadialGradientExplicitSize>
static auto consume(CSSValueParser &syntaxParser) -> std::optional<CSSRadialGradientExplicitSize>
{
auto sizeX = parseNextCSSValue<CSSLengthPercentage>(syntaxParser);
auto sizeX = syntaxParser.parseNextValue<CSSLengthPercentage>();
if (std::holds_alternative<std::monostate>(sizeX)) {
return {};
}
syntaxParser.consumeWhitespace();
syntaxParser.syntaxParser().consumeWhitespace();
auto sizeY = parseNextCSSValue<CSSLengthPercentage>(syntaxParser);
auto sizeY = syntaxParser.parseNextValue<CSSLengthPercentage>();
CSSRadialGradientExplicitSize result;
if (std::holds_alternative<CSSLength>(sizeX)) {
@@ -434,7 +431,7 @@ struct CSSRadialGradientFunction {
template <>
struct CSSDataTypeParser<CSSRadialGradientFunction> {
static auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
static auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
-> std::optional<CSSRadialGradientFunction>
{
if (!iequals(func.name, "radial-gradient")) {
@@ -445,20 +442,20 @@ struct CSSDataTypeParser<CSSRadialGradientFunction> {
auto hasExplicitShape = false;
auto hasExplicitSingleSize = false;
auto shapeResult = parseNextCSSValue<CSSRadialGradientShape>(parser);
auto shapeResult = parser.parseNextValue<CSSRadialGradientShape>();
if (std::holds_alternative<CSSRadialGradientShape>(shapeResult)) {
parser.consumeWhitespace();
parser.syntaxParser().consumeWhitespace();
}
std::optional<CSSRadialGradientSize> sizeResult;
auto sizeKeywordResult = parseNextCSSValue<CSSRadialGradientSizeKeyword>(parser);
auto sizeKeywordResult = parser.parseNextValue<CSSRadialGradientSizeKeyword>();
if (std::holds_alternative<CSSRadialGradientSizeKeyword>(sizeKeywordResult)) {
sizeResult = CSSRadialGradientSize{std::get<CSSRadialGradientSizeKeyword>(sizeKeywordResult)};
parser.consumeWhitespace();
parser.syntaxParser().consumeWhitespace();
} else {
auto explicitSizeResult = parseNextCSSValue<CSSRadialGradientExplicitSize>(parser);
auto explicitSizeResult = parser.parseNextValue<CSSRadialGradientExplicitSize>();
if (std::holds_alternative<CSSRadialGradientExplicitSize>(explicitSizeResult)) {
auto explicitSize = std::get<CSSRadialGradientExplicitSize>(explicitSizeResult);
// negative value validation
@@ -492,7 +489,7 @@ struct CSSDataTypeParser<CSSRadialGradientFunction> {
}
sizeResult = CSSRadialGradientSize{explicitSize};
parser.consumeWhitespace();
parser.syntaxParser().consumeWhitespace();
}
}
@@ -521,38 +518,24 @@ struct CSSDataTypeParser<CSSRadialGradientFunction> {
return {};
}
auto atResult = parser.consumeComponentValue<bool>([](const CSSPreservedToken &token) -> bool {
return token.type() == CSSTokenType::Ident && fnv1aLowercase(token.stringValue()) == fnv1a("at");
});
auto atResult = parser.parseNextValue<CSSGradientAtKeyword>();
bool hasAtKeyword = std::holds_alternative<CSSGradientAtKeyword>(atResult);
CSSRadialGradientPosition position;
if (atResult) {
parser.consumeWhitespace();
if (hasAtKeyword) {
parser.syntaxParser().consumeWhitespace();
std::vector<std::variant<CSSLength, CSSPercentage, CSSKeyword>> positionKeywordValues;
for (int i = 0; i < 2; i++) {
auto keywordFound = false;
auto valueFound = false;
auto positionKeyword = parser.consumeComponentValue<std::optional<CSSKeyword>>(
[](const CSSPreservedToken &token) -> std::optional<CSSKeyword> {
if (token.type() == CSSTokenType::Ident) {
auto keyword = std::string(token.stringValue());
auto hash = fnv1aLowercase(keyword);
if (hash == fnv1a("top")) {
return CSSKeyword::Top;
} else if (hash == fnv1a("bottom")) {
return CSSKeyword::Bottom;
} else if (hash == fnv1a("left")) {
return CSSKeyword::Left;
} else if (hash == fnv1a("right")) {
return CSSKeyword::Right;
} else if (hash == fnv1a("center")) {
return CSSKeyword::Center;
}
}
return {};
});
auto positionKeywordResult = parser.parseNextValue<CSSGradientPositionKeyword>();
std::optional<CSSKeyword> positionKeyword;
if (std::holds_alternative<CSSGradientPositionKeyword>(positionKeywordResult)) {
positionKeyword =
static_cast<CSSKeyword>(to_underlying(std::get<CSSGradientPositionKeyword>(positionKeywordResult)));
}
if (positionKeyword) {
// invalid position declaration of same keyword "at top 10% top 20%"
@@ -567,9 +550,9 @@ struct CSSDataTypeParser<CSSRadialGradientFunction> {
keywordFound = true;
}
parser.consumeWhitespace();
parser.syntaxParser().consumeWhitespace();
auto lengthPercentageValue = parseNextCSSValue<CSSLengthPercentage>(parser);
auto lengthPercentageValue = parser.parseNextValue<CSSLengthPercentage>();
std::optional<decltype(positionKeywordValues)::value_type> value;
if (std::holds_alternative<CSSLength>(lengthPercentageValue)) {
@@ -582,7 +565,7 @@ struct CSSDataTypeParser<CSSRadialGradientFunction> {
valueFound = true;
}
parser.consumeWhitespace();
parser.syntaxParser().consumeWhitespace();
if (!keywordFound && !valueFound) {
break;
@@ -791,7 +774,7 @@ struct CSSDataTypeParser<CSSRadialGradientFunction> {
gradient.position = position;
}
parser.consumeDelimiter(CSSDelimiter::Comma);
parser.syntaxParser().consumeDelimiter(CSSDelimiter::Comma);
auto [items, colorStopCount] = CSSLinearGradientFunction::parseGradientColorStopsAndHints(parser);
if (items.empty() || colorStopCount < 2) {
@@ -807,7 +790,7 @@ static_assert(CSSDataType<CSSRadialGradientFunction>);
template <>
struct CSSDataTypeParser<CSSLinearGradientFunction> {
static auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
static auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
-> std::optional<CSSLinearGradientFunction>
{
if (!iequals(func.name, "linear-gradient")) {
@@ -816,12 +799,12 @@ struct CSSDataTypeParser<CSSLinearGradientFunction> {
CSSLinearGradientFunction gradient;
auto parsedDirection = parseNextCSSValue<CSSLinearGradientDirection>(parser);
auto parsedDirection = parser.parseNextValue<CSSLinearGradientDirection>();
if (!std::holds_alternative<CSSLinearGradientDirection>(parsedDirection)) {
return {};
}
parser.consumeDelimiter(CSSDelimiter::Comma);
parser.syntaxParser().consumeDelimiter(CSSDelimiter::Comma);
gradient.direction = std::get<CSSLinearGradientDirection>(parsedDirection);
@@ -47,7 +47,7 @@ struct CSSDataTypeParser<CSSColor> {
return {};
}
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSSyntaxParser &parser)
static constexpr auto consumeFunctionBlock(const CSSFunctionBlock &func, CSSValueParser &parser)
-> std::optional<CSSColor>
{
return parseCSSColorFunction<CSSColor>(func.name, parser);
@@ -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
@@ -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>;
};
@@ -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};
}
};
@@ -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,6 +346,7 @@ 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)
@@ -28,11 +28,11 @@ struct CSSList<AllowedTypesT, Delim> : 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>>
static inline auto consume(CSSValueParser &parser) -> std::optional<CSSList<AllowedTypeT, Delim>>
{
CSSList<AllowedTypeT, Delim> result;
for (auto nextValue = parseNextCSSValue<AllowedTypeT>(parser); !std::holds_alternative<std::monostate>(nextValue);
nextValue = parseNextCSSValue<AllowedTypeT>(parser, Delim)) {
for (auto nextValue = parser.parseNextValue<AllowedTypeT>(); !std::holds_alternative<std::monostate>(nextValue);
nextValue = parser.parseNextValue<AllowedTypeT>(Delim)) {
// 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)
@@ -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};
}
@@ -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{});
}
@@ -113,6 +113,7 @@ enum class CSSDelimiter {
class CSSSyntaxParser {
template <CSSSyntaxVisitorReturn ReturnT, CSSComponentValueVisitor<ReturnT>... VisitorsT>
friend struct CSSComponentValueVisitorDispatcher;
friend class CSSValueParser;
public:
/**
@@ -231,17 +232,20 @@ class CSSSyntaxParser {
}
}
/**
* Returns the current token without consuming it.
*/
constexpr const CSSToken &peek() const
{
return currentToken_;
}
private:
constexpr CSSSyntaxParser(CSSSyntaxParser &parser, CSSTokenType terminator)
: tokenizer_{parser.tokenizer_}, currentToken_{parser.currentToken_}, terminator_{terminator}
{
}
constexpr const CSSToken &peek() const
{
return currentToken_;
}
constexpr CSSToken consumeToken()
{
auto prevToken = currentToken_;
@@ -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 {};
}
@@ -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)) {
@@ -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,
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
@@ -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));
}
@@ -32,6 +32,7 @@ std::vector<MarginValue> parseNormalizedRootMargin(
std::vector<MarginValue> values;
CSSSyntaxParser syntaxParser(marginStr);
CSSValueParser valueParser(syntaxParser);
// Parse exactly 4 space-separated values
while (!syntaxParser.isFinished() && values.size() < 4) {
@@ -40,7 +41,7 @@ std::vector<MarginValue> parseNormalizedRootMargin(
break;
}
auto parsed = parseNextCSSValue<CSSLength, CSSPercentage>(syntaxParser);
auto parsed = valueParser.parseNextValue<CSSLength, CSSPercentage>();
if (std::holds_alternative<CSSLength>(parsed)) {
auto length = std::get<CSSLength>(parsed);