react-native-tvos 0.78.0-0rc4 → 0.79.0-0

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

@@ -0,0 +1,341 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <array>
+#include <optional>
+#include <variant>
+
+#include <react/renderer/css/CSSColor.h>
+#include <react/renderer/css/CSSCompoundDataType.h>
+#include <react/renderer/css/CSSDataType.h>
+#include <react/renderer/css/CSSLength.h>
+#include <react/renderer/css/CSSList.h>
+#include <react/renderer/css/CSSNumber.h>
+#include <react/renderer/css/CSSPercentage.h>
+#include <react/renderer/css/CSSZero.h>
+#include <react/utils/TemplateStringLiteral.h>
+#include <react/utils/iequals.h>
+
+namespace facebook::react {
+
+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) -> std::optional<DataT> {
+    if (!iequals(func.name, Name)) {
+      return {};
+    }
+
+    auto amount = parseNextCSSValue<CSSNumber, CSSPercentage>(parser);
+    if (std::holds_alternative<CSSNumber>(amount)) {
+      if (std::get<CSSNumber>(amount).value < 0.0f) {
+        return {};
+      }
+      return DataT{std::get<CSSNumber>(amount).value};
+    } else if (std::holds_alternative<CSSPercentage>(amount)) {
+      if (std::get<CSSPercentage>(amount).value < 0.0f) {
+        return {};
+      }
+      return DataT{std::get<CSSPercentage>(amount).value / 100.0f};
+    } else {
+      return DataT{};
+    }
+  }
+};
+
+} // namespace detail
+
+/**
+ * Representation of blur() function
+ */
+struct CSSBlurFilter {
+  CSSLength amount{};
+
+  constexpr bool operator==(const CSSBlurFilter& rhs) const = default;
+};
+
+template <>
+struct CSSDataTypeParser<CSSBlurFilter> {
+  static constexpr auto consumeFunctionBlock(
+      const CSSFunctionBlock& func,
+      CSSSyntaxParser& parser) -> std::optional<CSSBlurFilter> {
+    if (!iequals(func.name, "blur")) {
+      return {};
+    }
+
+    auto len = parseNextCSSValue<CSSLength>(parser);
+    return CSSBlurFilter{
+        std::holds_alternative<CSSLength>(len) ? std::get<CSSLength>(len)
+                                               : CSSLength{}};
+  }
+};
+
+static_assert(CSSDataType<CSSBlurFilter>);
+
+/**
+ * Representation of brightness() function
+ */
+struct CSSBrightnessFilter {
+  float amount{1.0f};
+
+  constexpr bool operator==(const CSSBrightnessFilter& rhs) const = default;
+};
+
+template <>
+struct CSSDataTypeParser<CSSBrightnessFilter>
+    : public detail::
+          CSSFilterSimpleAmountParser<CSSBrightnessFilter, "brightness"> {};
+
+static_assert(CSSDataType<CSSBrightnessFilter>);
+
+/**
+ * Representation of contrast() function
+ */
+struct CSSContrastFilter {
+  float amount{1.0f};
+
+  constexpr bool operator==(const CSSContrastFilter& rhs) const = default;
+};
+
+template <>
+struct CSSDataTypeParser<CSSContrastFilter>
+    : public detail::
+          CSSFilterSimpleAmountParser<CSSContrastFilter, "contrast"> {};
+
+static_assert(CSSDataType<CSSContrastFilter>);
+
+/**
+ * Representation of drop-shadow() function
+ */
+struct CSSDropShadowFilter {
+  CSSLength offsetX{};
+  CSSLength offsetY{};
+  CSSLength standardDeviation{};
+  CSSColor color{};
+
+  constexpr bool operator==(const CSSDropShadowFilter& rhs) const = default;
+};
+
+template <>
+struct CSSDataTypeParser<CSSDropShadowFilter> {
+  static constexpr auto consumeFunctionBlock(
+      const CSSFunctionBlock& func,
+      CSSSyntaxParser& parser) -> std::optional<CSSDropShadowFilter> {
+    if (!iequals(func.name, "drop-shadow")) {
+      return {};
+    }
+
+    std::optional<CSSColor> color{};
+    std::optional<std::array<CSSLength, 3>> lengths{};
+
+    auto firstVal = parseNextCSSValue<CSSColor, CSSLength>(parser);
+    if (std::holds_alternative<std::monostate>(firstVal)) {
+      return {};
+    }
+
+    if (std::holds_alternative<CSSColor>(firstVal)) {
+      color = std::get<CSSColor>(firstVal);
+    } else {
+      lengths = parseLengths(std::get<CSSLength>(firstVal), parser);
+      if (!lengths.has_value()) {
+        return {};
+      }
+    }
+
+    auto secondVal = parseNextCSSValue<CSSColor, CSSLength>(
+        parser, CSSDelimiter::Whitespace);
+    if (std::holds_alternative<CSSColor>(secondVal)) {
+      if (color.has_value()) {
+        return {};
+      }
+      color = std::get<CSSColor>(secondVal);
+    } else if (std::holds_alternative<CSSLength>(secondVal)) {
+      if (lengths.has_value()) {
+        return {};
+      }
+      lengths = parseLengths(std::get<CSSLength>(secondVal), parser);
+    }
+
+    if (!lengths.has_value()) {
+      return {};
+    }
+
+    return CSSDropShadowFilter{
+        .offsetX = (*lengths)[0],
+        .offsetY = (*lengths)[1],
+        .standardDeviation = (*lengths)[2],
+        .color = color.value_or(CSSColor::black()),
+    };
+  }
+
+ private:
+  static constexpr std::optional<std::array<CSSLength, 3>> parseLengths(
+      CSSLength offsetX,
+      CSSSyntaxParser& parser) {
+    auto offsetY =
+        parseNextCSSValue<CSSLength>(parser, CSSDelimiter::Whitespace);
+    if (!std::holds_alternative<CSSLength>(offsetY)) {
+      return {};
+    }
+
+    auto standardDeviation =
+        parseNextCSSValue<CSSLength>(parser, CSSDelimiter::Whitespace);
+    if (std::holds_alternative<CSSLength>(standardDeviation) &&
+        std::get<CSSLength>(standardDeviation).value < 0.0f) {
+      return {};
+    }
+
+    return std::array<CSSLength, 3>{
+        offsetX,
+        std::get<CSSLength>(offsetY),
+        std::holds_alternative<CSSLength>(standardDeviation)
+            ? std::get<CSSLength>(standardDeviation)
+            : CSSLength{}};
+  }
+};
+
+static_assert(CSSDataType<CSSDropShadowFilter>);
+
+/**
+ * Representation of grayscale() function
+ */
+struct CSSGrayscaleFilter {
+  float amount{1.0f};
+
+  constexpr bool operator==(const CSSGrayscaleFilter& rhs) const = default;
+};
+
+template <>
+struct CSSDataTypeParser<CSSGrayscaleFilter>
+    : public detail::
+          CSSFilterSimpleAmountParser<CSSGrayscaleFilter, "grayscale"> {};
+
+static_assert(CSSDataType<CSSGrayscaleFilter>);
+
+/**
+ * Representation of hue-rotate() function
+ */
+struct CSSHueRotateFilter {
+  float degrees{};
+
+  constexpr bool operator==(const CSSHueRotateFilter& rhs) const = default;
+};
+
+template <>
+struct CSSDataTypeParser<CSSHueRotateFilter> {
+  static constexpr auto consumeFunctionBlock(
+      const CSSFunctionBlock& func,
+      CSSSyntaxParser& parser) -> std::optional<CSSHueRotateFilter> {
+    if (!iequals(func.name, "hue-rotate")) {
+      return {};
+    }
+
+    auto angle = parseNextCSSValue<CSSAngle, CSSZero>(parser);
+    return CSSHueRotateFilter{
+        std::holds_alternative<CSSAngle>(angle)
+            ? std::get<CSSAngle>(angle).degrees
+            : 0.0f};
+  }
+};
+
+static_assert(CSSDataType<CSSHueRotateFilter>);
+
+/**
+ * Representation of invert() function
+ */
+struct CSSInvertFilter {
+  float amount{1.0f};
+
+  constexpr bool operator==(const CSSInvertFilter& rhs) const = default;
+};
+
+template <>
+struct CSSDataTypeParser<CSSInvertFilter>
+    : public detail::CSSFilterSimpleAmountParser<CSSInvertFilter, "invert"> {};
+
+static_assert(CSSDataType<CSSInvertFilter>);
+
+/**
+ * Representation of opacity() function
+ */
+struct CSSOpacityFilter {
+  float amount{1.0f};
+
+  constexpr bool operator==(const CSSOpacityFilter& rhs) const = default;
+};
+
+template <>
+struct CSSDataTypeParser<CSSOpacityFilter>
+    : public detail::CSSFilterSimpleAmountParser<CSSOpacityFilter, "opacity"> {
+};
+
+static_assert(CSSDataType<CSSOpacityFilter>);
+
+/**
+ * Representation of saturate() function
+ */
+struct CSSSaturateFilter {
+  float amount{1.0f};
+
+  constexpr bool operator==(const CSSSaturateFilter& rhs) const = default;
+};
+
+template <>
+struct CSSDataTypeParser<CSSSaturateFilter>
+    : public detail::
+          CSSFilterSimpleAmountParser<CSSSaturateFilter, "saturate"> {};
+
+static_assert(CSSDataType<CSSSaturateFilter>);
+
+/**
+ * Representation of sepia() function
+ */
+struct CSSSepiaFilter {
+  float amount{1.0f};
+
+  constexpr bool operator==(const CSSSepiaFilter& rhs) const = default;
+};
+
+template <>
+struct CSSDataTypeParser<CSSSepiaFilter>
+    : public detail::CSSFilterSimpleAmountParser<CSSSepiaFilter, "sepia"> {};
+
+static_assert(CSSDataType<CSSSepiaFilter>);
+
+/**
+ * Representation of <filter-function>
+ * https://www.w3.org/TR/filter-effects-1/#typedef-filter-function
+ */
+using CSSFilterFunction = CSSCompoundDataType<
+    CSSBlurFilter,
+    CSSBrightnessFilter,
+    CSSContrastFilter,
+    CSSDropShadowFilter,
+    CSSGrayscaleFilter,
+    CSSHueRotateFilter,
+    CSSInvertFilter,
+    CSSOpacityFilter,
+    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
+ */
+using CSSFilterList = CSSWhitespaceSeparatedList<CSSFilterFunction>;
+
+} // namespace facebook::react

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

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <react/renderer/css/CSSDataType.h>
+#include <react/renderer/css/CSSKeyword.h>
+#include <react/renderer/css/CSSList.h>
+#include <react/utils/to_underlying.h>
+
+namespace facebook::react {
+
+/**
+ * Represents a possible font-variant keyword.
+ * https://drafts.csswg.org/css-fonts/#font-variant-prop
+ */
+enum class CSSFontVariant : std::underlying_type_t<CSSKeyword> {
+  SmallCaps = to_underlying(CSSKeyword::SmallCaps),
+  OldstyleNums = to_underlying(CSSKeyword::OldstyleNums),
+  LiningNums = to_underlying(CSSKeyword::LiningNums),
+  TabularNums = to_underlying(CSSKeyword::TabularNums),
+  CommonLigatures = to_underlying(CSSKeyword::CommonLigatures),
+  NoCommonLigatures = to_underlying(CSSKeyword::NoCommonLigatures),
+  DiscretionaryLigatures = to_underlying(CSSKeyword::DiscretionaryLigatures),
+  NoDiscretionaryLigatures =
+      to_underlying(CSSKeyword::NoDiscretionaryLigatures),
+  HistoricalLigatures = to_underlying(CSSKeyword::HistoricalLigatures),
+  NoHistoricalLigatures = to_underlying(CSSKeyword::NoHistoricalLigatures),
+  Contextual = to_underlying(CSSKeyword::Contextual),
+  NoContextual = to_underlying(CSSKeyword::NoContextual),
+  ProportionalNums = to_underlying(CSSKeyword::ProportionalNums),
+  StylisticOne = to_underlying(CSSKeyword::StylisticOne),
+  StylisticTwo = to_underlying(CSSKeyword::StylisticTwo),
+  StylisticThree = to_underlying(CSSKeyword::StylisticThree),
+  StylisticFour = to_underlying(CSSKeyword::StylisticFour),
+  StylisticFive = to_underlying(CSSKeyword::StylisticFive),
+  StylisticSix = to_underlying(CSSKeyword::StylisticSix),
+  StylisticSeven = to_underlying(CSSKeyword::StylisticSeven),
+  StylisticEight = to_underlying(CSSKeyword::StylisticEight),
+  StylisticNine = to_underlying(CSSKeyword::StylisticNine),
+  StylisticTen = to_underlying(CSSKeyword::StylisticTen),
+  StylisticEleven = to_underlying(CSSKeyword::StylisticEleven),
+  StylisticTwelve = to_underlying(CSSKeyword::StylisticTwelve),
+  StylisticThirteen = to_underlying(CSSKeyword::StylisticThirteen),
+  StylisticFourteen = to_underlying(CSSKeyword::StylisticFourteen),
+  StylisticFifteen = to_underlying(CSSKeyword::StylisticFifteen),
+  StylisticSixteen = to_underlying(CSSKeyword::StylisticSixteen),
+  StylisticSeventeen = to_underlying(CSSKeyword::StylisticSeventeen),
+  StylisticEighteen = to_underlying(CSSKeyword::StylisticEighteen),
+  StylisticNineteen = to_underlying(CSSKeyword::StylisticNineteen),
+  StylisticTwenty = to_underlying(CSSKeyword::StylisticTwenty),
+};
+
+static_assert(CSSDataType<CSSFontVariant>);
+
+/**
+ * Represents a whitespace-separated list of at least one font-variant.
+ */
+using CSSFontVariantList = CSSWhitespaceSeparatedList<CSSFontVariant>;
+
+} // namespace facebook::react

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

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <optional>
+#include <string_view>
+
+#include <react/utils/toLower.h>
+
+namespace facebook::react {
+
+namespace detail {
+enum class HexColorType {
+  Long,
+  Short,
+};
+
+constexpr uint8_t hexToNumeric(std::string_view hex, HexColorType hexType) {
+  int result = 0;
+  for (char c : hex) {
+    int value = 0;
+    if (c >= '0' && c <= '9') {
+      value = c - '0';
+    } else {
+      value = toLower(c) - 'a' + 10;
+    }
+    result *= 16;
+    result += value;
+  }
+
+  if (hexType == HexColorType::Short) {
+    return result * 16 + result;
+  } else {
+    return result;
+  }
+}
+
+constexpr bool isHexDigit(char c) {
+  return (c >= '0' && c <= '9') || (toLower(c) >= 'a' && toLower(c) <= 'f');
+}
+
+constexpr bool isValidHexColor(std::string_view hex) {
+  // The syntax of a <hex-color> is a <hash-token> token whose value consists
+  // of 3, 4, 6, or 8 hexadecimal digits.
+  if (hex.size() != 3 && hex.size() != 4 && hex.size() != 6 &&
+      hex.size() != 8) {
+    return false;
+  }
+
+  for (auto c : hex) {
+    if (!isHexDigit(c)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+} // namespace detail
+
+/**
+ * Parses a CSS <hex-color> value from hash token string value and returns a
+ * CSSColor if it is valid.
+ * https://www.w3.org/TR/css-color-4/#hex-color
+ */
+template <typename CSSColor>
+constexpr std::optional<CSSColor> parseCSSHexColor(
+    std::string_view hexColorValue) {
+  if (detail::isValidHexColor(hexColorValue)) {
+    if (hexColorValue.length() == 3) {
+      return CSSColor{
+          hexToNumeric(hexColorValue.substr(0, 1), detail::HexColorType::Short),
+          hexToNumeric(hexColorValue.substr(1, 1), detail::HexColorType::Short),
+          hexToNumeric(hexColorValue.substr(2, 1), detail::HexColorType::Short),
+          255u};
+    } else if (hexColorValue.length() == 4) {
+      return CSSColor{
+          hexToNumeric(hexColorValue.substr(0, 1), detail::HexColorType::Short),
+          hexToNumeric(hexColorValue.substr(1, 1), detail::HexColorType::Short),
+          hexToNumeric(hexColorValue.substr(2, 1), detail::HexColorType::Short),
+          hexToNumeric(
+              hexColorValue.substr(3, 1), detail::HexColorType::Short)};
+    } else if (hexColorValue.length() == 6) {
+      return CSSColor{
+          hexToNumeric(hexColorValue.substr(0, 2), detail::HexColorType::Long),
+          hexToNumeric(hexColorValue.substr(2, 2), detail::HexColorType::Long),
+          hexToNumeric(hexColorValue.substr(4, 2), detail::HexColorType::Long),
+          255u};
+    } else if (hexColorValue.length() == 8) {
+      return CSSColor{
+          hexToNumeric(hexColorValue.substr(0, 2), detail::HexColorType::Long),
+          hexToNumeric(hexColorValue.substr(2, 2), detail::HexColorType::Long),
+          hexToNumeric(hexColorValue.substr(4, 2), detail::HexColorType::Long),
+          hexToNumeric(hexColorValue.substr(6, 2), detail::HexColorType::Long)};
+    }
+  }
+  return {};
+}
+
+} // namespace facebook::react