Make renderer View conversions CSS-free (#58786)

Summary:
Pull Request resolved: https://github.com/react/react-native/pull/58786

Move CSS-dependent View conversion implementations for Yoga lengths, value units, transforms, transform origins, and aspect ratios from the exported `conversions.h` header into `conversions.cpp`. Keep the supported conversion declarations public and preserve existing parsing behavior. This change is necessary to remove CSS headers leaks as visibility of CSS module will be changed to `for frameworks` eventually.

Update existing conversion tests to exercise the same paths through supported public entry points, and regenerate the C++ API snapshots to remove private helper declarations.

Changelog: [Internal]

Reviewed By: javache

Differential Revision: D119507215

fbshipit-source-id: 1d39e6099fdd07d08b3c0759f55904b2992476f2
This commit is contained in:
Dawid Małecki authored and meta-codesync[bot] committed 2026-10-02 09:45:27 -07:00
1 parent 77bcf48575
commit 791835efc6
12 files changed
+848 -771

No files matched your search

@@ -0,0 +1,779 @@
/*
* 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.
*/
#include "conversions.h"
#include <react/debug/react_native_expect.h>
#include <react/featureflags/ReactNativeFeatureFlags.h>
#include <react/renderer/css/CSSAngle.h>
#include <react/renderer/css/CSSNumber.h>
#include <react/renderer/css/CSSPercentage.h>
#include <react/renderer/css/CSSRatio.h>
#include <react/renderer/css/CSSTransform.h>
#include <react/renderer/css/CSSTransformOrigin.h>
#include <react/renderer/css/CSSValueParser.h>
#include <cmath>
#include <optional>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <variant>
#include <vector>
namespace facebook::react {
void fromRawValue(
const PropsParserContext& /*context*/,
const RawValue& value,
yoga::Style::SizeLength& result) {
if (value.hasType<Float>()) {
result = yoga::StyleSizeLength::points((float)value);
return;
} else if (value.hasType<std::string>()) {
const auto stringValue = (std::string)value;
if (stringValue == "auto") {
result = yoga::StyleSizeLength::ofAuto();
return;
} else if (stringValue == "max-content") {
result = yoga::StyleSizeLength::ofMaxContent();
return;
} else if (stringValue == "stretch") {
result = yoga::StyleSizeLength::ofStretch();
return;
} else if (stringValue == "fit-content") {
result = yoga::StyleSizeLength::ofFitContent();
return;
} else {
auto parsed = parseCSSProperty<CSSNumber, CSSPercentage>(stringValue);
if (std::holds_alternative<CSSPercentage>(parsed)) {
result = yoga::StyleSizeLength::percent(
std::get<CSSPercentage>(parsed).value);
return;
} else if (std::holds_alternative<CSSNumber>(parsed)) {
result =
yoga::StyleSizeLength::points(std::get<CSSNumber>(parsed).value);
return;
}
}
}
result = yoga::StyleSizeLength::undefined();
}
void fromRawValue(
const PropsParserContext& context,
const RawValue& value,
yoga::Style::Length& result) {
if (value.hasType<Float>()) {
result = yoga::StyleLength::points((float)value);
return;
} else if (value.hasType<std::string>()) {
const auto stringValue = (std::string)value;
if (stringValue == "auto") {
result = yoga::StyleLength::ofAuto();
return;
} else {
auto parsed = parseCSSProperty<CSSNumber, CSSPercentage>(stringValue);
if (std::holds_alternative<CSSPercentage>(parsed)) {
result =
yoga::StyleLength::percent(std::get<CSSPercentage>(parsed).value);
return;
} else if (std::holds_alternative<CSSNumber>(parsed)) {
result = yoga::StyleLength::points(std::get<CSSNumber>(parsed).value);
return;
}
}
}
result = yoga::StyleLength::undefined();
}
void fromRawValue(
const PropsParserContext& context,
const RawValue& value,
YGValue& result) {
yoga::Style::Length length{};
fromRawValue(context, value, length);
result = (YGValue)length;
}
yoga::FloatOptional convertAspectRatio(
const PropsParserContext& /*context*/,
const RawValue& value) {
if (value.hasType<float>()) {
return yoga::FloatOptional((float)value);
}
if (ReactNativeFeatureFlags::enableNativeCSSParsing() &&
value.hasType<std::string>()) {
auto ratio = parseCSSProperty<CSSRatio>((std::string)value);
if (std::holds_alternative<CSSRatio>(ratio)) {
auto r = std::get<CSSRatio>(ratio);
if (!r.isDegenerate()) {
return yoga::FloatOptional(r.numerator / r.denominator);
}
}
}
return {};
}
namespace {
std::optional<Float> toRadians(const RawValue& value) {
if (value.hasType<Float>()) {
return (Float)value;
}
if (!value.hasType<std::string>()) {
return {};
}
auto angle = parseCSSProperty<CSSAngle>((std::string)value);
if (std::holds_alternative<CSSAngle>(angle)) {
return static_cast<float>(
std::get<CSSAngle>(angle).degrees * M_PI / 180.0f);
}
return {};
}
} // namespace
ValueUnit toValueUnit(const RawValue& value) {
if (value.hasType<Float>()) {
return ValueUnit((Float)value, UnitType::Point);
}
if (!value.hasType<std::string>()) {
return {};
}
auto pct = parseCSSProperty<CSSPercentage>((std::string)value);
if (std::holds_alternative<CSSPercentage>(pct)) {
return ValueUnit(std::get<CSSPercentage>(pct).value, UnitType::Percent);
}
return {};
}
void fromRawValue(
const PropsParserContext& /*context*/,
const RawValue& value,
ValueUnit& result) {
result = toValueUnit(value);
}
namespace {
ValueUnit cssLengthPercentageToValueUnit(
const std::variant<CSSLength, CSSPercentage>& value) {
if (std::holds_alternative<CSSLength>(value)) {
auto len = std::get<CSSLength>(value);
if (len.unit != CSSLengthUnit::Px) {
return {};
}
return {len.value, UnitType::Point};
} else {
return {std::get<CSSPercentage>(value).value, UnitType::Percent};
}
}
std::optional<TransformOperation> fromCSSTransformFunction(
const CSSTransformFunction& cssTransform) {
constexpr auto Zero = ValueUnit(0, UnitType::Point);
constexpr auto One = ValueUnit(1, UnitType::Point);
return std::visit(
[&](auto&& func) -> std::optional<TransformOperation> {
using T = std::decay_t<decltype(func)>;
if constexpr (std::is_same_v<T, CSSRotate>) {
auto radians = static_cast<float>(func.degrees * M_PI / 180.0f);
return TransformOperation{
.type = TransformOperationType::Rotate,
.x = Zero,
.y = Zero,
.z = ValueUnit(radians, UnitType::Point)};
}
if constexpr (std::is_same_v<T, CSSRotateX>) {
auto radians = static_cast<float>(func.degrees * M_PI / 180.0f);
return TransformOperation{
.type = TransformOperationType::Rotate,
.x = ValueUnit(radians, UnitType::Point),
.y = Zero,
.z = Zero};
}
if constexpr (std::is_same_v<T, CSSRotateY>) {
auto radians = static_cast<float>(func.degrees * M_PI / 180.0f);
return TransformOperation{
.type = TransformOperationType::Rotate,
.x = Zero,
.y = ValueUnit(radians, UnitType::Point),
.z = Zero};
}
if constexpr (std::is_same_v<T, CSSRotateZ>) {
auto radians = static_cast<float>(func.degrees * M_PI / 180.0f);
return TransformOperation{
.type = TransformOperationType::Rotate,
.x = Zero,
.y = Zero,
.z = ValueUnit(radians, UnitType::Point)};
}
if constexpr (std::is_same_v<T, CSSTranslate>) {
auto x = cssLengthPercentageToValueUnit(func.x);
auto y = cssLengthPercentageToValueUnit(func.y);
if (!x || !y) {
return std::nullopt;
}
return TransformOperation{
.type = TransformOperationType::Translate,
.x = x,
.y = y,
.z = Zero};
}
if constexpr (std::is_same_v<T, CSSTranslateX>) {
auto x = cssLengthPercentageToValueUnit(func.value);
if (!x) {
return std::nullopt;
}
return TransformOperation{
.type = TransformOperationType::Translate,
.x = x,
.y = Zero,
.z = Zero};
}
if constexpr (std::is_same_v<T, CSSTranslateY>) {
auto y = cssLengthPercentageToValueUnit(func.value);
if (!y) {
return std::nullopt;
}
return TransformOperation{
.type = TransformOperationType::Translate,
.x = Zero,
.y = y,
.z = Zero};
}
if constexpr (std::is_same_v<T, CSSTranslate3D>) {
auto x = cssLengthPercentageToValueUnit(func.x);
auto y = cssLengthPercentageToValueUnit(func.y);
if (!x || !y || func.z.unit != CSSLengthUnit::Px) {
return std::nullopt;
}
return TransformOperation{
.type = TransformOperationType::Translate,
.x = x,
.y = y,
.z = ValueUnit(func.z.value, UnitType::Point)};
}
if constexpr (std::is_same_v<T, CSSScale>) {
return TransformOperation{
.type = TransformOperationType::Scale,
.x = ValueUnit(func.x, UnitType::Point),
.y = ValueUnit(func.y, UnitType::Point),
.z = One};
}
if constexpr (std::is_same_v<T, CSSScaleX>) {
return TransformOperation{
.type = TransformOperationType::Scale,
.x = ValueUnit(func.value, UnitType::Point),
.y = One,
.z = One};
}
if constexpr (std::is_same_v<T, CSSScaleY>) {
return TransformOperation{
.type = TransformOperationType::Scale,
.x = One,
.y = ValueUnit(func.value, UnitType::Point),
.z = One};
}
if constexpr (std::is_same_v<T, CSSSkewX>) {
auto radians = static_cast<float>(func.degrees * M_PI / 180.0f);
return TransformOperation{
.type = TransformOperationType::Skew,
.x = ValueUnit(radians, UnitType::Point),
.y = Zero,
.z = Zero};
}
if constexpr (std::is_same_v<T, CSSSkewY>) {
auto radians = static_cast<float>(func.degrees * M_PI / 180.0f);
return TransformOperation{
.type = TransformOperationType::Skew,
.x = Zero,
.y = ValueUnit(radians, UnitType::Point),
.z = Zero};
}
if constexpr (std::is_same_v<T, CSSPerspective>) {
if (func.length.unit != CSSLengthUnit::Px) {
return std::nullopt;
}
return TransformOperation{
.type = TransformOperationType::Perspective,
.x = ValueUnit(func.length.value, UnitType::Point),
.y = Zero,
.z = Zero};
}
if constexpr (std::is_same_v<T, CSSMatrix>) {
return TransformOperation{
.type = TransformOperationType::Arbitrary,
.x = Zero,
.y = Zero,
.z = Zero};
}
},
cssTransform);
}
void parseProcessedTransform(
const PropsParserContext& /*context*/,
const RawValue& value,
Transform& result) {
auto transformMatrix = Transform{};
react_native_expect(value.hasType<std::vector<RawValue>>());
if (!value.hasType<std::vector<RawValue>>()) {
result = transformMatrix;
return;
}
auto configurations = static_cast<std::vector<RawValue>>(value);
for (const auto& configuration : configurations) {
if (!configuration.hasType<std::unordered_map<std::string, RawValue>>()) {
result = {};
return;
}
auto configurationPair =
static_cast<std::unordered_map<std::string, RawValue>>(configuration);
if (configurationPair.size() != 1) {
result = {};
return;
}
auto pair = configurationPair.begin();
auto operation = pair->first;
auto& parameters = pair->second;
auto Zero = ValueUnit(0, UnitType::Point);
auto One = ValueUnit(1, UnitType::Point);
if (operation == "matrix") {
// T215634510: We should support matrix transforms as part of a list of
// transforms
if (configurations.size() > 1) {
result = {};
return;
}
if (!parameters.hasType<std::vector<Float>>()) {
result = {};
return;
}
auto numbers = (std::vector<Float>)parameters;
if (numbers.size() != 9 && numbers.size() != 16) {
result = {};
return;
}
if (numbers.size() == 16) {
size_t i = 0;
for (auto number : numbers) {
transformMatrix.matrix[i++] = number;
}
} else if (numbers.size() == 9) {
// We need to convert the 2d transform matrix into a 3d one as such:
// [
// x00, x01, 0, x02
// x10, x11, 0, x12
// 0, 0, 1, 0
// x20, x21, 0, x22
// ]
transformMatrix.matrix[0] = numbers[0];
transformMatrix.matrix[1] = numbers[1];
transformMatrix.matrix[2] = 0;
transformMatrix.matrix[3] = numbers[2];
transformMatrix.matrix[4] = numbers[3];
transformMatrix.matrix[5] = numbers[4];
transformMatrix.matrix[6] = 0;
transformMatrix.matrix[7] = numbers[5];
transformMatrix.matrix[8] = 0;
transformMatrix.matrix[9] = 0;
transformMatrix.matrix[10] = 1;
transformMatrix.matrix[11] = 0;
transformMatrix.matrix[12] = numbers[6];
transformMatrix.matrix[13] = numbers[7];
transformMatrix.matrix[14] = 0;
transformMatrix.matrix[15] = numbers[8];
}
transformMatrix.operations.push_back(
TransformOperation{
.type = TransformOperationType::Arbitrary,
.x = Zero,
.y = Zero,
.z = Zero});
} else if (operation == "perspective") {
if (!parameters.hasType<Float>()) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{
.type = TransformOperationType::Perspective,
.x = ValueUnit((Float)parameters, UnitType::Point),
.y = Zero,
.z = Zero});
} else if (operation == "rotateX") {
auto radians = toRadians(parameters);
if (!radians.has_value()) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{
.type = TransformOperationType::Rotate,
.x = ValueUnit(*radians, UnitType::Point),
.y = Zero,
.z = Zero});
} else if (operation == "rotateY") {
auto radians = toRadians(parameters);
if (!radians.has_value()) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{
.type = TransformOperationType::Rotate,
.x = Zero,
.y = ValueUnit(*radians, UnitType::Point),
.z = Zero});
} else if (operation == "rotateZ" || operation == "rotate") {
auto radians = toRadians(parameters);
if (!radians.has_value()) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{
.type = TransformOperationType::Rotate,
.x = Zero,
.y = Zero,
.z = ValueUnit(*radians, UnitType::Point)});
} else if (operation == "scale") {
if (!parameters.hasType<Float>()) {
result = {};
return;
}
auto number = ValueUnit((Float)parameters, UnitType::Point);
transformMatrix.operations.push_back(
TransformOperation{
.type = TransformOperationType::Scale,
.x = number,
.y = number,
.z = number});
} else if (operation == "scaleX") {
if (!parameters.hasType<Float>()) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{
.type = TransformOperationType::Scale,
.x = ValueUnit((Float)parameters, UnitType::Point),
.y = One,
.z = One});
} else if (operation == "scaleY") {
if (!parameters.hasType<Float>()) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{
.type = TransformOperationType::Scale,
.x = One,
.y = ValueUnit((Float)parameters, UnitType::Point),
.z = One});
} else if (operation == "scaleZ") {
if (!parameters.hasType<Float>()) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{
.type = TransformOperationType::Scale,
.x = One,
.y = One,
.z = ValueUnit((Float)parameters, UnitType::Point)});
} else if (operation == "translate") {
if (!parameters.hasType<std::vector<RawValue>>()) {
result = {};
return;
}
auto numbers = (std::vector<RawValue>)parameters;
if (numbers.size() != 2) {
result = {};
return;
}
auto valueX = toValueUnit(numbers[0]);
if (!valueX) {
result = {};
return;
}
auto valueY = toValueUnit(numbers[1]);
if (!valueY) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{
.type = TransformOperationType::Translate,
.x = valueX,
.y = valueY,
.z = Zero});
} else if (operation == "translateX") {
auto valueX = toValueUnit(parameters);
if (!valueX) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{
.type = TransformOperationType::Translate,
.x = valueX,
.y = Zero,
.z = Zero});
} else if (operation == "translateY") {
auto valueY = toValueUnit(parameters);
if (!valueY) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{
.type = TransformOperationType::Translate,
.x = Zero,
.y = valueY,
.z = Zero});
} else if (operation == "skewX") {
auto radians = toRadians(parameters);
if (!radians.has_value()) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{
.type = TransformOperationType::Skew,
.x = ValueUnit(*radians, UnitType::Point),
.y = Zero,
.z = Zero});
} else if (operation == "skewY") {
auto radians = toRadians(parameters);
if (!radians.has_value()) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{
.type = TransformOperationType::Skew,
.x = Zero,
.y = ValueUnit(*radians, UnitType::Point),
.z = Zero});
}
}
result = transformMatrix;
}
void parseUnprocessedTransformString(
const std::string& value,
Transform& result) {
auto transformList = parseCSSProperty<CSSTransformList>(value);
if (!std::holds_alternative<CSSTransformList>(transformList)) {
result = {};
return;
}
auto transformMatrix = Transform{};
const auto& cssFuncs = std::get<CSSTransformList>(transformList);
transformMatrix.operations.reserve(cssFuncs.size());
for (const auto& cssFunc : cssFuncs) {
auto op = fromCSSTransformFunction(cssFunc);
if (!op.has_value()) {
result = {};
return;
}
if (op->type == TransformOperationType::Arbitrary) {
// CSSMatrix: expand 6-value 2D matrix to 4x4 matrix
if (std::holds_alternative<CSSMatrix>(cssFunc)) {
const auto& m = std::get<CSSMatrix>(cssFunc);
transformMatrix.matrix[0] = m.values[0];
transformMatrix.matrix[1] = m.values[1];
transformMatrix.matrix[2] = 0;
transformMatrix.matrix[3] = 0;
transformMatrix.matrix[4] = m.values[2];
transformMatrix.matrix[5] = m.values[3];
transformMatrix.matrix[6] = 0;
transformMatrix.matrix[7] = 0;
transformMatrix.matrix[8] = 0;
transformMatrix.matrix[9] = 0;
transformMatrix.matrix[10] = 1;
transformMatrix.matrix[11] = 0;
transformMatrix.matrix[12] = m.values[4];
transformMatrix.matrix[13] = m.values[5];
transformMatrix.matrix[14] = 0;
transformMatrix.matrix[15] = 1;
}
}
transformMatrix.operations.push_back(*op);
}
result = transformMatrix;
}
void parseUnprocessedTransform(
const PropsParserContext& context,
const RawValue& value,
Transform& result) {
if (value.hasType<std::string>()) {
parseUnprocessedTransformString((std::string)value, result);
} else {
parseProcessedTransform(context, value, result);
}
}
} // namespace
void fromRawValue(
const PropsParserContext& context,
const RawValue& value,
Transform& result) {
if (ReactNativeFeatureFlags::enableNativeCSSParsing()) {
parseUnprocessedTransform(context, value, result);
} else {
parseProcessedTransform(context, value, result);
}
}
namespace {
void parseProcessedTransformOrigin(
const PropsParserContext& /*context*/,
const RawValue& value,
TransformOrigin& result) {
if (!value.hasType<std::vector<RawValue>>()) {
result = {};
return;
}
auto origins = (std::vector<RawValue>)value;
if (origins.size() != 3) {
result = {};
return;
}
TransformOrigin transformOrigin;
for (size_t i = 0; i < 2; i++) {
auto origin = toValueUnit(origins[i]);
if (!origin) {
result = {};
return;
}
transformOrigin.xy[i] = origin;
}
if (!origins[2].hasType<Float>()) {
result = {};
return;
}
transformOrigin.z = (Float)origins[2];
result = transformOrigin;
}
void parseUnprocessedTransformOriginString(
const std::string& value,
TransformOrigin& result) {
auto cssOrigin = parseCSSProperty<CSSTransformOrigin>(value);
if (!std::holds_alternative<CSSTransformOrigin>(cssOrigin)) {
result = {};
return;
}
const auto& origin = std::get<CSSTransformOrigin>(cssOrigin);
TransformOrigin transformOrigin;
auto x = cssLengthPercentageToValueUnit(origin.x);
auto y = cssLengthPercentageToValueUnit(origin.y);
if (!x || !y) {
result = {};
return;
}
transformOrigin.xy[0] = x;
transformOrigin.xy[1] = y;
if (origin.z.unit != CSSLengthUnit::Px) {
result = {};
return;
}
transformOrigin.z = origin.z.value;
result = transformOrigin;
}
void parseUnprocessedTransformOrigin(
const PropsParserContext& context,
const RawValue& value,
TransformOrigin& result) {
if (value.hasType<std::string>()) {
parseUnprocessedTransformOriginString((std::string)value, result);
} else {
parseProcessedTransformOrigin(context, value, result);
}
}
} // namespace
void fromRawValue(
const PropsParserContext& context,
const RawValue& value,
TransformOrigin& result) {
if (ReactNativeFeatureFlags::enableNativeCSSParsing()) {
parseUnprocessedTransformOrigin(context, value, result);
} else {
parseProcessedTransformOrigin(context, value, result);
}
}
} // namespace facebook::react
@@ -11,19 +11,11 @@
#include <glog/logging.h>
#include <react/debug/react_native_expect.h>
#include <react/featureflags/ReactNativePublicFeatureFlags.h>
#include <react/renderer/components/view/primitives.h>
#include <react/renderer/core/LayoutMetrics.h>
#include <react/renderer/core/PropsParserContext.h>
#include <react/renderer/core/RawProps.h>
#include <react/renderer/core/graphicsConversions.h>
#include <react/renderer/css/CSSAngle.h>
#include <react/renderer/css/CSSNumber.h>
#include <react/renderer/css/CSSPercentage.h>
#include <react/renderer/css/CSSRatio.h>
#include <react/renderer/css/CSSTransform.h>
#include <react/renderer/css/CSSTransformOrigin.h>
#include <react/renderer/css/CSSValueParser.h>
#include <react/renderer/debug/DebugStringConvertible.h>
#include <react/renderer/debug/flags.h>
#include <react/renderer/graphics/BackgroundPosition.h>
@@ -32,7 +24,6 @@
#include <react/renderer/graphics/BlendMode.h>
#include <react/renderer/graphics/Isolation.h>
#include <react/renderer/graphics/LinearGradient.h>
#include <react/renderer/graphics/PlatformColorParser.h>
#include <react/renderer/graphics/Transform.h>
#include <react/renderer/graphics/ValueUnit.h>
#include <yoga/YGEnums.h>
@@ -446,645 +437,26 @@ inline void fromRawValue(const PropsParserContext &context, const RawValue &valu
LOG(ERROR) << "Could not parse yoga::Display: " << stringValue;
}
inline void fromRawValue(const PropsParserContext & /*context*/, const RawValue &value, yoga::Style::SizeLength &result)
{
if (value.hasType<Float>()) {
result = yoga::StyleSizeLength::points((float)value);
return;
} else if (value.hasType<std::string>()) {
const auto stringValue = (std::string)value;
if (stringValue == "auto") {
result = yoga::StyleSizeLength::ofAuto();
return;
} else if (stringValue == "max-content") {
result = yoga::StyleSizeLength::ofMaxContent();
return;
} else if (stringValue == "stretch") {
result = yoga::StyleSizeLength::ofStretch();
return;
} else if (stringValue == "fit-content") {
result = yoga::StyleSizeLength::ofFitContent();
return;
} else {
auto parsed = parseCSSProperty<CSSNumber, CSSPercentage>(stringValue);
if (std::holds_alternative<CSSPercentage>(parsed)) {
result = yoga::StyleSizeLength::percent(std::get<CSSPercentage>(parsed).value);
return;
} else if (std::holds_alternative<CSSNumber>(parsed)) {
result = yoga::StyleSizeLength::points(std::get<CSSNumber>(parsed).value);
return;
}
}
}
result = yoga::StyleSizeLength::undefined();
}
void fromRawValue(const PropsParserContext & /*context*/, const RawValue &value, yoga::Style::SizeLength &result);
inline void fromRawValue(const PropsParserContext &context, const RawValue &value, yoga::Style::Length &result)
{
if (value.hasType<Float>()) {
result = yoga::StyleLength::points((float)value);
return;
} else if (value.hasType<std::string>()) {
const auto stringValue = (std::string)value;
if (stringValue == "auto") {
result = yoga::StyleLength::ofAuto();
return;
} else {
auto parsed = parseCSSProperty<CSSNumber, CSSPercentage>(stringValue);
if (std::holds_alternative<CSSPercentage>(parsed)) {
result = yoga::StyleLength::percent(std::get<CSSPercentage>(parsed).value);
return;
} else if (std::holds_alternative<CSSNumber>(parsed)) {
result = yoga::StyleLength::points(std::get<CSSNumber>(parsed).value);
return;
}
}
}
result = yoga::StyleLength::undefined();
}
void fromRawValue(const PropsParserContext &context, const RawValue &value, yoga::Style::Length &result);
inline void fromRawValue(const PropsParserContext &context, const RawValue &value, YGValue &result)
{
yoga::Style::Length length{};
fromRawValue(context, value, length);
result = (YGValue)length;
}
void fromRawValue(const PropsParserContext &context, const RawValue &value, YGValue &result);
inline void fromRawValue(const PropsParserContext &context, const RawValue &value, yoga::FloatOptional &result)
{
result = value.hasType<float>() ? yoga::FloatOptional((float)value) : yoga::FloatOptional();
}
inline yoga::FloatOptional convertAspectRatio(const PropsParserContext & /*context*/, const RawValue &value)
{
if (value.hasType<float>()) {
return yoga::FloatOptional((float)value);
}
if (ReactNativeFeatureFlags_DO_NOT_USE::enableNativeCSSParsing() && value.hasType<std::string>()) {
auto ratio = parseCSSProperty<CSSRatio>((std::string)value);
if (std::holds_alternative<CSSRatio>(ratio)) {
auto r = std::get<CSSRatio>(ratio);
if (!r.isDegenerate()) {
return yoga::FloatOptional(r.numerator / r.denominator);
}
}
}
return {};
}
yoga::FloatOptional convertAspectRatio(const PropsParserContext & /*context*/, const RawValue &value);
inline std::optional<Float> toRadians(const RawValue &value)
{
if (value.hasType<Float>()) {
return (Float)value;
}
if (!value.hasType<std::string>()) {
return {};
}
ValueUnit toValueUnit(const RawValue &value);
auto angle = parseCSSProperty<CSSAngle>((std::string)value);
if (std::holds_alternative<CSSAngle>(angle)) {
return static_cast<float>(std::get<CSSAngle>(angle).degrees * M_PI / 180.0f);
}
void fromRawValue(const PropsParserContext & /*context*/, const RawValue &value, ValueUnit &result);
return {};
}
void fromRawValue(const PropsParserContext &context, const RawValue &value, Transform &result);
inline ValueUnit toValueUnit(const RawValue &value)
{
if (value.hasType<Float>()) {
return ValueUnit((Float)value, UnitType::Point);
}
if (!value.hasType<std::string>()) {
return {};
}
auto pct = parseCSSProperty<CSSPercentage>((std::string)value);
if (std::holds_alternative<CSSPercentage>(pct)) {
return ValueUnit(std::get<CSSPercentage>(pct).value, UnitType::Percent);
}
return {};
}
inline void fromRawValue(const PropsParserContext & /*context*/, const RawValue &value, ValueUnit &result)
{
result = toValueUnit(value);
}
inline ValueUnit cssLengthPercentageToValueUnit(const std::variant<CSSLength, CSSPercentage> &value)
{
if (std::holds_alternative<CSSLength>(value)) {
auto len = std::get<CSSLength>(value);
if (len.unit != CSSLengthUnit::Px) {
return {};
}
return {len.value, UnitType::Point};
} else {
return {std::get<CSSPercentage>(value).value, UnitType::Percent};
}
}
inline std::optional<TransformOperation> fromCSSTransformFunction(const CSSTransformFunction &cssTransform)
{
constexpr auto Zero = ValueUnit(0, UnitType::Point);
constexpr auto One = ValueUnit(1, UnitType::Point);
return std::visit(
[&](auto &&func) -> std::optional<TransformOperation> {
using T = std::decay_t<decltype(func)>;
if constexpr (std::is_same_v<T, CSSRotate>) {
auto radians = static_cast<float>(func.degrees * M_PI / 180.0f);
return TransformOperation{
.type = TransformOperationType::Rotate, .x = Zero, .y = Zero, .z = ValueUnit(radians, UnitType::Point)};
}
if constexpr (std::is_same_v<T, CSSRotateX>) {
auto radians = static_cast<float>(func.degrees * M_PI / 180.0f);
return TransformOperation{
.type = TransformOperationType::Rotate, .x = ValueUnit(radians, UnitType::Point), .y = Zero, .z = Zero};
}
if constexpr (std::is_same_v<T, CSSRotateY>) {
auto radians = static_cast<float>(func.degrees * M_PI / 180.0f);
return TransformOperation{
.type = TransformOperationType::Rotate, .x = Zero, .y = ValueUnit(radians, UnitType::Point), .z = Zero};
}
if constexpr (std::is_same_v<T, CSSRotateZ>) {
auto radians = static_cast<float>(func.degrees * M_PI / 180.0f);
return TransformOperation{
.type = TransformOperationType::Rotate, .x = Zero, .y = Zero, .z = ValueUnit(radians, UnitType::Point)};
}
if constexpr (std::is_same_v<T, CSSTranslate>) {
auto x = cssLengthPercentageToValueUnit(func.x);
auto y = cssLengthPercentageToValueUnit(func.y);
if (!x || !y) {
return std::nullopt;
}
return TransformOperation{.type = TransformOperationType::Translate, .x = x, .y = y, .z = Zero};
}
if constexpr (std::is_same_v<T, CSSTranslateX>) {
auto x = cssLengthPercentageToValueUnit(func.value);
if (!x) {
return std::nullopt;
}
return TransformOperation{.type = TransformOperationType::Translate, .x = x, .y = Zero, .z = Zero};
}
if constexpr (std::is_same_v<T, CSSTranslateY>) {
auto y = cssLengthPercentageToValueUnit(func.value);
if (!y) {
return std::nullopt;
}
return TransformOperation{.type = TransformOperationType::Translate, .x = Zero, .y = y, .z = Zero};
}
if constexpr (std::is_same_v<T, CSSTranslate3D>) {
auto x = cssLengthPercentageToValueUnit(func.x);
auto y = cssLengthPercentageToValueUnit(func.y);
if (!x || !y || func.z.unit != CSSLengthUnit::Px) {
return std::nullopt;
}
return TransformOperation{
.type = TransformOperationType::Translate, .x = x, .y = y, .z = ValueUnit(func.z.value, UnitType::Point)};
}
if constexpr (std::is_same_v<T, CSSScale>) {
return TransformOperation{
.type = TransformOperationType::Scale,
.x = ValueUnit(func.x, UnitType::Point),
.y = ValueUnit(func.y, UnitType::Point),
.z = One};
}
if constexpr (std::is_same_v<T, CSSScaleX>) {
return TransformOperation{
.type = TransformOperationType::Scale, .x = ValueUnit(func.value, UnitType::Point), .y = One, .z = One};
}
if constexpr (std::is_same_v<T, CSSScaleY>) {
return TransformOperation{
.type = TransformOperationType::Scale, .x = One, .y = ValueUnit(func.value, UnitType::Point), .z = One};
}
if constexpr (std::is_same_v<T, CSSSkewX>) {
auto radians = static_cast<float>(func.degrees * M_PI / 180.0f);
return TransformOperation{
.type = TransformOperationType::Skew, .x = ValueUnit(radians, UnitType::Point), .y = Zero, .z = Zero};
}
if constexpr (std::is_same_v<T, CSSSkewY>) {
auto radians = static_cast<float>(func.degrees * M_PI / 180.0f);
return TransformOperation{
.type = TransformOperationType::Skew, .x = Zero, .y = ValueUnit(radians, UnitType::Point), .z = Zero};
}
if constexpr (std::is_same_v<T, CSSPerspective>) {
if (func.length.unit != CSSLengthUnit::Px) {
return std::nullopt;
}
return TransformOperation{
.type = TransformOperationType::Perspective,
.x = ValueUnit(func.length.value, UnitType::Point),
.y = Zero,
.z = Zero};
}
if constexpr (std::is_same_v<T, CSSMatrix>) {
return TransformOperation{.type = TransformOperationType::Arbitrary, .x = Zero, .y = Zero, .z = Zero};
}
},
cssTransform);
}
inline void parseProcessedTransform(const PropsParserContext & /*context*/, const RawValue &value, Transform &result)
{
auto transformMatrix = Transform{};
react_native_expect(value.hasType<std::vector<RawValue>>());
if (!value.hasType<std::vector<RawValue>>()) {
result = transformMatrix;
return;
}
auto configurations = static_cast<std::vector<RawValue>>(value);
for (const auto &configuration : configurations) {
if (!configuration.hasType<std::unordered_map<std::string, RawValue>>()) {
result = {};
return;
}
auto configurationPair = static_cast<std::unordered_map<std::string, RawValue>>(configuration);
if (configurationPair.size() != 1) {
result = {};
return;
}
auto pair = configurationPair.begin();
auto operation = pair->first;
auto &parameters = pair->second;
auto Zero = ValueUnit(0, UnitType::Point);
auto One = ValueUnit(1, UnitType::Point);
if (operation == "matrix") {
// T215634510: We should support matrix transforms as part of a list of
// transforms
if (configurations.size() > 1) {
result = {};
return;
}
if (!parameters.hasType<std::vector<Float>>()) {
result = {};
return;
}
auto numbers = (std::vector<Float>)parameters;
if (numbers.size() != 9 && numbers.size() != 16) {
result = {};
return;
}
if (numbers.size() == 16) {
size_t i = 0;
for (auto number : numbers) {
transformMatrix.matrix[i++] = number;
}
} else if (numbers.size() == 9) {
// We need to convert the 2d transform matrix into a 3d one as such:
// [
// x00, x01, 0, x02
// x10, x11, 0, x12
// 0, 0, 1, 0
// x20, x21, 0, x22
// ]
transformMatrix.matrix[0] = numbers[0];
transformMatrix.matrix[1] = numbers[1];
transformMatrix.matrix[2] = 0;
transformMatrix.matrix[3] = numbers[2];
transformMatrix.matrix[4] = numbers[3];
transformMatrix.matrix[5] = numbers[4];
transformMatrix.matrix[6] = 0;
transformMatrix.matrix[7] = numbers[5];
transformMatrix.matrix[8] = 0;
transformMatrix.matrix[9] = 0;
transformMatrix.matrix[10] = 1;
transformMatrix.matrix[11] = 0;
transformMatrix.matrix[12] = numbers[6];
transformMatrix.matrix[13] = numbers[7];
transformMatrix.matrix[14] = 0;
transformMatrix.matrix[15] = numbers[8];
}
transformMatrix.operations.push_back(
TransformOperation{.type = TransformOperationType::Arbitrary, .x = Zero, .y = Zero, .z = Zero});
} else if (operation == "perspective") {
if (!parameters.hasType<Float>()) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{
.type = TransformOperationType::Perspective,
.x = ValueUnit((Float)parameters, UnitType::Point),
.y = Zero,
.z = Zero});
} else if (operation == "rotateX") {
auto radians = toRadians(parameters);
if (!radians.has_value()) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{
.type = TransformOperationType::Rotate, .x = ValueUnit(*radians, UnitType::Point), .y = Zero, .z = Zero});
} else if (operation == "rotateY") {
auto radians = toRadians(parameters);
if (!radians.has_value()) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{
.type = TransformOperationType::Rotate, .x = Zero, .y = ValueUnit(*radians, UnitType::Point), .z = Zero});
} else if (operation == "rotateZ" || operation == "rotate") {
auto radians = toRadians(parameters);
if (!radians.has_value()) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{
.type = TransformOperationType::Rotate, .x = Zero, .y = Zero, .z = ValueUnit(*radians, UnitType::Point)});
} else if (operation == "scale") {
if (!parameters.hasType<Float>()) {
result = {};
return;
}
auto number = ValueUnit((Float)parameters, UnitType::Point);
transformMatrix.operations.push_back(
TransformOperation{.type = TransformOperationType::Scale, .x = number, .y = number, .z = number});
} else if (operation == "scaleX") {
if (!parameters.hasType<Float>()) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{
.type = TransformOperationType::Scale,
.x = ValueUnit((Float)parameters, UnitType::Point),
.y = One,
.z = One});
} else if (operation == "scaleY") {
if (!parameters.hasType<Float>()) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{
.type = TransformOperationType::Scale,
.x = One,
.y = ValueUnit((Float)parameters, UnitType::Point),
.z = One});
} else if (operation == "scaleZ") {
if (!parameters.hasType<Float>()) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{
.type = TransformOperationType::Scale,
.x = One,
.y = One,
.z = ValueUnit((Float)parameters, UnitType::Point)});
} else if (operation == "translate") {
if (!parameters.hasType<std::vector<RawValue>>()) {
result = {};
return;
}
auto numbers = (std::vector<RawValue>)parameters;
if (numbers.size() != 2) {
result = {};
return;
}
auto valueX = toValueUnit(numbers[0]);
if (!valueX) {
result = {};
return;
}
auto valueY = toValueUnit(numbers[1]);
if (!valueY) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{.type = TransformOperationType::Translate, .x = valueX, .y = valueY, .z = Zero});
} else if (operation == "translateX") {
auto valueX = toValueUnit(parameters);
if (!valueX) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{.type = TransformOperationType::Translate, .x = valueX, .y = Zero, .z = Zero});
} else if (operation == "translateY") {
auto valueY = toValueUnit(parameters);
if (!valueY) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{.type = TransformOperationType::Translate, .x = Zero, .y = valueY, .z = Zero});
} else if (operation == "skewX") {
auto radians = toRadians(parameters);
if (!radians.has_value()) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{
.type = TransformOperationType::Skew, .x = ValueUnit(*radians, UnitType::Point), .y = Zero, .z = Zero});
} else if (operation == "skewY") {
auto radians = toRadians(parameters);
if (!radians.has_value()) {
result = {};
return;
}
transformMatrix.operations.push_back(
TransformOperation{
.type = TransformOperationType::Skew, .x = Zero, .y = ValueUnit(*radians, UnitType::Point), .z = Zero});
}
}
result = transformMatrix;
}
inline void parseUnprocessedTransformString(const std::string &value, Transform &result)
{
auto transformList = parseCSSProperty<CSSTransformList>(value);
if (!std::holds_alternative<CSSTransformList>(transformList)) {
result = {};
return;
}
auto transformMatrix = Transform{};
const auto &cssFuncs = std::get<CSSTransformList>(transformList);
transformMatrix.operations.reserve(cssFuncs.size());
for (const auto &cssFunc : cssFuncs) {
auto op = fromCSSTransformFunction(cssFunc);
if (!op.has_value()) {
result = {};
return;
}
if (op->type == TransformOperationType::Arbitrary) {
// CSSMatrix: expand 6-value 2D matrix to 4x4 matrix
if (std::holds_alternative<CSSMatrix>(cssFunc)) {
const auto &m = std::get<CSSMatrix>(cssFunc);
transformMatrix.matrix[0] = m.values[0];
transformMatrix.matrix[1] = m.values[1];
transformMatrix.matrix[2] = 0;
transformMatrix.matrix[3] = 0;
transformMatrix.matrix[4] = m.values[2];
transformMatrix.matrix[5] = m.values[3];
transformMatrix.matrix[6] = 0;
transformMatrix.matrix[7] = 0;
transformMatrix.matrix[8] = 0;
transformMatrix.matrix[9] = 0;
transformMatrix.matrix[10] = 1;
transformMatrix.matrix[11] = 0;
transformMatrix.matrix[12] = m.values[4];
transformMatrix.matrix[13] = m.values[5];
transformMatrix.matrix[14] = 0;
transformMatrix.matrix[15] = 1;
}
}
transformMatrix.operations.push_back(*op);
}
result = transformMatrix;
}
inline void parseUnprocessedTransform(const PropsParserContext &context, const RawValue &value, Transform &result)
{
if (value.hasType<std::string>()) {
parseUnprocessedTransformString((std::string)value, result);
} else {
parseProcessedTransform(context, value, result);
}
}
inline void fromRawValue(const PropsParserContext &context, const RawValue &value, Transform &result)
{
if (ReactNativeFeatureFlags_DO_NOT_USE::enableNativeCSSParsing()) {
parseUnprocessedTransform(context, value, result);
} else {
parseProcessedTransform(context, value, result);
}
}
inline void
parseProcessedTransformOrigin(const PropsParserContext & /*context*/, const RawValue &value, TransformOrigin &result)
{
if (!value.hasType<std::vector<RawValue>>()) {
result = {};
return;
}
auto origins = (std::vector<RawValue>)value;
if (origins.size() != 3) {
result = {};
return;
}
TransformOrigin transformOrigin;
for (size_t i = 0; i < 2; i++) {
auto origin = toValueUnit(origins[i]);
if (!origin) {
result = {};
return;
}
transformOrigin.xy[i] = origin;
}
if (!origins[2].hasType<Float>()) {
result = {};
return;
}
transformOrigin.z = (Float)origins[2];
result = transformOrigin;
}
inline void parseUnprocessedTransformOriginString(const std::string &value, TransformOrigin &result)
{
auto cssOrigin = parseCSSProperty<CSSTransformOrigin>(value);
if (!std::holds_alternative<CSSTransformOrigin>(cssOrigin)) {
result = {};
return;
}
const auto &origin = std::get<CSSTransformOrigin>(cssOrigin);
TransformOrigin transformOrigin;
auto x = cssLengthPercentageToValueUnit(origin.x);
auto y = cssLengthPercentageToValueUnit(origin.y);
if (!x || !y) {
result = {};
return;
}
transformOrigin.xy[0] = x;
transformOrigin.xy[1] = y;
if (origin.z.unit != CSSLengthUnit::Px) {
result = {};
return;
}
transformOrigin.z = origin.z.value;
result = transformOrigin;
}
inline void
parseUnprocessedTransformOrigin(const PropsParserContext &context, const RawValue &value, TransformOrigin &result)
{
if (value.hasType<std::string>()) {
parseUnprocessedTransformOriginString((std::string)value, result);
} else {
parseProcessedTransformOrigin(context, value, result);
}
}
inline void fromRawValue(const PropsParserContext &context, const RawValue &value, TransformOrigin &result)
{
if (ReactNativeFeatureFlags_DO_NOT_USE::enableNativeCSSParsing()) {
parseUnprocessedTransformOrigin(context, value, result);
} else {
parseProcessedTransformOrigin(context, value, result);
}
}
void fromRawValue(const PropsParserContext &context, const RawValue &value, TransformOrigin &result);
inline void fromRawValue(const PropsParserContext &context, const RawValue &value, PointerEventsMode &result)
{
@@ -379,10 +379,10 @@ TEST_F(NativeCSSConversionsTest, unprocessed_filter_objects_unknown_type) {
EXPECT_TRUE(filters.empty());
}
TEST(ConversionsTest, unprocessed_transform_css_string) {
TEST_F(NativeCSSConversionsTest, unprocessed_transform_css_string) {
RawValue value{folly::dynamic("rotate(45deg) scale(2) translateX(10px)")};
Transform result;
parseUnprocessedTransformString(
"rotate(45deg) scale(2) translateX(10px)", result);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, result);
EXPECT_EQ(result.operations.size(), 3);
@@ -405,9 +405,10 @@ TEST(ConversionsTest, unprocessed_transform_css_string) {
EXPECT_EQ(result.operations[2].y.value, 0.0f);
}
TEST(ConversionsTest, unprocessed_transform_css_translate_percent) {
TEST_F(NativeCSSConversionsTest, unprocessed_transform_css_translate_percent) {
RawValue value{folly::dynamic("translate(10px, 50%)")};
Transform result;
parseUnprocessedTransformString("translate(10px, 50%)", result);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, result);
EXPECT_EQ(result.operations.size(), 1);
EXPECT_EQ(result.operations[0].type, TransformOperationType::Translate);
@@ -417,27 +418,28 @@ TEST(ConversionsTest, unprocessed_transform_css_translate_percent) {
EXPECT_EQ(result.operations[0].y.unit, UnitType::Percent);
}
TEST(ConversionsTest, unprocessed_transform_css_perspective) {
TEST_F(NativeCSSConversionsTest, unprocessed_transform_css_perspective) {
RawValue value{folly::dynamic("perspective(500px)")};
Transform result;
parseUnprocessedTransformString("perspective(500px)", result);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, result);
EXPECT_EQ(result.operations.size(), 1);
EXPECT_EQ(result.operations[0].type, TransformOperationType::Perspective);
EXPECT_EQ(result.operations[0].x.value, 500.0f);
}
TEST(ConversionsTest, unprocessed_transform_css_invalid_string) {
TEST_F(NativeCSSConversionsTest, unprocessed_transform_css_invalid_string) {
RawValue value{folly::dynamic("not-a-transform")};
Transform result;
parseUnprocessedTransformString("not-a-transform", result);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, result);
EXPECT_TRUE(result.operations.empty());
}
TEST(ConversionsTest, unprocessed_transform_rawvalue_string) {
TEST_F(NativeCSSConversionsTest, unprocessed_transform_rawvalue_string) {
RawValue value{folly::dynamic("rotate(45deg) scale(2)")};
Transform result;
parseUnprocessedTransform(
PropsParserContext{-1, ContextContainer{}}, value, result);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, result);
EXPECT_EQ(result.operations.size(), 2);
EXPECT_EQ(result.operations[0].type, TransformOperationType::Rotate);
@@ -449,8 +451,7 @@ TEST(ConversionsTest, unprocessed_transform_rawvalue_array) {
folly::dynamic::object("rotate", "45deg"),
folly::dynamic::object("scale", 2))};
Transform result;
parseUnprocessedTransform(
PropsParserContext{-1, ContextContainer{}}, value, result);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, result);
EXPECT_EQ(result.operations.size(), 2);
EXPECT_EQ(result.operations[0].type, TransformOperationType::Rotate);
@@ -465,8 +466,7 @@ TEST(ConversionsTest, unprocessed_transform_rawvalue_matrix) {
folly::dynamic::array(
1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)))};
Transform result;
parseUnprocessedTransform(
PropsParserContext{-1, ContextContainer{}}, value, result);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, result);
EXPECT_EQ(result.operations.size(), 1);
EXPECT_EQ(result.operations[0].type, TransformOperationType::Arbitrary);
@@ -476,8 +476,7 @@ TEST(ConversionsTest, unprocessed_transform_rawvalue_translate_percent) {
RawValue value{
folly::dynamic::array(folly::dynamic::object("translateX", "50%"))};
Transform result;
parseUnprocessedTransform(
PropsParserContext{-1, ContextContainer{}}, value, result);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, result);
EXPECT_EQ(result.operations.size(), 1);
EXPECT_EQ(result.operations[0].type, TransformOperationType::Translate);
@@ -485,9 +484,10 @@ TEST(ConversionsTest, unprocessed_transform_rawvalue_translate_percent) {
EXPECT_EQ(result.operations[0].x.unit, UnitType::Percent);
}
TEST(ConversionsTest, unprocessed_transform_origin_css_top_left) {
TEST_F(NativeCSSConversionsTest, unprocessed_transform_origin_css_top_left) {
RawValue value{folly::dynamic("top left")};
TransformOrigin result;
parseUnprocessedTransformOriginString("top left", result);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, result);
EXPECT_EQ(result.xy[0].value, 0.0f);
EXPECT_EQ(result.xy[0].unit, UnitType::Percent);
@@ -496,9 +496,10 @@ TEST(ConversionsTest, unprocessed_transform_origin_css_top_left) {
EXPECT_EQ(result.z, 0.0f);
}
TEST(ConversionsTest, unprocessed_transform_origin_css_center) {
TEST_F(NativeCSSConversionsTest, unprocessed_transform_origin_css_center) {
RawValue value{folly::dynamic("center")};
TransformOrigin result;
parseUnprocessedTransformOriginString("center", result);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, result);
EXPECT_EQ(result.xy[0].value, 50.0f);
EXPECT_EQ(result.xy[0].unit, UnitType::Percent);
@@ -507,9 +508,12 @@ TEST(ConversionsTest, unprocessed_transform_origin_css_center) {
EXPECT_EQ(result.z, 0.0f);
}
TEST(ConversionsTest, unprocessed_transform_origin_css_right_bottom) {
TEST_F(
NativeCSSConversionsTest,
unprocessed_transform_origin_css_right_bottom) {
RawValue value{folly::dynamic("right bottom")};
TransformOrigin result;
parseUnprocessedTransformOriginString("right bottom", result);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, result);
EXPECT_EQ(result.xy[0].value, 100.0f);
EXPECT_EQ(result.xy[0].unit, UnitType::Percent);
@@ -518,9 +522,12 @@ TEST(ConversionsTest, unprocessed_transform_origin_css_right_bottom) {
EXPECT_EQ(result.z, 0.0f);
}
TEST(ConversionsTest, unprocessed_transform_origin_css_length_percent) {
TEST_F(
NativeCSSConversionsTest,
unprocessed_transform_origin_css_length_percent) {
RawValue value{folly::dynamic("10px 50%")};
TransformOrigin result;
parseUnprocessedTransformOriginString("10px 50%", result);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, result);
EXPECT_EQ(result.xy[0].value, 10.0f);
EXPECT_EQ(result.xy[0].unit, UnitType::Point);
@@ -533,8 +540,7 @@ TEST(ConversionsTest, unprocessed_transform_origin_processed_array) {
RawValue value{folly::dynamic::array("50%", "50%", 0)};
TransformOrigin result;
parseProcessedTransformOrigin(
PropsParserContext{-1, ContextContainer{}}, value, result);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, result);
EXPECT_EQ(result.xy[0].value, 50.0f);
EXPECT_EQ(result.xy[0].unit, UnitType::Percent);
@@ -543,11 +549,10 @@ TEST(ConversionsTest, unprocessed_transform_origin_processed_array) {
EXPECT_EQ(result.z, 0.0f);
}
TEST(ConversionsTest, unprocessed_transform_origin_rawvalue_string) {
TEST_F(NativeCSSConversionsTest, unprocessed_transform_origin_rawvalue_string) {
RawValue value{folly::dynamic("top left")};
TransformOrigin result;
parseUnprocessedTransformOrigin(
PropsParserContext{-1, ContextContainer{}}, value, result);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, result);
EXPECT_EQ(result.xy[0].value, 0.0f);
EXPECT_EQ(result.xy[0].unit, UnitType::Percent);
@@ -559,8 +564,7 @@ TEST(ConversionsTest, unprocessed_transform_origin_rawvalue_string) {
TEST(ConversionsTest, unprocessed_transform_origin_rawvalue_array) {
RawValue value{folly::dynamic::array(10, "50%", 5)};
TransformOrigin result;
parseUnprocessedTransformOrigin(
PropsParserContext{-1, ContextContainer{}}, value, result);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, result);
EXPECT_EQ(result.xy[0].value, 10.0f);
EXPECT_EQ(result.xy[0].unit, UnitType::Point);
@@ -569,11 +573,12 @@ TEST(ConversionsTest, unprocessed_transform_origin_rawvalue_array) {
EXPECT_EQ(result.z, 5.0f);
}
TEST(ConversionsTest, unprocessed_transform_origin_rawvalue_string_with_z) {
TEST_F(
NativeCSSConversionsTest,
unprocessed_transform_origin_rawvalue_string_with_z) {
RawValue value{folly::dynamic("center center 15px")};
TransformOrigin result;
parseUnprocessedTransformOrigin(
PropsParserContext{-1, ContextContainer{}}, value, result);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, result);
EXPECT_EQ(result.xy[0].value, 50.0f);
EXPECT_EQ(result.xy[0].unit, UnitType::Percent);
@@ -616,28 +621,30 @@ TEST(ConversionsTest, convert_aspect_ratio_float) {
EXPECT_EQ(result.unwrap(), 1.5f);
}
TEST(ConversionsTest, convert_aspect_ratio_ratio_string) {
// CSSRatio parses "16/9" as {numerator: 16, denominator: 9}
auto ratio = parseCSSProperty<CSSRatio>("16/9");
ASSERT_TRUE(std::holds_alternative<CSSRatio>(ratio));
auto r = std::get<CSSRatio>(ratio);
EXPECT_FALSE(r.isDegenerate());
EXPECT_NEAR(r.numerator / r.denominator, 16.0f / 9.0f, 0.001f);
TEST_F(NativeCSSConversionsTest, convert_aspect_ratio_ratio_string) {
RawValue value{folly::dynamic("16/9")};
auto result =
convertAspectRatio(PropsParserContext{-1, ContextContainer{}}, value);
ASSERT_FALSE(result.isUndefined());
EXPECT_NEAR(result.unwrap(), 16.0f / 9.0f, 0.001f);
}
TEST(ConversionsTest, convert_aspect_ratio_number_string) {
// CSSRatio parses "1.5" as {numerator: 1.5, denominator: 1.0}
auto ratio = parseCSSProperty<CSSRatio>("1.5");
ASSERT_TRUE(std::holds_alternative<CSSRatio>(ratio));
auto r = std::get<CSSRatio>(ratio);
EXPECT_FALSE(r.isDegenerate());
EXPECT_EQ(r.numerator / r.denominator, 1.5f);
TEST_F(NativeCSSConversionsTest, convert_aspect_ratio_number_string) {
RawValue value{folly::dynamic("1.5")};
auto result =
convertAspectRatio(PropsParserContext{-1, ContextContainer{}}, value);
ASSERT_FALSE(result.isUndefined());
EXPECT_EQ(result.unwrap(), 1.5f);
}
TEST(ConversionsTest, convert_aspect_ratio_degenerate) {
auto ratio = parseCSSProperty<CSSRatio>("0/0");
ASSERT_TRUE(std::holds_alternative<CSSRatio>(ratio));
EXPECT_TRUE(std::get<CSSRatio>(ratio).isDegenerate());
TEST_F(NativeCSSConversionsTest, convert_aspect_ratio_degenerate) {
RawValue value{folly::dynamic("0/0")};
auto result =
convertAspectRatio(PropsParserContext{-1, ContextContainer{}}, value);
EXPECT_TRUE(result.isUndefined());
}
TEST(ConversionsTest, float_optional_from_rawvalue_float) {
@@ -900,7 +900,6 @@ facebook::react::Size facebook::react::ModalHostViewScreenSize(void);
facebook::react::Size facebook::react::yogaMeassureToSize(int64_t value);
facebook::react::SurfaceId facebook::react::getNextRootViewTag() noexcept;
facebook::react::TurboModuleMethodValueKind facebook::react::getTurboModuleMethodValueKind(facebook::jsi::Runtime& rt, const facebook::jsi::Value* value);
facebook::react::ValueUnit facebook::react::cssLengthPercentageToValueUnit(const std::variant<facebook::react::CSSLength, facebook::react::CSSPercentage>& value);
facebook::react::ValueUnit facebook::react::toValueUnit(const facebook::react::RawValue& value);
facebook::yoga::FloatOptional facebook::react::convertAspectRatio(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value);
facebook::yoga::FloatOptional facebook::react::yogaOptionalFloatFromFloat(facebook::react::Float value);
@@ -948,10 +947,8 @@ std::optional<facebook::react::BlendMode> facebook::react::blendModeFromString(s
std::optional<facebook::react::FilterType> facebook::react::filterTypeFromString(std::string_view filterName);
std::optional<facebook::react::Float> facebook::react::coerceLength(const facebook::react::RawValue& value);
std::optional<facebook::react::Float> facebook::react::optionalFloatFromYogaValue(const facebook::yoga::Style::Length& length, std::optional<facebook::react::Float> base = {});
std::optional<facebook::react::Float> facebook::react::toRadians(const facebook::react::RawValue& value);
std::optional<facebook::react::FontVariant> facebook::react::fontVariantFromCSSFontVariant(facebook::react::CSSFontVariant cssVariant);
std::optional<facebook::react::Isolation> facebook::react::isolationFromString(std::string_view isolationSetting);
std::optional<facebook::react::TransformOperation> facebook::react::fromCSSTransformFunction(const facebook::react::CSSTransformFunction& cssTransform);
std::pair<facebook::react::Float, facebook::react::Float> facebook::react::calculateAnimationProgress(uint64_t now, const facebook::react::LayoutAnimation& animation, const facebook::react::AnimationConfig& mutationConfig);
std::string facebook::react::base64Encode(const std::string_view s);
std::string facebook::react::componentNameByReactViewName(std::string viewName);
@@ -1144,16 +1141,10 @@ void facebook::react::g_setNativeAnimatedNowTimestampFunction(facebook::react::T
void facebook::react::handleJSError(facebook::jsi::Runtime& runtime, const facebook::jsi::JSError& error, bool isFatal);
void facebook::react::parseProcessedBackgroundImage(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseProcessedFontVariant(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::FontVariant& result);
void facebook::react::parseProcessedTransform(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::Transform& result);
void facebook::react::parseProcessedTransformOrigin(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedBackgroundImageList(const facebook::react::PropsParserContext& context, const std::vector<facebook::react::RawValue>& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseUnprocessedBackgroundImageString(const std::string& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseUnprocessedFontVariant(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::FontVariant& result);
void facebook::react::parseUnprocessedFontVariantString(const std::string& value, facebook::react::FontVariant& result);
void facebook::react::parseUnprocessedTransform(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::Transform& result);
void facebook::react::parseUnprocessedTransformOrigin(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedTransformOriginString(const std::string& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedTransformString(const std::string& value, facebook::react::Transform& result);
void facebook::react::reactAndroidLoggingHook(const std::string& message, unsigned int logLevel);
void facebook::react::registerCxxModuleToGlobalModuleMap(std::string name, std::function<std::shared_ptr<facebook::react::TurboModule>(std::shared_ptr<facebook::react::CallInvoker> jsInvoker)> moduleProviderFunc);
void facebook::react::serializeTransformAxis(const facebook::react::TransformOperation& operation, const std::string& operationName, float defaultValue, folly::dynamic& resultTranslateArray);
@@ -899,7 +899,6 @@ facebook::react::Size facebook::react::ModalHostViewScreenSize(void);
facebook::react::Size facebook::react::yogaMeassureToSize(int64_t value);
facebook::react::SurfaceId facebook::react::getNextRootViewTag() noexcept;
facebook::react::TurboModuleMethodValueKind facebook::react::getTurboModuleMethodValueKind(facebook::jsi::Runtime& rt, const facebook::jsi::Value* value);
facebook::react::ValueUnit facebook::react::cssLengthPercentageToValueUnit(const std::variant<facebook::react::CSSLength, facebook::react::CSSPercentage>& value);
facebook::react::ValueUnit facebook::react::toValueUnit(const facebook::react::RawValue& value);
facebook::yoga::FloatOptional facebook::react::convertAspectRatio(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value);
facebook::yoga::FloatOptional facebook::react::yogaOptionalFloatFromFloat(facebook::react::Float value);
@@ -946,10 +945,8 @@ std::optional<facebook::react::BlendMode> facebook::react::blendModeFromString(s
std::optional<facebook::react::FilterType> facebook::react::filterTypeFromString(std::string_view filterName);
std::optional<facebook::react::Float> facebook::react::coerceLength(const facebook::react::RawValue& value);
std::optional<facebook::react::Float> facebook::react::optionalFloatFromYogaValue(const facebook::yoga::Style::Length& length, std::optional<facebook::react::Float> base = {});
std::optional<facebook::react::Float> facebook::react::toRadians(const facebook::react::RawValue& value);
std::optional<facebook::react::FontVariant> facebook::react::fontVariantFromCSSFontVariant(facebook::react::CSSFontVariant cssVariant);
std::optional<facebook::react::Isolation> facebook::react::isolationFromString(std::string_view isolationSetting);
std::optional<facebook::react::TransformOperation> facebook::react::fromCSSTransformFunction(const facebook::react::CSSTransformFunction& cssTransform);
std::pair<facebook::react::Float, facebook::react::Float> facebook::react::calculateAnimationProgress(uint64_t now, const facebook::react::LayoutAnimation& animation, const facebook::react::AnimationConfig& mutationConfig);
std::string facebook::react::base64Encode(const std::string_view s);
std::string facebook::react::componentNameByReactViewName(std::string viewName);
@@ -1140,16 +1137,10 @@ void facebook::react::g_setNativeAnimatedNowTimestampFunction(facebook::react::T
void facebook::react::handleJSError(facebook::jsi::Runtime& runtime, const facebook::jsi::JSError& error, bool isFatal);
void facebook::react::parseProcessedBackgroundImage(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseProcessedFontVariant(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::FontVariant& result);
void facebook::react::parseProcessedTransform(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::Transform& result);
void facebook::react::parseProcessedTransformOrigin(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedBackgroundImageList(const facebook::react::PropsParserContext& context, const std::vector<facebook::react::RawValue>& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseUnprocessedBackgroundImageString(const std::string& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseUnprocessedFontVariant(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::FontVariant& result);
void facebook::react::parseUnprocessedFontVariantString(const std::string& value, facebook::react::FontVariant& result);
void facebook::react::parseUnprocessedTransform(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::Transform& result);
void facebook::react::parseUnprocessedTransformOrigin(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedTransformOriginString(const std::string& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedTransformString(const std::string& value, facebook::react::Transform& result);
void facebook::react::reactAndroidLoggingHook(const std::string& message, unsigned int logLevel);
void facebook::react::registerCxxModuleToGlobalModuleMap(std::string name, std::function<std::shared_ptr<facebook::react::TurboModule>(std::shared_ptr<facebook::react::CallInvoker> jsInvoker)> moduleProviderFunc);
void facebook::react::serializeTransformAxis(const facebook::react::TransformOperation& operation, const std::string& operationName, float defaultValue, folly::dynamic& resultTranslateArray);
@@ -900,7 +900,6 @@ facebook::react::Size facebook::react::ModalHostViewScreenSize(void);
facebook::react::Size facebook::react::yogaMeassureToSize(int64_t value);
facebook::react::SurfaceId facebook::react::getNextRootViewTag() noexcept;
facebook::react::TurboModuleMethodValueKind facebook::react::getTurboModuleMethodValueKind(facebook::jsi::Runtime& rt, const facebook::jsi::Value* value);
facebook::react::ValueUnit facebook::react::cssLengthPercentageToValueUnit(const std::variant<facebook::react::CSSLength, facebook::react::CSSPercentage>& value);
facebook::react::ValueUnit facebook::react::toValueUnit(const facebook::react::RawValue& value);
facebook::yoga::FloatOptional facebook::react::convertAspectRatio(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value);
facebook::yoga::FloatOptional facebook::react::yogaOptionalFloatFromFloat(facebook::react::Float value);
@@ -948,10 +947,8 @@ std::optional<facebook::react::BlendMode> facebook::react::blendModeFromString(s
std::optional<facebook::react::FilterType> facebook::react::filterTypeFromString(std::string_view filterName);
std::optional<facebook::react::Float> facebook::react::coerceLength(const facebook::react::RawValue& value);
std::optional<facebook::react::Float> facebook::react::optionalFloatFromYogaValue(const facebook::yoga::Style::Length& length, std::optional<facebook::react::Float> base = {});
std::optional<facebook::react::Float> facebook::react::toRadians(const facebook::react::RawValue& value);
std::optional<facebook::react::FontVariant> facebook::react::fontVariantFromCSSFontVariant(facebook::react::CSSFontVariant cssVariant);
std::optional<facebook::react::Isolation> facebook::react::isolationFromString(std::string_view isolationSetting);
std::optional<facebook::react::TransformOperation> facebook::react::fromCSSTransformFunction(const facebook::react::CSSTransformFunction& cssTransform);
std::pair<facebook::react::Float, facebook::react::Float> facebook::react::calculateAnimationProgress(uint64_t now, const facebook::react::LayoutAnimation& animation, const facebook::react::AnimationConfig& mutationConfig);
std::string facebook::react::base64Encode(const std::string_view s);
std::string facebook::react::componentNameByReactViewName(std::string viewName);
@@ -1144,16 +1141,10 @@ void facebook::react::g_setNativeAnimatedNowTimestampFunction(facebook::react::T
void facebook::react::handleJSError(facebook::jsi::Runtime& runtime, const facebook::jsi::JSError& error, bool isFatal);
void facebook::react::parseProcessedBackgroundImage(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseProcessedFontVariant(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::FontVariant& result);
void facebook::react::parseProcessedTransform(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::Transform& result);
void facebook::react::parseProcessedTransformOrigin(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedBackgroundImageList(const facebook::react::PropsParserContext& context, const std::vector<facebook::react::RawValue>& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseUnprocessedBackgroundImageString(const std::string& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseUnprocessedFontVariant(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::FontVariant& result);
void facebook::react::parseUnprocessedFontVariantString(const std::string& value, facebook::react::FontVariant& result);
void facebook::react::parseUnprocessedTransform(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::Transform& result);
void facebook::react::parseUnprocessedTransformOrigin(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedTransformOriginString(const std::string& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedTransformString(const std::string& value, facebook::react::Transform& result);
void facebook::react::reactAndroidLoggingHook(const std::string& message, unsigned int logLevel);
void facebook::react::registerCxxModuleToGlobalModuleMap(std::string name, std::function<std::shared_ptr<facebook::react::TurboModule>(std::shared_ptr<facebook::react::CallInvoker> jsInvoker)> moduleProviderFunc);
void facebook::react::serializeTransformAxis(const facebook::react::TransformOperation& operation, const std::string& operationName, float defaultValue, folly::dynamic& resultTranslateArray);
@@ -3714,7 +3714,6 @@ facebook::react::Size facebook::react::ModalHostViewScreenSize(void);
facebook::react::Size facebook::react::yogaMeassureToSize(int64_t value);
facebook::react::SurfaceId facebook::react::getNextRootViewTag() noexcept;
facebook::react::TurboModuleMethodValueKind facebook::react::getTurboModuleMethodValueKind(facebook::jsi::Runtime& rt, const facebook::jsi::Value* value);
facebook::react::ValueUnit facebook::react::cssLengthPercentageToValueUnit(const std::variant<facebook::react::CSSLength, facebook::react::CSSPercentage>& value);
facebook::react::ValueUnit facebook::react::toValueUnit(const facebook::react::RawValue& value);
facebook::yoga::FloatOptional facebook::react::convertAspectRatio(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value);
facebook::yoga::FloatOptional facebook::react::yogaOptionalFloatFromFloat(facebook::react::Float value);
@@ -3746,10 +3745,8 @@ std::optional<facebook::react::BlendMode> facebook::react::blendModeFromString(s
std::optional<facebook::react::FilterType> facebook::react::filterTypeFromString(std::string_view filterName);
std::optional<facebook::react::Float> facebook::react::coerceLength(const facebook::react::RawValue& value);
std::optional<facebook::react::Float> facebook::react::optionalFloatFromYogaValue(const facebook::yoga::Style::Length& length, std::optional<facebook::react::Float> base = {});
std::optional<facebook::react::Float> facebook::react::toRadians(const facebook::react::RawValue& value);
std::optional<facebook::react::FontVariant> facebook::react::fontVariantFromCSSFontVariant(facebook::react::CSSFontVariant cssVariant);
std::optional<facebook::react::Isolation> facebook::react::isolationFromString(std::string_view isolationSetting);
std::optional<facebook::react::TransformOperation> facebook::react::fromCSSTransformFunction(const facebook::react::CSSTransformFunction& cssTransform);
std::pair<facebook::react::Float, facebook::react::Float> facebook::react::calculateAnimationProgress(uint64_t now, const facebook::react::LayoutAnimation& animation, const facebook::react::AnimationConfig& mutationConfig);
std::string facebook::react::base64Encode(const std::string_view s);
std::string facebook::react::componentNameByReactViewName(std::string viewName);
@@ -3944,16 +3941,10 @@ void facebook::react::handleJSError(facebook::jsi::Runtime& runtime, const faceb
void facebook::react::installLegacyUIManagerConstantsProviderBinding(facebook::jsi::Runtime& runtime);
void facebook::react::parseProcessedBackgroundImage(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseProcessedFontVariant(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::FontVariant& result);
void facebook::react::parseProcessedTransform(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::Transform& result);
void facebook::react::parseProcessedTransformOrigin(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedBackgroundImageList(const facebook::react::PropsParserContext& context, const std::vector<facebook::react::RawValue>& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseUnprocessedBackgroundImageString(const std::string& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseUnprocessedFontVariant(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::FontVariant& result);
void facebook::react::parseUnprocessedFontVariantString(const std::string& value, facebook::react::FontVariant& result);
void facebook::react::parseUnprocessedTransform(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::Transform& result);
void facebook::react::parseUnprocessedTransformOrigin(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedTransformOriginString(const std::string& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedTransformString(const std::string& value, facebook::react::Transform& result);
void facebook::react::registerCxxModuleToGlobalModuleMap(std::string name, std::function<std::shared_ptr<facebook::react::TurboModule>(std::shared_ptr<facebook::react::CallInvoker> jsInvoker)> moduleProviderFunc);
void facebook::react::serializeTransformAxis(const facebook::react::TransformOperation& operation, const std::string& operationName, float defaultValue, folly::dynamic& resultTranslateArray);
void facebook::react::serializeTransformOperationValue(const std::string& operationName, const facebook::react::ValueUnit& valueUnit, folly::dynamic& resultArray);
@@ -3705,7 +3705,6 @@ facebook::react::Size facebook::react::ModalHostViewScreenSize(void);
facebook::react::Size facebook::react::yogaMeassureToSize(int64_t value);
facebook::react::SurfaceId facebook::react::getNextRootViewTag() noexcept;
facebook::react::TurboModuleMethodValueKind facebook::react::getTurboModuleMethodValueKind(facebook::jsi::Runtime& rt, const facebook::jsi::Value* value);
facebook::react::ValueUnit facebook::react::cssLengthPercentageToValueUnit(const std::variant<facebook::react::CSSLength, facebook::react::CSSPercentage>& value);
facebook::react::ValueUnit facebook::react::toValueUnit(const facebook::react::RawValue& value);
facebook::yoga::FloatOptional facebook::react::convertAspectRatio(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value);
facebook::yoga::FloatOptional facebook::react::yogaOptionalFloatFromFloat(facebook::react::Float value);
@@ -3736,10 +3735,8 @@ std::optional<facebook::react::BlendMode> facebook::react::blendModeFromString(s
std::optional<facebook::react::FilterType> facebook::react::filterTypeFromString(std::string_view filterName);
std::optional<facebook::react::Float> facebook::react::coerceLength(const facebook::react::RawValue& value);
std::optional<facebook::react::Float> facebook::react::optionalFloatFromYogaValue(const facebook::yoga::Style::Length& length, std::optional<facebook::react::Float> base = {});
std::optional<facebook::react::Float> facebook::react::toRadians(const facebook::react::RawValue& value);
std::optional<facebook::react::FontVariant> facebook::react::fontVariantFromCSSFontVariant(facebook::react::CSSFontVariant cssVariant);
std::optional<facebook::react::Isolation> facebook::react::isolationFromString(std::string_view isolationSetting);
std::optional<facebook::react::TransformOperation> facebook::react::fromCSSTransformFunction(const facebook::react::CSSTransformFunction& cssTransform);
std::pair<facebook::react::Float, facebook::react::Float> facebook::react::calculateAnimationProgress(uint64_t now, const facebook::react::LayoutAnimation& animation, const facebook::react::AnimationConfig& mutationConfig);
std::string facebook::react::base64Encode(const std::string_view s);
std::string facebook::react::componentNameByReactViewName(std::string viewName);
@@ -3933,16 +3930,10 @@ void facebook::react::handleJSError(facebook::jsi::Runtime& runtime, const faceb
void facebook::react::installLegacyUIManagerConstantsProviderBinding(facebook::jsi::Runtime& runtime);
void facebook::react::parseProcessedBackgroundImage(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseProcessedFontVariant(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::FontVariant& result);
void facebook::react::parseProcessedTransform(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::Transform& result);
void facebook::react::parseProcessedTransformOrigin(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedBackgroundImageList(const facebook::react::PropsParserContext& context, const std::vector<facebook::react::RawValue>& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseUnprocessedBackgroundImageString(const std::string& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseUnprocessedFontVariant(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::FontVariant& result);
void facebook::react::parseUnprocessedFontVariantString(const std::string& value, facebook::react::FontVariant& result);
void facebook::react::parseUnprocessedTransform(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::Transform& result);
void facebook::react::parseUnprocessedTransformOrigin(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedTransformOriginString(const std::string& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedTransformString(const std::string& value, facebook::react::Transform& result);
void facebook::react::registerCxxModuleToGlobalModuleMap(std::string name, std::function<std::shared_ptr<facebook::react::TurboModule>(std::shared_ptr<facebook::react::CallInvoker> jsInvoker)> moduleProviderFunc);
void facebook::react::serializeTransformAxis(const facebook::react::TransformOperation& operation, const std::string& operationName, float defaultValue, folly::dynamic& resultTranslateArray);
void facebook::react::serializeTransformOperationValue(const std::string& operationName, const facebook::react::ValueUnit& valueUnit, folly::dynamic& resultArray);
@@ -3714,7 +3714,6 @@ facebook::react::Size facebook::react::ModalHostViewScreenSize(void);
facebook::react::Size facebook::react::yogaMeassureToSize(int64_t value);
facebook::react::SurfaceId facebook::react::getNextRootViewTag() noexcept;
facebook::react::TurboModuleMethodValueKind facebook::react::getTurboModuleMethodValueKind(facebook::jsi::Runtime& rt, const facebook::jsi::Value* value);
facebook::react::ValueUnit facebook::react::cssLengthPercentageToValueUnit(const std::variant<facebook::react::CSSLength, facebook::react::CSSPercentage>& value);
facebook::react::ValueUnit facebook::react::toValueUnit(const facebook::react::RawValue& value);
facebook::yoga::FloatOptional facebook::react::convertAspectRatio(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value);
facebook::yoga::FloatOptional facebook::react::yogaOptionalFloatFromFloat(facebook::react::Float value);
@@ -3746,10 +3745,8 @@ std::optional<facebook::react::BlendMode> facebook::react::blendModeFromString(s
std::optional<facebook::react::FilterType> facebook::react::filterTypeFromString(std::string_view filterName);
std::optional<facebook::react::Float> facebook::react::coerceLength(const facebook::react::RawValue& value);
std::optional<facebook::react::Float> facebook::react::optionalFloatFromYogaValue(const facebook::yoga::Style::Length& length, std::optional<facebook::react::Float> base = {});
std::optional<facebook::react::Float> facebook::react::toRadians(const facebook::react::RawValue& value);
std::optional<facebook::react::FontVariant> facebook::react::fontVariantFromCSSFontVariant(facebook::react::CSSFontVariant cssVariant);
std::optional<facebook::react::Isolation> facebook::react::isolationFromString(std::string_view isolationSetting);
std::optional<facebook::react::TransformOperation> facebook::react::fromCSSTransformFunction(const facebook::react::CSSTransformFunction& cssTransform);
std::pair<facebook::react::Float, facebook::react::Float> facebook::react::calculateAnimationProgress(uint64_t now, const facebook::react::LayoutAnimation& animation, const facebook::react::AnimationConfig& mutationConfig);
std::string facebook::react::base64Encode(const std::string_view s);
std::string facebook::react::componentNameByReactViewName(std::string viewName);
@@ -3944,16 +3941,10 @@ void facebook::react::handleJSError(facebook::jsi::Runtime& runtime, const faceb
void facebook::react::installLegacyUIManagerConstantsProviderBinding(facebook::jsi::Runtime& runtime);
void facebook::react::parseProcessedBackgroundImage(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseProcessedFontVariant(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::FontVariant& result);
void facebook::react::parseProcessedTransform(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::Transform& result);
void facebook::react::parseProcessedTransformOrigin(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedBackgroundImageList(const facebook::react::PropsParserContext& context, const std::vector<facebook::react::RawValue>& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseUnprocessedBackgroundImageString(const std::string& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseUnprocessedFontVariant(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::FontVariant& result);
void facebook::react::parseUnprocessedFontVariantString(const std::string& value, facebook::react::FontVariant& result);
void facebook::react::parseUnprocessedTransform(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::Transform& result);
void facebook::react::parseUnprocessedTransformOrigin(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedTransformOriginString(const std::string& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedTransformString(const std::string& value, facebook::react::Transform& result);
void facebook::react::registerCxxModuleToGlobalModuleMap(std::string name, std::function<std::shared_ptr<facebook::react::TurboModule>(std::shared_ptr<facebook::react::CallInvoker> jsInvoker)> moduleProviderFunc);
void facebook::react::serializeTransformAxis(const facebook::react::TransformOperation& operation, const std::string& operationName, float defaultValue, folly::dynamic& resultTranslateArray);
void facebook::react::serializeTransformOperationValue(const std::string& operationName, const facebook::react::ValueUnit& valueUnit, folly::dynamic& resultArray);
@@ -494,7 +494,6 @@ facebook::react::Size facebook::react::ModalHostViewScreenSize(void);
facebook::react::Size facebook::react::yogaMeassureToSize(int64_t value);
facebook::react::SurfaceId facebook::react::getNextRootViewTag() noexcept;
facebook::react::TurboModuleMethodValueKind facebook::react::getTurboModuleMethodValueKind(facebook::jsi::Runtime& rt, const facebook::jsi::Value* value);
facebook::react::ValueUnit facebook::react::cssLengthPercentageToValueUnit(const std::variant<facebook::react::CSSLength, facebook::react::CSSPercentage>& value);
facebook::react::ValueUnit facebook::react::toValueUnit(const facebook::react::RawValue& value);
facebook::yoga::FloatOptional facebook::react::convertAspectRatio(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value);
facebook::yoga::FloatOptional facebook::react::yogaOptionalFloatFromFloat(Float value);
@@ -518,12 +517,10 @@ size_t facebook::react::textAttributesHashLayoutWise(const facebook::react::Text
std::function<void(folly::dynamic)> facebook::react::makeCallback(std::weak_ptr<facebook::react::Instance> instance, const folly::dynamic& callbackId);
std::optional<Float> facebook::react::coerceLength(const facebook::react::RawValue& value);
std::optional<Float> facebook::react::optionalFloatFromYogaValue(const facebook::yoga::Style::Length& length, std::optional<Float> base = {});
std::optional<Float> facebook::react::toRadians(const facebook::react::RawValue& value);
std::optional<facebook::react::BlendMode> facebook::react::blendModeFromString(std::string_view blendModeName);
std::optional<facebook::react::FilterType> facebook::react::filterTypeFromString(std::string_view filterName);
std::optional<facebook::react::FontVariant> facebook::react::fontVariantFromCSSFontVariant(facebook::react::CSSFontVariant cssVariant);
std::optional<facebook::react::Isolation> facebook::react::isolationFromString(std::string_view isolationSetting);
std::optional<facebook::react::TransformOperation> facebook::react::fromCSSTransformFunction(const facebook::react::CSSTransformFunction& cssTransform);
std::pair<Float, Float> facebook::react::calculateAnimationProgress(uint64_t now, const facebook::react::LayoutAnimation& animation, const facebook::react::AnimationConfig& mutationConfig);
std::string facebook::react::base64Encode(const std::string_view s);
std::string facebook::react::componentNameByReactViewName(std::string viewName);
@@ -704,16 +701,10 @@ void facebook::react::g_setNativeAnimatedNowTimestampFunction(facebook::react::T
void facebook::react::handleJSError(facebook::jsi::Runtime& runtime, const facebook::jsi::JSError& error, bool isFatal);
void facebook::react::parseProcessedBackgroundImage(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseProcessedFontVariant(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::FontVariant& result);
void facebook::react::parseProcessedTransform(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::Transform& result);
void facebook::react::parseProcessedTransformOrigin(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedBackgroundImageList(const facebook::react::PropsParserContext& context, const std::vector<facebook::react::RawValue>& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseUnprocessedBackgroundImageString(const std::string& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseUnprocessedFontVariant(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::FontVariant& result);
void facebook::react::parseUnprocessedFontVariantString(const std::string& value, facebook::react::FontVariant& result);
void facebook::react::parseUnprocessedTransform(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::Transform& result);
void facebook::react::parseUnprocessedTransformOrigin(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedTransformOriginString(const std::string& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedTransformString(const std::string& value, facebook::react::Transform& result);
void facebook::react::registerCxxModuleToGlobalModuleMap(std::string name, std::function<std::shared_ptr<facebook::react::TurboModule>(std::shared_ptr<facebook::react::CallInvoker> jsInvoker)> moduleProviderFunc);
void facebook::react::serializeTransformAxis(const facebook::react::TransformOperation& operation, const std::string& operationName, float defaultValue, folly::dynamic& resultTranslateArray);
void facebook::react::serializeTransformOperationValue(const std::string& operationName, const facebook::react::ValueUnit& valueUnit, folly::dynamic& resultArray);
@@ -493,7 +493,6 @@ facebook::react::Size facebook::react::ModalHostViewScreenSize(void);
facebook::react::Size facebook::react::yogaMeassureToSize(int64_t value);
facebook::react::SurfaceId facebook::react::getNextRootViewTag() noexcept;
facebook::react::TurboModuleMethodValueKind facebook::react::getTurboModuleMethodValueKind(facebook::jsi::Runtime& rt, const facebook::jsi::Value* value);
facebook::react::ValueUnit facebook::react::cssLengthPercentageToValueUnit(const std::variant<facebook::react::CSSLength, facebook::react::CSSPercentage>& value);
facebook::react::ValueUnit facebook::react::toValueUnit(const facebook::react::RawValue& value);
facebook::yoga::FloatOptional facebook::react::convertAspectRatio(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value);
facebook::yoga::FloatOptional facebook::react::yogaOptionalFloatFromFloat(Float value);
@@ -516,12 +515,10 @@ size_t facebook::react::attributedStringHashLayoutWise(const facebook::react::At
size_t facebook::react::textAttributesHashLayoutWise(const facebook::react::TextAttributes& textAttributes);
std::optional<Float> facebook::react::coerceLength(const facebook::react::RawValue& value);
std::optional<Float> facebook::react::optionalFloatFromYogaValue(const facebook::yoga::Style::Length& length, std::optional<Float> base = {});
std::optional<Float> facebook::react::toRadians(const facebook::react::RawValue& value);
std::optional<facebook::react::BlendMode> facebook::react::blendModeFromString(std::string_view blendModeName);
std::optional<facebook::react::FilterType> facebook::react::filterTypeFromString(std::string_view filterName);
std::optional<facebook::react::FontVariant> facebook::react::fontVariantFromCSSFontVariant(facebook::react::CSSFontVariant cssVariant);
std::optional<facebook::react::Isolation> facebook::react::isolationFromString(std::string_view isolationSetting);
std::optional<facebook::react::TransformOperation> facebook::react::fromCSSTransformFunction(const facebook::react::CSSTransformFunction& cssTransform);
std::pair<Float, Float> facebook::react::calculateAnimationProgress(uint64_t now, const facebook::react::LayoutAnimation& animation, const facebook::react::AnimationConfig& mutationConfig);
std::string facebook::react::base64Encode(const std::string_view s);
std::string facebook::react::componentNameByReactViewName(std::string viewName);
@@ -701,16 +698,10 @@ void facebook::react::g_setNativeAnimatedNowTimestampFunction(facebook::react::T
void facebook::react::handleJSError(facebook::jsi::Runtime& runtime, const facebook::jsi::JSError& error, bool isFatal);
void facebook::react::parseProcessedBackgroundImage(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseProcessedFontVariant(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::FontVariant& result);
void facebook::react::parseProcessedTransform(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::Transform& result);
void facebook::react::parseProcessedTransformOrigin(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedBackgroundImageList(const facebook::react::PropsParserContext& context, const std::vector<facebook::react::RawValue>& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseUnprocessedBackgroundImageString(const std::string& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseUnprocessedFontVariant(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::FontVariant& result);
void facebook::react::parseUnprocessedFontVariantString(const std::string& value, facebook::react::FontVariant& result);
void facebook::react::parseUnprocessedTransform(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::Transform& result);
void facebook::react::parseUnprocessedTransformOrigin(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedTransformOriginString(const std::string& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedTransformString(const std::string& value, facebook::react::Transform& result);
void facebook::react::registerCxxModuleToGlobalModuleMap(std::string name, std::function<std::shared_ptr<facebook::react::TurboModule>(std::shared_ptr<facebook::react::CallInvoker> jsInvoker)> moduleProviderFunc);
void facebook::react::serializeTransformAxis(const facebook::react::TransformOperation& operation, const std::string& operationName, float defaultValue, folly::dynamic& resultTranslateArray);
void facebook::react::serializeTransformOperationValue(const std::string& operationName, const facebook::react::ValueUnit& valueUnit, folly::dynamic& resultArray);
@@ -494,7 +494,6 @@ facebook::react::Size facebook::react::ModalHostViewScreenSize(void);
facebook::react::Size facebook::react::yogaMeassureToSize(int64_t value);
facebook::react::SurfaceId facebook::react::getNextRootViewTag() noexcept;
facebook::react::TurboModuleMethodValueKind facebook::react::getTurboModuleMethodValueKind(facebook::jsi::Runtime& rt, const facebook::jsi::Value* value);
facebook::react::ValueUnit facebook::react::cssLengthPercentageToValueUnit(const std::variant<facebook::react::CSSLength, facebook::react::CSSPercentage>& value);
facebook::react::ValueUnit facebook::react::toValueUnit(const facebook::react::RawValue& value);
facebook::yoga::FloatOptional facebook::react::convertAspectRatio(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value);
facebook::yoga::FloatOptional facebook::react::yogaOptionalFloatFromFloat(Float value);
@@ -518,12 +517,10 @@ size_t facebook::react::textAttributesHashLayoutWise(const facebook::react::Text
std::function<void(folly::dynamic)> facebook::react::makeCallback(std::weak_ptr<facebook::react::Instance> instance, const folly::dynamic& callbackId);
std::optional<Float> facebook::react::coerceLength(const facebook::react::RawValue& value);
std::optional<Float> facebook::react::optionalFloatFromYogaValue(const facebook::yoga::Style::Length& length, std::optional<Float> base = {});
std::optional<Float> facebook::react::toRadians(const facebook::react::RawValue& value);
std::optional<facebook::react::BlendMode> facebook::react::blendModeFromString(std::string_view blendModeName);
std::optional<facebook::react::FilterType> facebook::react::filterTypeFromString(std::string_view filterName);
std::optional<facebook::react::FontVariant> facebook::react::fontVariantFromCSSFontVariant(facebook::react::CSSFontVariant cssVariant);
std::optional<facebook::react::Isolation> facebook::react::isolationFromString(std::string_view isolationSetting);
std::optional<facebook::react::TransformOperation> facebook::react::fromCSSTransformFunction(const facebook::react::CSSTransformFunction& cssTransform);
std::pair<Float, Float> facebook::react::calculateAnimationProgress(uint64_t now, const facebook::react::LayoutAnimation& animation, const facebook::react::AnimationConfig& mutationConfig);
std::string facebook::react::base64Encode(const std::string_view s);
std::string facebook::react::componentNameByReactViewName(std::string viewName);
@@ -704,16 +701,10 @@ void facebook::react::g_setNativeAnimatedNowTimestampFunction(facebook::react::T
void facebook::react::handleJSError(facebook::jsi::Runtime& runtime, const facebook::jsi::JSError& error, bool isFatal);
void facebook::react::parseProcessedBackgroundImage(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseProcessedFontVariant(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::FontVariant& result);
void facebook::react::parseProcessedTransform(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::Transform& result);
void facebook::react::parseProcessedTransformOrigin(const facebook::react::PropsParserContext&, const facebook::react::RawValue& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedBackgroundImageList(const facebook::react::PropsParserContext& context, const std::vector<facebook::react::RawValue>& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseUnprocessedBackgroundImageString(const std::string& value, std::vector<facebook::react::BackgroundImage>& result);
void facebook::react::parseUnprocessedFontVariant(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::FontVariant& result);
void facebook::react::parseUnprocessedFontVariantString(const std::string& value, facebook::react::FontVariant& result);
void facebook::react::parseUnprocessedTransform(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::Transform& result);
void facebook::react::parseUnprocessedTransformOrigin(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedTransformOriginString(const std::string& value, facebook::react::TransformOrigin& result);
void facebook::react::parseUnprocessedTransformString(const std::string& value, facebook::react::Transform& result);
void facebook::react::registerCxxModuleToGlobalModuleMap(std::string name, std::function<std::shared_ptr<facebook::react::TurboModule>(std::shared_ptr<facebook::react::CallInvoker> jsInvoker)> moduleProviderFunc);
void facebook::react::serializeTransformAxis(const facebook::react::TransformOperation& operation, const std::string& operationName, float defaultValue, folly::dynamic& resultTranslateArray);
void facebook::react::serializeTransformOperationValue(const std::string& operationName, const facebook::react::ValueUnit& valueUnit, folly::dynamic& resultArray);