Move leaf View parsers out of headers (#58785)

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

Move View CSS parsing implementation details for color and length coercion, box shadows, and filters from exported headers into compiled source files. Keep only the supported `coerceColor`, `coerceLength`, and `fromRawValue` declarations in public headers while preserving 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 the public entry points, and regenerate the C++ API snapshots to remove private helper declarations.

Changelog: [Internal]

Reviewed By: javache

Differential Revision: D119507169

fbshipit-source-id: 9bfafda0fc1c9f8c7f7e49ac35c96f97a823ad05
This commit is contained in:
Dawid Małecki authored and meta-codesync[bot] committed 2026-10-02 09:45:27 -07:00
1 parent 357b6998c4
commit 77bcf48575
17 files changed
+851 -867

No files matched your search

@@ -438,20 +438,32 @@ void fromCSSColorStop(
// first stop with start position
colorStops.push_back(
ColorStop{
.color = fromCSSColor(colorStop.color),
.color = colorFromRGBA(
colorStop.color.r,
colorStop.color.g,
colorStop.color.b,
colorStop.color.a),
.position = convertLengthPercentageToValueUnit(
*colorStop.startPosition)});
// second stop with end position (same color)
colorStops.push_back(
ColorStop{
.color = fromCSSColor(colorStop.color),
.color = colorFromRGBA(
colorStop.color.r,
colorStop.color.g,
colorStop.color.b,
colorStop.color.a),
.position =
convertLengthPercentageToValueUnit(*colorStop.endPosition)});
} else {
// single color stop
ColorStop stop;
stop.color = fromCSSColor(colorStop.color);
stop.color = colorFromRGBA(
colorStop.color.r,
colorStop.color.g,
colorStop.color.b,
colorStop.color.a);
// handle start position if present
if (colorStop.startPosition.has_value()) {
@@ -0,0 +1,281 @@
/*
* 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 "BoxShadowPropsConversions.h"
#include <react/debug/react_native_expect.h>
#include <react/featureflags/ReactNativeFeatureFlags.h>
#include <react/renderer/components/view/CSSConversions.h>
#include <react/renderer/css/CSSShadow.h>
#include <react/renderer/css/CSSValueParser.h>
#include <react/renderer/graphics/PlatformColorParser.h>
#include <optional>
#include <string>
#include <unordered_map>
namespace facebook::react {
namespace {
void parseProcessedBoxShadow(
const PropsParserContext& context,
const RawValue& value,
std::vector<BoxShadow>& result) {
react_native_expect(value.hasType<std::vector<RawValue>>());
if (!value.hasType<std::vector<RawValue>>()) {
result = {};
return;
}
std::vector<BoxShadow> boxShadows{};
auto rawBoxShadows = static_cast<std::vector<RawValue>>(value);
for (const auto& rawBoxShadow : rawBoxShadows) {
bool isMap =
rawBoxShadow.hasType<std::unordered_map<std::string, RawValue>>();
react_native_expect(isMap);
if (!isMap) {
// If any box shadow is malformed then we should not apply any of them
// which is the web behavior.
result = {};
return;
}
auto rawBoxShadowMap =
static_cast<std::unordered_map<std::string, RawValue>>(rawBoxShadow);
BoxShadow boxShadow{};
auto offsetX = rawBoxShadowMap.find("offsetX");
react_native_expect(offsetX != rawBoxShadowMap.end());
if (offsetX == rawBoxShadowMap.end()) {
result = {};
return;
}
react_native_expect(offsetX->second.hasType<Float>());
if (!offsetX->second.hasType<Float>()) {
result = {};
return;
}
boxShadow.offsetX = (Float)offsetX->second;
auto offsetY = rawBoxShadowMap.find("offsetY");
react_native_expect(offsetY != rawBoxShadowMap.end());
if (offsetY == rawBoxShadowMap.end()) {
result = {};
return;
}
react_native_expect(offsetY->second.hasType<Float>());
if (!offsetY->second.hasType<Float>()) {
result = {};
return;
}
boxShadow.offsetY = (Float)offsetY->second;
auto blurRadius = rawBoxShadowMap.find("blurRadius");
if (blurRadius != rawBoxShadowMap.end()) {
react_native_expect(blurRadius->second.hasType<Float>());
if (!blurRadius->second.hasType<Float>()) {
result = {};
return;
}
boxShadow.blurRadius = (Float)blurRadius->second;
}
auto spreadDistance = rawBoxShadowMap.find("spreadDistance");
if (spreadDistance != rawBoxShadowMap.end()) {
react_native_expect(spreadDistance->second.hasType<Float>());
if (!spreadDistance->second.hasType<Float>()) {
result = {};
return;
}
boxShadow.spreadDistance = (Float)spreadDistance->second;
}
auto inset = rawBoxShadowMap.find("inset");
if (inset != rawBoxShadowMap.end()) {
react_native_expect(inset->second.hasType<bool>());
if (!inset->second.hasType<bool>()) {
result = {};
return;
}
boxShadow.inset = (bool)inset->second;
}
auto color = rawBoxShadowMap.find("color");
if (color != rawBoxShadowMap.end()) {
fromRawValue(
context.contextContainer,
context.surfaceId,
color->second,
boxShadow.color);
}
boxShadows.push_back(boxShadow);
}
result = boxShadows;
}
std::optional<BoxShadow> fromCSSShadow(const CSSShadow& cssShadow) {
// TODO: handle non-px values
if (cssShadow.offsetX.unit != CSSLengthUnit::Px ||
cssShadow.offsetY.unit != CSSLengthUnit::Px ||
cssShadow.blurRadius.unit != CSSLengthUnit::Px ||
cssShadow.spreadDistance.unit != CSSLengthUnit::Px) {
return {};
}
return BoxShadow{
.offsetX = cssShadow.offsetX.value,
.offsetY = cssShadow.offsetY.value,
.blurRadius = cssShadow.blurRadius.value,
.spreadDistance = cssShadow.spreadDistance.value,
.color = colorFromRGBA(
cssShadow.color.r,
cssShadow.color.g,
cssShadow.color.b,
cssShadow.color.a),
.inset = cssShadow.inset,
};
}
void parseUnprocessedBoxShadowString(
std::string&& value,
std::vector<BoxShadow>& result) {
auto boxShadowList = parseCSSProperty<CSSShadowList>((std::string)value);
if (!std::holds_alternative<CSSShadowList>(boxShadowList)) {
result = {};
return;
}
for (const auto& cssShadow : std::get<CSSShadowList>(boxShadowList)) {
if (auto boxShadow = fromCSSShadow(cssShadow)) {
result.push_back(*boxShadow);
} else {
result = {};
return;
}
}
}
std::optional<BoxShadow> parseBoxShadowRawValue(
const PropsParserContext& context,
const RawValue& value) {
if (!value.hasType<std::unordered_map<std::string, RawValue>>()) {
return {};
}
auto boxShadow = std::unordered_map<std::string, RawValue>(value);
auto rawOffsetX = boxShadow.find("offsetX");
if (rawOffsetX == boxShadow.end()) {
return {};
}
auto offsetX = coerceLength(rawOffsetX->second);
if (!offsetX.has_value()) {
return {};
}
auto rawOffsetY = boxShadow.find("offsetY");
if (rawOffsetY == boxShadow.end()) {
return {};
}
auto offsetY = coerceLength(rawOffsetY->second);
if (!offsetY.has_value()) {
return {};
}
Float blurRadius = 0;
auto rawBlurRadius = boxShadow.find("blurRadius");
if (rawBlurRadius != boxShadow.end()) {
if (auto blurRadiusValue = coerceLength(rawBlurRadius->second)) {
if (*blurRadiusValue < 0) {
return {};
}
blurRadius = *blurRadiusValue;
} else {
return {};
}
}
Float spreadDistance = 0;
auto rawSpreadDistance = boxShadow.find("spreadDistance");
if (rawSpreadDistance != boxShadow.end()) {
if (auto spreadDistanceValue = coerceLength(rawSpreadDistance->second)) {
spreadDistance = *spreadDistanceValue;
} else {
return {};
}
}
bool inset = false;
auto rawInset = boxShadow.find("inset");
if (rawInset != boxShadow.end()) {
if (rawInset->second.hasType<bool>()) {
inset = (bool)rawInset->second;
} else {
return {};
}
}
SharedColor color;
auto rawColor = boxShadow.find("color");
if (rawColor != boxShadow.end()) {
color = coerceColor(rawColor->second, context);
if (!color) {
return {};
}
}
return BoxShadow{
.offsetX = *offsetX,
.offsetY = *offsetY,
.blurRadius = blurRadius,
.spreadDistance = spreadDistance,
.color = color,
.inset = inset};
}
void parseUnprocessedBoxShadowList(
const PropsParserContext& context,
std::vector<RawValue>&& value,
std::vector<BoxShadow>& result) {
for (const auto& rawValue : value) {
if (auto boxShadow = parseBoxShadowRawValue(context, rawValue)) {
result.push_back(*boxShadow);
} else {
result = {};
return;
}
}
}
void parseUnprocessedBoxShadow(
const PropsParserContext& context,
const RawValue& value,
std::vector<BoxShadow>& result) {
if (value.hasType<std::string>()) {
parseUnprocessedBoxShadowString((std::string)value, result);
} else if (value.hasType<std::vector<RawValue>>()) {
parseUnprocessedBoxShadowList(
context, (std::vector<RawValue>)value, result);
} else {
result = {};
}
}
} // namespace
void fromRawValue(
const PropsParserContext& context,
const RawValue& value,
std::vector<BoxShadow>& result) {
if (ReactNativeFeatureFlags::enableNativeCSSParsing()) {
parseUnprocessedBoxShadow(context, value, result);
} else {
parseProcessedBoxShadow(context, value, result);
}
}
} // namespace facebook::react
@@ -9,257 +9,13 @@
#include <react/cxxstableapi/UmbrellaGuard.h>
#include <glog/logging.h>
#include <react/debug/react_native_expect.h>
#include <react/featureflags/ReactNativePublicFeatureFlags.h>
#include <react/renderer/components/view/CSSConversions.h>
#include <react/renderer/core/PropsParserContext.h>
#include <react/renderer/core/RawProps.h>
#include <react/renderer/css/CSSShadow.h>
#include <react/renderer/css/CSSValueParser.h>
#include <react/renderer/core/RawValue.h>
#include <react/renderer/graphics/BoxShadow.h>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
namespace facebook::react {
inline void
parseProcessedBoxShadow(const PropsParserContext &context, const RawValue &value, std::vector<BoxShadow> &result)
{
react_native_expect(value.hasType<std::vector<RawValue>>());
if (!value.hasType<std::vector<RawValue>>()) {
result = {};
return;
}
std::vector<BoxShadow> boxShadows{};
auto rawBoxShadows = static_cast<std::vector<RawValue>>(value);
for (const auto &rawBoxShadow : rawBoxShadows) {
bool isMap = rawBoxShadow.hasType<std::unordered_map<std::string, RawValue>>();
react_native_expect(isMap);
if (!isMap) {
// If any box shadow is malformed then we should not apply any of them
// which is the web behavior.
result = {};
return;
}
auto rawBoxShadowMap = static_cast<std::unordered_map<std::string, RawValue>>(rawBoxShadow);
BoxShadow boxShadow{};
auto offsetX = rawBoxShadowMap.find("offsetX");
react_native_expect(offsetX != rawBoxShadowMap.end());
if (offsetX == rawBoxShadowMap.end()) {
result = {};
return;
}
react_native_expect(offsetX->second.hasType<Float>());
if (!offsetX->second.hasType<Float>()) {
result = {};
return;
}
boxShadow.offsetX = (Float)offsetX->second;
auto offsetY = rawBoxShadowMap.find("offsetY");
react_native_expect(offsetY != rawBoxShadowMap.end());
if (offsetY == rawBoxShadowMap.end()) {
result = {};
return;
}
react_native_expect(offsetY->second.hasType<Float>());
if (!offsetY->second.hasType<Float>()) {
result = {};
return;
}
boxShadow.offsetY = (Float)offsetY->second;
auto blurRadius = rawBoxShadowMap.find("blurRadius");
if (blurRadius != rawBoxShadowMap.end()) {
react_native_expect(blurRadius->second.hasType<Float>());
if (!blurRadius->second.hasType<Float>()) {
result = {};
return;
}
boxShadow.blurRadius = (Float)blurRadius->second;
}
auto spreadDistance = rawBoxShadowMap.find("spreadDistance");
if (spreadDistance != rawBoxShadowMap.end()) {
react_native_expect(spreadDistance->second.hasType<Float>());
if (!spreadDistance->second.hasType<Float>()) {
result = {};
return;
}
boxShadow.spreadDistance = (Float)spreadDistance->second;
}
auto inset = rawBoxShadowMap.find("inset");
if (inset != rawBoxShadowMap.end()) {
react_native_expect(inset->second.hasType<bool>());
if (!inset->second.hasType<bool>()) {
result = {};
return;
}
boxShadow.inset = (bool)inset->second;
}
auto color = rawBoxShadowMap.find("color");
if (color != rawBoxShadowMap.end()) {
fromRawValue(context.contextContainer, context.surfaceId, color->second, boxShadow.color);
}
boxShadows.push_back(boxShadow);
}
result = boxShadows;
}
inline std::optional<BoxShadow> fromCSSShadow(const CSSShadow &cssShadow)
{
// TODO: handle non-px values
if (cssShadow.offsetX.unit != CSSLengthUnit::Px || cssShadow.offsetY.unit != CSSLengthUnit::Px ||
cssShadow.blurRadius.unit != CSSLengthUnit::Px || cssShadow.spreadDistance.unit != CSSLengthUnit::Px) {
return {};
}
return BoxShadow{
.offsetX = cssShadow.offsetX.value,
.offsetY = cssShadow.offsetY.value,
.blurRadius = cssShadow.blurRadius.value,
.spreadDistance = cssShadow.spreadDistance.value,
.color = fromCSSColor(cssShadow.color),
.inset = cssShadow.inset,
};
}
inline void parseUnprocessedBoxShadowString(std::string &&value, std::vector<BoxShadow> &result)
{
auto boxShadowList = parseCSSProperty<CSSShadowList>((std::string)value);
if (!std::holds_alternative<CSSShadowList>(boxShadowList)) {
result = {};
return;
}
for (const auto &cssShadow : std::get<CSSShadowList>(boxShadowList)) {
if (auto boxShadow = fromCSSShadow(cssShadow)) {
result.push_back(*boxShadow);
} else {
result = {};
return;
}
}
}
inline std::optional<BoxShadow> parseBoxShadowRawValue(const PropsParserContext &context, const RawValue &value)
{
if (!value.hasType<std::unordered_map<std::string, RawValue>>()) {
return {};
}
auto boxShadow = std::unordered_map<std::string, RawValue>(value);
auto rawOffsetX = boxShadow.find("offsetX");
if (rawOffsetX == boxShadow.end()) {
return {};
}
auto offsetX = coerceLength(rawOffsetX->second);
if (!offsetX.has_value()) {
return {};
}
auto rawOffsetY = boxShadow.find("offsetY");
if (rawOffsetY == boxShadow.end()) {
return {};
}
auto offsetY = coerceLength(rawOffsetY->second);
if (!offsetY.has_value()) {
return {};
}
Float blurRadius = 0;
auto rawBlurRadius = boxShadow.find("blurRadius");
if (rawBlurRadius != boxShadow.end()) {
if (auto blurRadiusValue = coerceLength(rawBlurRadius->second)) {
if (*blurRadiusValue < 0) {
return {};
}
blurRadius = *blurRadiusValue;
} else {
return {};
}
}
Float spreadDistance = 0;
auto rawSpreadDistance = boxShadow.find("spreadDistance");
if (rawSpreadDistance != boxShadow.end()) {
if (auto spreadDistanceValue = coerceLength(rawSpreadDistance->second)) {
spreadDistance = *spreadDistanceValue;
} else {
return {};
}
}
bool inset = false;
auto rawInset = boxShadow.find("inset");
if (rawInset != boxShadow.end()) {
if (rawInset->second.hasType<bool>()) {
inset = (bool)rawInset->second;
} else {
return {};
}
}
SharedColor color;
auto rawColor = boxShadow.find("color");
if (rawColor != boxShadow.end()) {
color = coerceColor(rawColor->second, context);
if (!color) {
return {};
}
}
return BoxShadow{
.offsetX = *offsetX,
.offsetY = *offsetY,
.blurRadius = blurRadius,
.spreadDistance = spreadDistance,
.color = color,
.inset = inset};
}
inline void parseUnprocessedBoxShadowList(
const PropsParserContext &context,
std::vector<RawValue> &&value,
std::vector<BoxShadow> &result)
{
for (const auto &rawValue : value) {
if (auto boxShadow = parseBoxShadowRawValue(context, rawValue)) {
result.push_back(*boxShadow);
} else {
result = {};
return;
}
}
}
inline void
parseUnprocessedBoxShadow(const PropsParserContext &context, const RawValue &value, std::vector<BoxShadow> &result)
{
if (value.hasType<std::string>()) {
parseUnprocessedBoxShadowString((std::string)value, result);
} else if (value.hasType<std::vector<RawValue>>()) {
parseUnprocessedBoxShadowList(context, (std::vector<RawValue>)value, result);
} else {
result = {};
}
}
inline void fromRawValue(const PropsParserContext &context, const RawValue &value, std::vector<BoxShadow> &result)
{
if (ReactNativeFeatureFlags_DO_NOT_USE::enableNativeCSSParsing()) {
parseUnprocessedBoxShadow(context, value, result);
} else {
parseProcessedBoxShadow(context, value, result);
}
}
void fromRawValue(const PropsParserContext &context, const RawValue &value, std::vector<BoxShadow> &result);
} // namespace facebook::react
@@ -0,0 +1,57 @@
/*
* 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 "CSSConversions.h"
#include <react/renderer/core/graphicsConversions.h>
#include <react/renderer/css/CSSColor.h>
#include <react/renderer/css/CSSLength.h>
#include <react/renderer/css/CSSValueParser.h>
namespace facebook::react {
SharedColor coerceColor(
const RawValue& value,
const PropsParserContext& context) {
if (value.hasType<std::string>()) {
auto cssColor = parseCSSProperty<CSSColor>((std::string)value);
if (!std::holds_alternative<CSSColor>(cssColor)) {
return {};
}
const auto& color = std::get<CSSColor>(cssColor);
return colorFromRGBA(color.r, color.g, color.b, color.a);
}
SharedColor color;
fromRawValue(context.contextContainer, context.surfaceId, value, color);
return color;
}
std::optional<Float> coerceLength(const RawValue& value) {
if (value.hasType<Float>()) {
return (Float)value;
}
if (value.hasType<std::string>()) {
auto length = parseCSSProperty<CSSLength>((std::string)value);
if (!std::holds_alternative<CSSLength>(length)) {
return {};
}
auto cssLength = std::get<CSSLength>(length);
if (cssLength.unit != CSSLengthUnit::Px) {
return {};
}
return cssLength.value;
}
return {};
}
} // namespace facebook::react
@@ -11,89 +11,14 @@
#include <react/renderer/core/PropsParserContext.h>
#include <react/renderer/core/RawValue.h>
#include <react/renderer/core/graphicsConversions.h>
#include <react/renderer/css/CSSColor.h>
#include <react/renderer/css/CSSLength.h>
#include <react/renderer/css/CSSNumber.h>
#include <react/renderer/css/CSSPercentage.h>
#include <react/renderer/css/CSSValueParser.h>
#include <react/renderer/graphics/Color.h>
#include <react/renderer/graphics/Float.h>
#include <optional>
namespace facebook::react {
inline SharedColor fromCSSColor(const CSSColor &cssColor)
{
return hostPlatformColorFromRGBA(cssColor.r, cssColor.g, cssColor.b, cssColor.a);
}
SharedColor coerceColor(const RawValue &value, const PropsParserContext &context);
inline std::optional<Float> coerceAmount(const RawValue &value)
{
if (value.hasType<Float>()) {
return (Float)value;
}
if (value.hasType<std::string>()) {
auto cssVal = parseCSSProperty<CSSNumber, CSSPercentage>((std::string)value);
if (std::holds_alternative<CSSNumber>(cssVal)) {
return std::get<CSSNumber>(cssVal).value;
} else if (std::holds_alternative<CSSPercentage>(cssVal)) {
return std::get<CSSPercentage>(cssVal).value / 100.0f;
}
}
return {};
}
inline std::optional<Float> coerceAngle(const RawValue &value)
{
if (value.hasType<Float>()) {
return (Float)value;
}
if (value.hasType<std::string>()) {
auto cssVal = parseCSSProperty<CSSAngle>((std::string)value);
if (std::holds_alternative<CSSAngle>(cssVal)) {
return std::get<CSSAngle>(cssVal).degrees;
}
}
return {};
}
inline SharedColor coerceColor(const RawValue &value, const PropsParserContext &context)
{
if (value.hasType<std::string>()) {
auto cssColor = parseCSSProperty<CSSColor>((std::string)value);
if (!std::holds_alternative<CSSColor>(cssColor)) {
return {};
}
return fromCSSColor(std::get<CSSColor>(cssColor));
}
SharedColor color;
fromRawValue(context.contextContainer, context.surfaceId, value, color);
return color;
}
inline std::optional<Float> coerceLength(const RawValue &value)
{
if (value.hasType<Float>()) {
return (Float)value;
}
if (value.hasType<std::string>()) {
auto len = parseCSSProperty<CSSLength>((std::string)value);
if (!std::holds_alternative<CSSLength>(len)) {
return {};
}
auto cssLen = std::get<CSSLength>(len);
if (cssLen.unit != CSSLengthUnit::Px) {
return {};
}
return cssLen.value;
}
return {};
}
std::optional<Float> coerceLength(const RawValue &value);
} // namespace facebook::react
@@ -0,0 +1,434 @@
/*
* 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 "FilterPropsConversions.h"
#include <glog/logging.h>
#include <react/debug/react_native_expect.h>
#include <react/featureflags/ReactNativeFeatureFlags.h>
#include <react/renderer/components/view/CSSConversions.h>
#include <react/renderer/css/CSSAngle.h>
#include <react/renderer/css/CSSFilter.h>
#include <react/renderer/css/CSSNumber.h>
#include <react/renderer/css/CSSPercentage.h>
#include <react/renderer/css/CSSValueParser.h>
#include <react/renderer/graphics/PlatformColorParser.h>
#include <optional>
#include <string>
#include <unordered_map>
namespace facebook::react {
namespace {
std::optional<Float> coerceAmount(const RawValue& value) {
if (value.hasType<Float>()) {
return (Float)value;
}
if (value.hasType<std::string>()) {
auto cssValue =
parseCSSProperty<CSSNumber, CSSPercentage>((std::string)value);
if (std::holds_alternative<CSSNumber>(cssValue)) {
return std::get<CSSNumber>(cssValue).value;
}
if (std::holds_alternative<CSSPercentage>(cssValue)) {
return std::get<CSSPercentage>(cssValue).value / 100.0f;
}
}
return {};
}
std::optional<Float> coerceAngle(const RawValue& value) {
if (value.hasType<Float>()) {
return (Float)value;
}
if (value.hasType<std::string>()) {
auto cssValue = parseCSSProperty<CSSAngle>((std::string)value);
if (std::holds_alternative<CSSAngle>(cssValue)) {
return std::get<CSSAngle>(cssValue).degrees;
}
}
return {};
}
void parseProcessedFilter(
const PropsParserContext& context,
const RawValue& value,
std::vector<FilterFunction>& result) {
react_native_expect(value.hasType<std::vector<RawValue>>());
if (!value.hasType<std::vector<RawValue>>()) {
result = {};
return;
}
std::vector<FilterFunction> filter{};
auto rawFilter = static_cast<std::vector<RawValue>>(value);
for (const auto& rawFilterPrimitive : rawFilter) {
bool isMap =
rawFilterPrimitive.hasType<std::unordered_map<std::string, RawValue>>();
react_native_expect(isMap);
if (!isMap) {
// If a filter is malformed then we should not apply any of them which
// is the web behavior.
result = {};
return;
}
auto rawFilterFunction =
static_cast<std::unordered_map<std::string, RawValue>>(
rawFilterPrimitive);
FilterFunction filterFunction{};
auto filterType = filterTypeFromString(rawFilterFunction.begin()->first);
if (!filterType.has_value()) {
LOG(ERROR) << "Could not parse FilterFunction: "
<< rawFilterFunction.begin()->first;
result = {};
return;
}
filterFunction.type = *filterType;
if (filterFunction.type == FilterType::DropShadow) {
auto rawDropShadow =
static_cast<std::unordered_map<std::string, RawValue>>(
rawFilterFunction.begin()->second);
DropShadowParams dropShadowParams{};
auto offsetX = rawDropShadow.find("offsetX");
react_native_expect(offsetX != rawDropShadow.end());
if (offsetX == rawDropShadow.end()) {
result = {};
return;
}
react_native_expect(offsetX->second.hasType<Float>());
if (!offsetX->second.hasType<Float>()) {
result = {};
return;
}
dropShadowParams.offsetX = (Float)offsetX->second;
auto offsetY = rawDropShadow.find("offsetY");
react_native_expect(offsetY != rawDropShadow.end());
if (offsetY == rawDropShadow.end()) {
result = {};
return;
}
react_native_expect(offsetY->second.hasType<Float>());
if (!offsetY->second.hasType<Float>()) {
result = {};
return;
}
dropShadowParams.offsetY = (Float)offsetY->second;
auto standardDeviation = rawDropShadow.find("standardDeviation");
if (standardDeviation != rawDropShadow.end()) {
react_native_expect(standardDeviation->second.hasType<Float>());
if (!standardDeviation->second.hasType<Float>()) {
result = {};
return;
}
dropShadowParams.standardDeviation = (Float)standardDeviation->second;
}
auto color = rawDropShadow.find("color");
if (color != rawDropShadow.end()) {
fromRawValue(
context.contextContainer,
context.surfaceId,
color->second,
dropShadowParams.color);
}
filterFunction.parameters = dropShadowParams;
} else {
filterFunction.parameters = (float)rawFilterFunction.begin()->second;
}
filter.push_back(filterFunction);
}
result = filter;
}
FilterType filterTypeFromVariant(const CSSFilterFunction& filter) {
return std::visit(
[](auto&& filter) -> FilterType {
using FilterT = std::decay_t<decltype(filter)>;
if constexpr (std::is_same_v<FilterT, CSSBlurFilter>) {
return FilterType::Blur;
}
if constexpr (std::is_same_v<FilterT, CSSBrightnessFilter>) {
return FilterType::Brightness;
}
if constexpr (std::is_same_v<FilterT, CSSContrastFilter>) {
return FilterType::Contrast;
}
if constexpr (std::is_same_v<FilterT, CSSDropShadowFilter>) {
return FilterType::DropShadow;
}
if constexpr (std::is_same_v<FilterT, CSSGrayscaleFilter>) {
return FilterType::Grayscale;
}
if constexpr (std::is_same_v<FilterT, CSSHueRotateFilter>) {
return FilterType::HueRotate;
}
if constexpr (std::is_same_v<FilterT, CSSInvertFilter>) {
return FilterType::Invert;
}
if constexpr (std::is_same_v<FilterT, CSSOpacityFilter>) {
return FilterType::Opacity;
}
if constexpr (std::is_same_v<FilterT, CSSSaturateFilter>) {
return FilterType::Saturate;
}
if constexpr (std::is_same_v<FilterT, CSSSepiaFilter>) {
return FilterType::Sepia;
}
},
filter);
}
std::optional<FilterFunction> fromCSSFilter(
const CSSFilterFunction& cssFilter) {
return std::visit(
[&](auto&& filter) -> std::optional<FilterFunction> {
using FilterT = std::decay_t<decltype(filter)>;
if constexpr (std::is_same_v<FilterT, CSSBlurFilter>) {
// TODO: support non-px values
if (filter.amount.unit != CSSLengthUnit::Px) {
return {};
}
return FilterFunction{
.type = filterTypeFromVariant(cssFilter),
.parameters = filter.amount.value,
};
}
if constexpr (std::is_same_v<FilterT, CSSDropShadowFilter>) {
// TODO: support non-px values
if (filter.offsetX.unit != CSSLengthUnit::Px ||
filter.offsetY.unit != CSSLengthUnit::Px ||
filter.standardDeviation.unit != CSSLengthUnit::Px) {
return {};
}
return FilterFunction{
.type = FilterType::DropShadow,
.parameters = DropShadowParams{
.offsetX = filter.offsetX.value,
.offsetY = filter.offsetY.value,
.standardDeviation = filter.standardDeviation.value,
.color = colorFromRGBA(
filter.color.r,
filter.color.g,
filter.color.b,
filter.color.a),
}};
}
if constexpr (
std::is_same_v<FilterT, CSSBrightnessFilter> ||
std::is_same_v<FilterT, CSSContrastFilter> ||
std::is_same_v<FilterT, CSSGrayscaleFilter> ||
std::is_same_v<FilterT, CSSInvertFilter> ||
std::is_same_v<FilterT, CSSOpacityFilter> ||
std::is_same_v<FilterT, CSSSaturateFilter> ||
std::is_same_v<FilterT, CSSSepiaFilter>) {
return FilterFunction{
.type = filterTypeFromVariant(cssFilter),
.parameters = filter.amount,
};
}
if constexpr (std::is_same_v<FilterT, CSSHueRotateFilter>) {
return FilterFunction{
.type = filterTypeFromVariant(cssFilter),
.parameters = filter.degrees,
};
}
},
cssFilter);
}
void parseUnprocessedFilterString(
std::string&& value,
std::vector<FilterFunction>& result) {
auto filterList = parseCSSProperty<CSSFilterList>((std::string)value);
if (!std::holds_alternative<CSSFilterList>(filterList)) {
result = {};
return;
}
for (const auto& cssFilter : std::get<CSSFilterList>(filterList)) {
if (auto filter = fromCSSFilter(cssFilter)) {
result.push_back(*filter);
} else {
result = {};
return;
}
}
}
std::optional<FilterFunction> parseDropShadow(
const PropsParserContext& context,
const RawValue& value) {
if (value.hasType<std::string>()) {
auto val = parseCSSProperty<CSSDropShadowFilter>(
std::string("drop-shadow(") + (std::string)value + ")");
if (std::holds_alternative<CSSDropShadowFilter>(val)) {
return fromCSSFilter(std::get<CSSDropShadowFilter>(val));
}
return {};
}
if (!value.hasType<std::unordered_map<std::string, RawValue>>()) {
return {};
}
auto rawDropShadow =
static_cast<std::unordered_map<std::string, RawValue>>(value);
DropShadowParams dropShadowParams{};
auto offsetX = rawDropShadow.find("offsetX");
if (offsetX == rawDropShadow.end()) {
return {};
}
if (auto parsedOffsetX = coerceLength(offsetX->second)) {
dropShadowParams.offsetX = *parsedOffsetX;
} else {
return {};
}
auto offsetY = rawDropShadow.find("offsetY");
if (offsetY == rawDropShadow.end()) {
return {};
}
if (auto parsedOffsetY = coerceLength(offsetY->second)) {
dropShadowParams.offsetY = *parsedOffsetY;
} else {
return {};
}
auto standardDeviation = rawDropShadow.find("standardDeviation");
if (standardDeviation != rawDropShadow.end()) {
if (auto parsedStandardDeviation =
coerceLength(standardDeviation->second)) {
if (*parsedStandardDeviation < 0.0f) {
return {};
}
dropShadowParams.standardDeviation = *parsedStandardDeviation;
} else {
return {};
}
}
auto color = rawDropShadow.find("color");
if (color != rawDropShadow.end()) {
if (auto parsedColor = coerceColor(color->second, context)) {
dropShadowParams.color = *parsedColor;
} else {
return {};
}
}
return FilterFunction{
.type = FilterType::DropShadow, .parameters = dropShadowParams};
}
std::optional<FilterFunction> parseFilterRawValue(
const PropsParserContext& context,
const RawValue& value) {
if (!value.hasType<std::unordered_map<std::string, RawValue>>()) {
return {};
}
auto rawFilter =
static_cast<std::unordered_map<std::string, RawValue>>(value);
if (rawFilter.size() != 1) {
return {};
}
const auto& filterKey = rawFilter.begin()->first;
if (filterKey == "drop-shadow") {
return parseDropShadow(context, rawFilter.begin()->second);
} else if (filterKey == "blur") {
if (auto length = coerceLength(rawFilter.begin()->second)) {
if (*length < 0.0f) {
return {};
}
return FilterFunction{.type = FilterType::Blur, .parameters = *length};
}
return {};
} else if (filterKey == "hue-rotate") {
if (auto angle = coerceAngle(rawFilter.begin()->second)) {
return FilterFunction{
.type = FilterType::HueRotate, .parameters = *angle};
}
return {};
} else {
auto filterType = filterTypeFromString(filterKey);
if (!filterType.has_value()) {
return {};
}
if (auto amount = coerceAmount(rawFilter.begin()->second)) {
if (*amount < 0.0f) {
return {};
}
return FilterFunction{.type = *filterType, .parameters = *amount};
}
return {};
}
}
void parseUnprocessedFilterList(
const PropsParserContext& context,
std::vector<RawValue>&& value,
std::vector<FilterFunction>& result) {
for (const auto& rawValue : value) {
if (auto Filter = parseFilterRawValue(context, rawValue)) {
result.push_back(*Filter);
} else {
result = {};
return;
}
}
}
void parseUnprocessedFilter(
const PropsParserContext& context,
const RawValue& value,
std::vector<FilterFunction>& result) {
if (value.hasType<std::string>()) {
parseUnprocessedFilterString((std::string)value, result);
} else if (value.hasType<std::vector<RawValue>>()) {
parseUnprocessedFilterList(context, (std::vector<RawValue>)value, result);
} else {
result = {};
}
}
} // namespace
void fromRawValue(
const PropsParserContext& context,
const RawValue& value,
std::vector<FilterFunction>& result) {
if (ReactNativeFeatureFlags::enableNativeCSSParsing()) {
parseUnprocessedFilter(context, value, result);
} else {
parseProcessedFilter(context, value, result);
}
}
} // namespace facebook::react
@@ -9,360 +9,13 @@
#include <react/cxxstableapi/UmbrellaGuard.h>
#include <glog/logging.h>
#include <react/debug/react_native_expect.h>
#include <react/featureflags/ReactNativePublicFeatureFlags.h>
#include <react/renderer/components/view/CSSConversions.h>
#include <react/renderer/core/PropsParserContext.h>
#include <react/renderer/core/RawProps.h>
#include <react/renderer/css/CSSFilter.h>
#include <react/renderer/css/CSSValueParser.h>
#include <react/renderer/core/RawValue.h>
#include <react/renderer/graphics/Filter.h>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
namespace facebook::react {
inline void
parseProcessedFilter(const PropsParserContext &context, const RawValue &value, std::vector<FilterFunction> &result)
{
react_native_expect(value.hasType<std::vector<RawValue>>());
if (!value.hasType<std::vector<RawValue>>()) {
result = {};
return;
}
std::vector<FilterFunction> filter{};
auto rawFilter = static_cast<std::vector<RawValue>>(value);
for (const auto &rawFilterPrimitive : rawFilter) {
bool isMap = rawFilterPrimitive.hasType<std::unordered_map<std::string, RawValue>>();
react_native_expect(isMap);
if (!isMap) {
// If a filter is malformed then we should not apply any of them which
// is the web behavior.
result = {};
return;
}
auto rawFilterFunction = static_cast<std::unordered_map<std::string, RawValue>>(rawFilterPrimitive);
FilterFunction filterFunction{};
auto filterType = filterTypeFromString(rawFilterFunction.begin()->first);
if (!filterType.has_value()) {
LOG(ERROR) << "Could not parse FilterFunction: " << rawFilterFunction.begin()->first;
result = {};
return;
}
filterFunction.type = *filterType;
if (filterFunction.type == FilterType::DropShadow) {
auto rawDropShadow = static_cast<std::unordered_map<std::string, RawValue>>(rawFilterFunction.begin()->second);
DropShadowParams dropShadowParams{};
auto offsetX = rawDropShadow.find("offsetX");
react_native_expect(offsetX != rawDropShadow.end());
if (offsetX == rawDropShadow.end()) {
result = {};
return;
}
react_native_expect(offsetX->second.hasType<Float>());
if (!offsetX->second.hasType<Float>()) {
result = {};
return;
}
dropShadowParams.offsetX = (Float)offsetX->second;
auto offsetY = rawDropShadow.find("offsetY");
react_native_expect(offsetY != rawDropShadow.end());
if (offsetY == rawDropShadow.end()) {
result = {};
return;
}
react_native_expect(offsetY->second.hasType<Float>());
if (!offsetY->second.hasType<Float>()) {
result = {};
return;
}
dropShadowParams.offsetY = (Float)offsetY->second;
auto standardDeviation = rawDropShadow.find("standardDeviation");
if (standardDeviation != rawDropShadow.end()) {
react_native_expect(standardDeviation->second.hasType<Float>());
if (!standardDeviation->second.hasType<Float>()) {
result = {};
return;
}
dropShadowParams.standardDeviation = (Float)standardDeviation->second;
}
auto color = rawDropShadow.find("color");
if (color != rawDropShadow.end()) {
fromRawValue(context.contextContainer, context.surfaceId, color->second, dropShadowParams.color);
}
filterFunction.parameters = dropShadowParams;
} else {
filterFunction.parameters = (float)rawFilterFunction.begin()->second;
}
filter.push_back(filterFunction);
}
result = filter;
}
inline FilterType filterTypeFromVariant(const CSSFilterFunction &filter)
{
return std::visit(
[](auto &&filter) -> FilterType {
using FilterT = std::decay_t<decltype(filter)>;
if constexpr (std::is_same_v<FilterT, CSSBlurFilter>) {
return FilterType::Blur;
}
if constexpr (std::is_same_v<FilterT, CSSBrightnessFilter>) {
return FilterType::Brightness;
}
if constexpr (std::is_same_v<FilterT, CSSContrastFilter>) {
return FilterType::Contrast;
}
if constexpr (std::is_same_v<FilterT, CSSDropShadowFilter>) {
return FilterType::DropShadow;
}
if constexpr (std::is_same_v<FilterT, CSSGrayscaleFilter>) {
return FilterType::Grayscale;
}
if constexpr (std::is_same_v<FilterT, CSSHueRotateFilter>) {
return FilterType::HueRotate;
}
if constexpr (std::is_same_v<FilterT, CSSInvertFilter>) {
return FilterType::Invert;
}
if constexpr (std::is_same_v<FilterT, CSSOpacityFilter>) {
return FilterType::Opacity;
}
if constexpr (std::is_same_v<FilterT, CSSSaturateFilter>) {
return FilterType::Saturate;
}
if constexpr (std::is_same_v<FilterT, CSSSepiaFilter>) {
return FilterType::Sepia;
}
},
filter);
}
inline std::optional<FilterFunction> fromCSSFilter(const CSSFilterFunction &cssFilter)
{
return std::visit(
[&](auto &&filter) -> std::optional<FilterFunction> {
using FilterT = std::decay_t<decltype(filter)>;
if constexpr (std::is_same_v<FilterT, CSSBlurFilter>) {
// TODO: support non-px values
if (filter.amount.unit != CSSLengthUnit::Px) {
return {};
}
return FilterFunction{
.type = filterTypeFromVariant(cssFilter),
.parameters = filter.amount.value,
};
}
if constexpr (std::is_same_v<FilterT, CSSDropShadowFilter>) {
// TODO: support non-px values
if (filter.offsetX.unit != CSSLengthUnit::Px || filter.offsetY.unit != CSSLengthUnit::Px ||
filter.standardDeviation.unit != CSSLengthUnit::Px) {
return {};
}
return FilterFunction{
.type = FilterType::DropShadow,
.parameters = DropShadowParams{
.offsetX = filter.offsetX.value,
.offsetY = filter.offsetY.value,
.standardDeviation = filter.standardDeviation.value,
.color = fromCSSColor(filter.color),
}};
}
if constexpr (
std::is_same_v<FilterT, CSSBrightnessFilter> || std::is_same_v<FilterT, CSSContrastFilter> ||
std::is_same_v<FilterT, CSSGrayscaleFilter> || std::is_same_v<FilterT, CSSInvertFilter> ||
std::is_same_v<FilterT, CSSOpacityFilter> || std::is_same_v<FilterT, CSSSaturateFilter> ||
std::is_same_v<FilterT, CSSSepiaFilter>) {
return FilterFunction{
.type = filterTypeFromVariant(cssFilter),
.parameters = filter.amount,
};
}
if constexpr (std::is_same_v<FilterT, CSSHueRotateFilter>) {
return FilterFunction{
.type = filterTypeFromVariant(cssFilter),
.parameters = filter.degrees,
};
}
},
cssFilter);
}
inline void parseUnprocessedFilterString(std::string &&value, std::vector<FilterFunction> &result)
{
auto filterList = parseCSSProperty<CSSFilterList>((std::string)value);
if (!std::holds_alternative<CSSFilterList>(filterList)) {
result = {};
return;
}
for (const auto &cssFilter : std::get<CSSFilterList>(filterList)) {
if (auto filter = fromCSSFilter(cssFilter)) {
result.push_back(*filter);
} else {
result = {};
return;
}
}
}
inline std::optional<FilterFunction> parseDropShadow(const PropsParserContext &context, const RawValue &value)
{
if (value.hasType<std::string>()) {
auto val = parseCSSProperty<CSSDropShadowFilter>(std::string("drop-shadow(") + (std::string)value + ")");
if (std::holds_alternative<CSSDropShadowFilter>(val)) {
return fromCSSFilter(std::get<CSSDropShadowFilter>(val));
}
return {};
}
if (!value.hasType<std::unordered_map<std::string, RawValue>>()) {
return {};
}
auto rawDropShadow = static_cast<std::unordered_map<std::string, RawValue>>(value);
DropShadowParams dropShadowParams{};
auto offsetX = rawDropShadow.find("offsetX");
if (offsetX == rawDropShadow.end()) {
return {};
}
if (auto parsedOffsetX = coerceLength(offsetX->second)) {
dropShadowParams.offsetX = *parsedOffsetX;
} else {
return {};
}
auto offsetY = rawDropShadow.find("offsetY");
if (offsetY == rawDropShadow.end()) {
return {};
}
if (auto parsedOffsetY = coerceLength(offsetY->second)) {
dropShadowParams.offsetY = *parsedOffsetY;
} else {
return {};
}
auto standardDeviation = rawDropShadow.find("standardDeviation");
if (standardDeviation != rawDropShadow.end()) {
if (auto parsedStandardDeviation = coerceLength(standardDeviation->second)) {
if (*parsedStandardDeviation < 0.0f) {
return {};
}
dropShadowParams.standardDeviation = *parsedStandardDeviation;
} else {
return {};
}
}
auto color = rawDropShadow.find("color");
if (color != rawDropShadow.end()) {
if (auto parsedColor = coerceColor(color->second, context)) {
dropShadowParams.color = *parsedColor;
} else {
return {};
}
}
return FilterFunction{.type = FilterType::DropShadow, .parameters = dropShadowParams};
}
inline std::optional<FilterFunction> parseFilterRawValue(const PropsParserContext &context, const RawValue &value)
{
if (!value.hasType<std::unordered_map<std::string, RawValue>>()) {
return {};
}
auto rawFilter = static_cast<std::unordered_map<std::string, RawValue>>(value);
if (rawFilter.size() != 1) {
return {};
}
const auto &filterKey = rawFilter.begin()->first;
if (filterKey == "drop-shadow") {
return parseDropShadow(context, rawFilter.begin()->second);
} else if (filterKey == "blur") {
if (auto length = coerceLength(rawFilter.begin()->second)) {
if (*length < 0.0f) {
return {};
}
return FilterFunction{.type = FilterType::Blur, .parameters = *length};
}
return {};
} else if (filterKey == "hue-rotate") {
if (auto angle = coerceAngle(rawFilter.begin()->second)) {
return FilterFunction{.type = FilterType::HueRotate, .parameters = *angle};
}
return {};
} else {
auto filterType = filterTypeFromString(filterKey);
if (!filterType.has_value()) {
return {};
}
if (auto amount = coerceAmount(rawFilter.begin()->second)) {
if (*amount < 0.0f) {
return {};
}
return FilterFunction{.type = *filterType, .parameters = *amount};
}
return {};
}
}
inline void parseUnprocessedFilterList(
const PropsParserContext &context,
std::vector<RawValue> &&value,
std::vector<FilterFunction> &result)
{
for (const auto &rawValue : value) {
if (auto Filter = parseFilterRawValue(context, rawValue)) {
result.push_back(*Filter);
} else {
result = {};
return;
}
}
}
inline void
parseUnprocessedFilter(const PropsParserContext &context, const RawValue &value, std::vector<FilterFunction> &result)
{
if (value.hasType<std::string>()) {
parseUnprocessedFilterString((std::string)value, result);
} else if (value.hasType<std::vector<RawValue>>()) {
parseUnprocessedFilterList(context, (std::vector<RawValue>)value, result);
} else {
result = {};
}
}
inline void fromRawValue(const PropsParserContext &context, const RawValue &value, std::vector<FilterFunction> &result)
{
if (ReactNativeFeatureFlags_DO_NOT_USE::enableNativeCSSParsing()) {
parseUnprocessedFilter(context, value, result);
} else {
parseProcessedFilter(context, value, result);
}
}
void fromRawValue(const PropsParserContext &context, const RawValue &value, std::vector<FilterFunction> &result);
} // namespace facebook::react
@@ -6,9 +6,12 @@
*/
#include <array>
#include <memory>
#include <gtest/gtest.h>
#include <react/featureflags/ReactNativeFeatureFlags.h>
#include <react/featureflags/ReactNativeFeatureFlagsDefaults.h>
#include <react/renderer/attributedstring/conversions.h>
#include <react/renderer/components/view/BoxShadowPropsConversions.h>
#include <react/renderer/components/view/FilterPropsConversions.h>
@@ -17,6 +20,30 @@
namespace facebook::react {
namespace {
class NativeCSSParsingEnabledFlags : public ReactNativeFeatureFlagsDefaults {
public:
bool enableNativeCSSParsing() override {
return true;
}
};
class NativeCSSConversionsTest : public ::testing::Test {
protected:
void SetUp() override {
ReactNativeFeatureFlags::dangerouslyReset();
ReactNativeFeatureFlags::override(
std::make_unique<NativeCSSParsingEnabledFlags>());
}
void TearDown() override {
ReactNativeFeatureFlags::dangerouslyReset();
}
};
} // namespace
TEST(ConversionsTest, accessibility_roles_round_trip) {
struct AccessibilityRoleTestCase {
AccessibilityRole role;
@@ -122,13 +149,12 @@ TEST(ConversionsTest, accessibility_roles_round_trip) {
}
}
TEST(ConversionsTest, unprocessed_box_shadow_string) {
TEST_F(NativeCSSConversionsTest, unprocessed_box_shadow_string) {
RawValue value{
folly::dynamic("10px 2px 0 5px #fff, inset 20px 10px 5px 0 #000")};
std::vector<BoxShadow> boxShadows;
parseUnprocessedBoxShadow(
PropsParserContext{-1, ContextContainer{}}, value, boxShadows);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, boxShadows);
EXPECT_EQ(boxShadows.size(), 2);
EXPECT_EQ(boxShadows[0].offsetX, 10);
@@ -146,7 +172,7 @@ TEST(ConversionsTest, unprocessed_box_shadow_string) {
EXPECT_TRUE(boxShadows[1].inset);
}
TEST(ConversionsTest, unprocessed_box_shadow_objects) {
TEST_F(NativeCSSConversionsTest, unprocessed_box_shadow_objects) {
RawValue value{folly::dynamic::array(
folly::dynamic::object("offsetX", 10)("offsetY", 2)("blurRadius", 3)(
"spreadDistance", 5),
@@ -154,8 +180,7 @@ TEST(ConversionsTest, unprocessed_box_shadow_objects) {
"color", "#fff")("inset", true))};
std::vector<BoxShadow> boxShadows;
parseUnprocessedBoxShadow(
PropsParserContext{-1, ContextContainer{}}, value, boxShadows);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, boxShadows);
EXPECT_EQ(boxShadows.size(), 2);
EXPECT_EQ(boxShadows[0].offsetX, 10);
@@ -173,37 +198,34 @@ TEST(ConversionsTest, unprocessed_box_shadow_objects) {
EXPECT_TRUE(boxShadows[1].inset);
}
TEST(ConversionsTest, unprocessed_box_object_invalid_color) {
TEST_F(NativeCSSConversionsTest, unprocessed_box_object_invalid_color) {
RawValue value{folly::dynamic::array(
folly::dynamic::object("offsetX", 10)("offsetY", 2)("blurRadius", 3)(
"spreadDistance", 5)("color", "hello"))};
std::vector<BoxShadow> boxShadows;
parseUnprocessedBoxShadow(
PropsParserContext{-1, ContextContainer{}}, value, boxShadows);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, boxShadows);
EXPECT_TRUE(boxShadows.empty());
}
TEST(ConversionsTest, unprocessed_box_object_negative_blur) {
TEST_F(NativeCSSConversionsTest, unprocessed_box_object_negative_blur) {
RawValue value{folly::dynamic::array(
folly::dynamic::object("offsetX", 10)("offsetY", 2)("blurRadius", -3)(
"spreadDistance", 5))};
std::vector<BoxShadow> boxShadows;
parseUnprocessedBoxShadow(
PropsParserContext{-1, ContextContainer{}}, value, boxShadows);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, boxShadows);
EXPECT_TRUE(boxShadows.empty());
}
TEST(ConversionsTest, unprocessed_filter_string) {
TEST_F(NativeCSSConversionsTest, unprocessed_filter_string) {
RawValue value{folly::dynamic(
"drop-shadow(10px -2px 0.5px #fff) blur(5px) hue-rotate(90deg) saturate(2) brightness(50%)")};
std::vector<FilterFunction> filters;
parseUnprocessedFilter(
PropsParserContext{-1, ContextContainer{}}, value, filters);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, filters);
EXPECT_EQ(filters.size(), 5);
@@ -234,7 +256,7 @@ TEST(ConversionsTest, unprocessed_filter_string) {
EXPECT_EQ(std::get<Float>(filters[4].parameters), 0.5f);
}
TEST(ConversionsTest, unprocessed_filter_objects) {
TEST_F(NativeCSSConversionsTest, unprocessed_filter_objects) {
RawValue value{folly::dynamic::array(
folly::dynamic::object(
"drop-shadow",
@@ -247,8 +269,7 @@ TEST(ConversionsTest, unprocessed_filter_objects) {
folly::dynamic::object("brightness", "50%"))};
std::vector<FilterFunction> filters;
parseUnprocessedFilter(
PropsParserContext{-1, ContextContainer{}}, value, filters);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, filters);
EXPECT_EQ(filters.size(), 6);
@@ -288,7 +309,9 @@ TEST(ConversionsTest, unprocessed_filter_objects) {
EXPECT_EQ(std::get<Float>(filters[5].parameters), 0.5f);
}
TEST(ConversionsTest, unprocessed_filter_objects_negative_shadow_blur) {
TEST_F(
NativeCSSConversionsTest,
unprocessed_filter_objects_negative_shadow_blur) {
RawValue value{folly::dynamic::array(
folly::dynamic::object(
"drop-shadow",
@@ -296,40 +319,38 @@ TEST(ConversionsTest, unprocessed_filter_objects_negative_shadow_blur) {
"standardDeviation", -0.5)))};
std::vector<FilterFunction> filters;
parseUnprocessedFilter(
PropsParserContext{-1, ContextContainer{}}, value, filters);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, filters);
EXPECT_TRUE(filters.empty());
}
TEST(ConversionsTest, unprocessed_filter_objects_negative_blur) {
TEST_F(NativeCSSConversionsTest, unprocessed_filter_objects_negative_blur) {
RawValue value{folly::dynamic::array(folly::dynamic::object("blur", -5))};
std::vector<FilterFunction> filters;
parseUnprocessedFilter(
PropsParserContext{-1, ContextContainer{}}, value, filters);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, filters);
EXPECT_TRUE(filters.empty());
}
TEST(ConversionsTest, unprocessed_filter_objects_negative_contrast) {
TEST_F(NativeCSSConversionsTest, unprocessed_filter_objects_negative_contrast) {
RawValue value{
folly::dynamic::array(folly::dynamic::object("constrast", -5))};
std::vector<FilterFunction> filters;
parseUnprocessedFilter(
PropsParserContext{-1, ContextContainer{}}, value, filters);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, filters);
EXPECT_TRUE(filters.empty());
}
TEST(ConversionsTest, unprocessed_filter_objects_negative_hue_rotate) {
TEST_F(
NativeCSSConversionsTest,
unprocessed_filter_objects_negative_hue_rotate) {
RawValue value{
folly::dynamic::array(folly::dynamic::object("hue-rotate", -5))};
std::vector<FilterFunction> filters;
parseUnprocessedFilter(
PropsParserContext{-1, ContextContainer{}}, value, filters);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, filters);
EXPECT_EQ(filters.size(), 1);
@@ -338,24 +359,22 @@ TEST(ConversionsTest, unprocessed_filter_objects_negative_hue_rotate) {
EXPECT_EQ(std::get<Float>(filters[0].parameters), -5.0f);
}
TEST(ConversionsTest, unprocessed_filter_objects_multiple_objects) {
TEST_F(NativeCSSConversionsTest, unprocessed_filter_objects_multiple_objects) {
RawValue value{folly::dynamic::array(
folly::dynamic::object("blur", 5)("hue-rotate", "90deg"))};
std::vector<FilterFunction> filters;
parseUnprocessedFilter(
PropsParserContext{-1, ContextContainer{}}, value, filters);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, filters);
EXPECT_TRUE(filters.empty());
}
TEST(ConversionsTest, unprocessed_filter_objects_unknown_type) {
TEST_F(NativeCSSConversionsTest, unprocessed_filter_objects_unknown_type) {
RawValue value{
folly::dynamic::array(folly::dynamic::object("unknown-filter", 5))};
std::vector<FilterFunction> filters;
parseUnprocessedFilter(
PropsParserContext{-1, ContextContainer{}}, value, filters);
fromRawValue(PropsParserContext{-1, ContextContainer{}}, value, filters);
EXPECT_TRUE(filters.empty());
}
@@ -873,7 +873,6 @@ facebook::react::ColorSpace facebook::react::getDefaultColorSpace();
facebook::react::ComponentBuilder facebook::react::simpleComponentBuilder(std::shared_ptr<const facebook::react::ContextContainer> contextContainer = nullptr);
facebook::react::ComponentRegistryFactory facebook::react::getDefaultComponentRegistryFactory();
facebook::react::DisplayType facebook::react::displayTypeFromYGDisplay(YGDisplay display);
facebook::react::FilterType facebook::react::filterTypeFromVariant(const facebook::react::CSSFilterFunction& filter);
facebook::react::Float facebook::react::floatFromYogaFloat(float value);
facebook::react::Float facebook::react::floatFromYogaOptionalFloat(facebook::yoga::FloatOptional value);
facebook::react::LayoutMetrics facebook::react::layoutMetricsFromYogaNode(facebook::yoga::Node& yogaNode);
@@ -895,7 +894,6 @@ facebook::react::SharedColor facebook::react::clearColor();
facebook::react::SharedColor facebook::react::coerceColor(const facebook::react::RawValue& value, const facebook::react::PropsParserContext& context);
facebook::react::SharedColor facebook::react::colorFromComponents(facebook::react::ColorComponents components);
facebook::react::SharedColor facebook::react::colorFromRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
facebook::react::SharedColor facebook::react::fromCSSColor(const facebook::react::CSSColor& cssColor);
facebook::react::SharedColor facebook::react::parsePlatformColor(const facebook::react::ContextContainer& contextContainer, int32_t surfaceId, const facebook::react::RawValue& value);
facebook::react::SharedColor facebook::react::whiteColor();
facebook::react::Size facebook::react::ModalHostViewScreenSize(void);
@@ -947,14 +945,7 @@ size_t facebook::react::attributedStringHashLayoutWise(const facebook::react::At
size_t facebook::react::textAttributesHashLayoutWise(const facebook::react::TextAttributes& textAttributes);
std::function<void(folly::dynamic)> facebook::react::makeCallback(std::weak_ptr<facebook::react::Instance> instance, const folly::dynamic& callbackId);
std::optional<facebook::react::BlendMode> facebook::react::blendModeFromString(std::string_view blendModeName);
std::optional<facebook::react::BoxShadow> facebook::react::fromCSSShadow(const facebook::react::CSSShadow& cssShadow);
std::optional<facebook::react::BoxShadow> facebook::react::parseBoxShadowRawValue(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterFunction> facebook::react::fromCSSFilter(const facebook::react::CSSFilterFunction& cssFilter);
std::optional<facebook::react::FilterFunction> facebook::react::parseDropShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterFunction> facebook::react::parseFilterRawValue(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterType> facebook::react::filterTypeFromString(std::string_view filterName);
std::optional<facebook::react::Float> facebook::react::coerceAmount(const facebook::react::RawValue& value);
std::optional<facebook::react::Float> facebook::react::coerceAngle(const facebook::react::RawValue& value);
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);
@@ -1152,19 +1143,11 @@ void facebook::react::fromString(const std::string& string, facebook::react::Acc
void facebook::react::g_setNativeAnimatedNowTimestampFunction(facebook::react::TimePointFunction nowFunction);
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::parseProcessedBoxShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseProcessedFilter(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::FilterFunction>& 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::parseUnprocessedBoxShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedBoxShadowList(const facebook::react::PropsParserContext& context, std::vector<facebook::react::RawValue>&& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedBoxShadowString(std::string&& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedFilter(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::FilterFunction>& result);
void facebook::react::parseUnprocessedFilterList(const facebook::react::PropsParserContext& context, std::vector<facebook::react::RawValue>&& value, std::vector<facebook::react::FilterFunction>& result);
void facebook::react::parseUnprocessedFilterString(std::string&& value, std::vector<facebook::react::FilterFunction>& 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);
@@ -872,7 +872,6 @@ facebook::react::ColorSpace facebook::react::getDefaultColorSpace();
facebook::react::ComponentBuilder facebook::react::simpleComponentBuilder(std::shared_ptr<const facebook::react::ContextContainer> contextContainer = nullptr);
facebook::react::ComponentRegistryFactory facebook::react::getDefaultComponentRegistryFactory();
facebook::react::DisplayType facebook::react::displayTypeFromYGDisplay(YGDisplay display);
facebook::react::FilterType facebook::react::filterTypeFromVariant(const facebook::react::CSSFilterFunction& filter);
facebook::react::Float facebook::react::floatFromYogaFloat(float value);
facebook::react::Float facebook::react::floatFromYogaOptionalFloat(facebook::yoga::FloatOptional value);
facebook::react::LayoutMetrics facebook::react::layoutMetricsFromYogaNode(facebook::yoga::Node& yogaNode);
@@ -894,7 +893,6 @@ facebook::react::SharedColor facebook::react::clearColor();
facebook::react::SharedColor facebook::react::coerceColor(const facebook::react::RawValue& value, const facebook::react::PropsParserContext& context);
facebook::react::SharedColor facebook::react::colorFromComponents(facebook::react::ColorComponents components);
facebook::react::SharedColor facebook::react::colorFromRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
facebook::react::SharedColor facebook::react::fromCSSColor(const facebook::react::CSSColor& cssColor);
facebook::react::SharedColor facebook::react::parsePlatformColor(const facebook::react::ContextContainer& contextContainer, int32_t surfaceId, const facebook::react::RawValue& value);
facebook::react::SharedColor facebook::react::whiteColor();
facebook::react::Size facebook::react::ModalHostViewScreenSize(void);
@@ -945,14 +943,7 @@ size_t facebook::react::attributedStringHashDisplayWise(const facebook::react::A
size_t facebook::react::attributedStringHashLayoutWise(const facebook::react::AttributedString& attributedString);
size_t facebook::react::textAttributesHashLayoutWise(const facebook::react::TextAttributes& textAttributes);
std::optional<facebook::react::BlendMode> facebook::react::blendModeFromString(std::string_view blendModeName);
std::optional<facebook::react::BoxShadow> facebook::react::fromCSSShadow(const facebook::react::CSSShadow& cssShadow);
std::optional<facebook::react::BoxShadow> facebook::react::parseBoxShadowRawValue(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterFunction> facebook::react::fromCSSFilter(const facebook::react::CSSFilterFunction& cssFilter);
std::optional<facebook::react::FilterFunction> facebook::react::parseDropShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterFunction> facebook::react::parseFilterRawValue(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterType> facebook::react::filterTypeFromString(std::string_view filterName);
std::optional<facebook::react::Float> facebook::react::coerceAmount(const facebook::react::RawValue& value);
std::optional<facebook::react::Float> facebook::react::coerceAngle(const facebook::react::RawValue& value);
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);
@@ -1148,19 +1139,11 @@ void facebook::react::fromString(const std::string& string, facebook::react::Acc
void facebook::react::g_setNativeAnimatedNowTimestampFunction(facebook::react::TimePointFunction nowFunction);
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::parseProcessedBoxShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseProcessedFilter(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::FilterFunction>& 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::parseUnprocessedBoxShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedBoxShadowList(const facebook::react::PropsParserContext& context, std::vector<facebook::react::RawValue>&& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedBoxShadowString(std::string&& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedFilter(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::FilterFunction>& result);
void facebook::react::parseUnprocessedFilterList(const facebook::react::PropsParserContext& context, std::vector<facebook::react::RawValue>&& value, std::vector<facebook::react::FilterFunction>& result);
void facebook::react::parseUnprocessedFilterString(std::string&& value, std::vector<facebook::react::FilterFunction>& 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);
@@ -873,7 +873,6 @@ facebook::react::ColorSpace facebook::react::getDefaultColorSpace();
facebook::react::ComponentBuilder facebook::react::simpleComponentBuilder(std::shared_ptr<const facebook::react::ContextContainer> contextContainer = nullptr);
facebook::react::ComponentRegistryFactory facebook::react::getDefaultComponentRegistryFactory();
facebook::react::DisplayType facebook::react::displayTypeFromYGDisplay(YGDisplay display);
facebook::react::FilterType facebook::react::filterTypeFromVariant(const facebook::react::CSSFilterFunction& filter);
facebook::react::Float facebook::react::floatFromYogaFloat(float value);
facebook::react::Float facebook::react::floatFromYogaOptionalFloat(facebook::yoga::FloatOptional value);
facebook::react::LayoutMetrics facebook::react::layoutMetricsFromYogaNode(facebook::yoga::Node& yogaNode);
@@ -895,7 +894,6 @@ facebook::react::SharedColor facebook::react::clearColor();
facebook::react::SharedColor facebook::react::coerceColor(const facebook::react::RawValue& value, const facebook::react::PropsParserContext& context);
facebook::react::SharedColor facebook::react::colorFromComponents(facebook::react::ColorComponents components);
facebook::react::SharedColor facebook::react::colorFromRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
facebook::react::SharedColor facebook::react::fromCSSColor(const facebook::react::CSSColor& cssColor);
facebook::react::SharedColor facebook::react::parsePlatformColor(const facebook::react::ContextContainer& contextContainer, int32_t surfaceId, const facebook::react::RawValue& value);
facebook::react::SharedColor facebook::react::whiteColor();
facebook::react::Size facebook::react::ModalHostViewScreenSize(void);
@@ -947,14 +945,7 @@ size_t facebook::react::attributedStringHashLayoutWise(const facebook::react::At
size_t facebook::react::textAttributesHashLayoutWise(const facebook::react::TextAttributes& textAttributes);
std::function<void(folly::dynamic)> facebook::react::makeCallback(std::weak_ptr<facebook::react::Instance> instance, const folly::dynamic& callbackId);
std::optional<facebook::react::BlendMode> facebook::react::blendModeFromString(std::string_view blendModeName);
std::optional<facebook::react::BoxShadow> facebook::react::fromCSSShadow(const facebook::react::CSSShadow& cssShadow);
std::optional<facebook::react::BoxShadow> facebook::react::parseBoxShadowRawValue(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterFunction> facebook::react::fromCSSFilter(const facebook::react::CSSFilterFunction& cssFilter);
std::optional<facebook::react::FilterFunction> facebook::react::parseDropShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterFunction> facebook::react::parseFilterRawValue(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterType> facebook::react::filterTypeFromString(std::string_view filterName);
std::optional<facebook::react::Float> facebook::react::coerceAmount(const facebook::react::RawValue& value);
std::optional<facebook::react::Float> facebook::react::coerceAngle(const facebook::react::RawValue& value);
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);
@@ -1152,19 +1143,11 @@ void facebook::react::fromString(const std::string& string, facebook::react::Acc
void facebook::react::g_setNativeAnimatedNowTimestampFunction(facebook::react::TimePointFunction nowFunction);
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::parseProcessedBoxShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseProcessedFilter(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::FilterFunction>& 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::parseUnprocessedBoxShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedBoxShadowList(const facebook::react::PropsParserContext& context, std::vector<facebook::react::RawValue>&& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedBoxShadowString(std::string&& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedFilter(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::FilterFunction>& result);
void facebook::react::parseUnprocessedFilterList(const facebook::react::PropsParserContext& context, std::vector<facebook::react::RawValue>&& value, std::vector<facebook::react::FilterFunction>& result);
void facebook::react::parseUnprocessedFilterString(std::string&& value, std::vector<facebook::react::FilterFunction>& 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);
@@ -3694,7 +3694,6 @@ facebook::react::ColorSpace facebook::react::getDefaultColorSpace();
facebook::react::ComponentBuilder facebook::react::simpleComponentBuilder(std::shared_ptr<const facebook::react::ContextContainer> contextContainer = nullptr);
facebook::react::ComponentRegistryFactory facebook::react::getDefaultComponentRegistryFactory();
facebook::react::DisplayType facebook::react::displayTypeFromYGDisplay(YGDisplay display);
facebook::react::FilterType facebook::react::filterTypeFromVariant(const facebook::react::CSSFilterFunction& filter);
facebook::react::Float facebook::react::floatFromYogaFloat(float value);
facebook::react::Float facebook::react::floatFromYogaOptionalFloat(facebook::yoga::FloatOptional value);
facebook::react::LayoutMetrics facebook::react::layoutMetricsFromYogaNode(facebook::yoga::Node& yogaNode);
@@ -3709,7 +3708,6 @@ facebook::react::SharedColor facebook::react::clearColor();
facebook::react::SharedColor facebook::react::coerceColor(const facebook::react::RawValue& value, const facebook::react::PropsParserContext& context);
facebook::react::SharedColor facebook::react::colorFromComponents(facebook::react::ColorComponents components);
facebook::react::SharedColor facebook::react::colorFromRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
facebook::react::SharedColor facebook::react::fromCSSColor(const facebook::react::CSSColor& cssColor);
facebook::react::SharedColor facebook::react::parsePlatformColor(const facebook::react::ContextContainer& contextContainer, int32_t surfaceId, const facebook::react::RawValue& value);
facebook::react::SharedColor facebook::react::whiteColor();
facebook::react::Size facebook::react::ModalHostViewScreenSize(void);
@@ -3745,14 +3743,7 @@ size_t facebook::react::attributedStringHashLayoutWise(const facebook::react::At
size_t facebook::react::textAttributesHashLayoutWise(const facebook::react::TextAttributes& textAttributes);
std::function<void(folly::dynamic)> facebook::react::makeCallback(std::weak_ptr<facebook::react::Instance> instance, const folly::dynamic& callbackId);
std::optional<facebook::react::BlendMode> facebook::react::blendModeFromString(std::string_view blendModeName);
std::optional<facebook::react::BoxShadow> facebook::react::fromCSSShadow(const facebook::react::CSSShadow& cssShadow);
std::optional<facebook::react::BoxShadow> facebook::react::parseBoxShadowRawValue(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterFunction> facebook::react::fromCSSFilter(const facebook::react::CSSFilterFunction& cssFilter);
std::optional<facebook::react::FilterFunction> facebook::react::parseDropShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterFunction> facebook::react::parseFilterRawValue(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterType> facebook::react::filterTypeFromString(std::string_view filterName);
std::optional<facebook::react::Float> facebook::react::coerceAmount(const facebook::react::RawValue& value);
std::optional<facebook::react::Float> facebook::react::coerceAngle(const facebook::react::RawValue& value);
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);
@@ -3952,19 +3943,11 @@ 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::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::parseProcessedBoxShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseProcessedFilter(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::FilterFunction>& 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::parseUnprocessedBoxShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedBoxShadowList(const facebook::react::PropsParserContext& context, std::vector<facebook::react::RawValue>&& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedBoxShadowString(std::string&& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedFilter(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::FilterFunction>& result);
void facebook::react::parseUnprocessedFilterList(const facebook::react::PropsParserContext& context, std::vector<facebook::react::RawValue>&& value, std::vector<facebook::react::FilterFunction>& result);
void facebook::react::parseUnprocessedFilterString(std::string&& value, std::vector<facebook::react::FilterFunction>& 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);
@@ -3685,7 +3685,6 @@ facebook::react::ColorSpace facebook::react::getDefaultColorSpace();
facebook::react::ComponentBuilder facebook::react::simpleComponentBuilder(std::shared_ptr<const facebook::react::ContextContainer> contextContainer = nullptr);
facebook::react::ComponentRegistryFactory facebook::react::getDefaultComponentRegistryFactory();
facebook::react::DisplayType facebook::react::displayTypeFromYGDisplay(YGDisplay display);
facebook::react::FilterType facebook::react::filterTypeFromVariant(const facebook::react::CSSFilterFunction& filter);
facebook::react::Float facebook::react::floatFromYogaFloat(float value);
facebook::react::Float facebook::react::floatFromYogaOptionalFloat(facebook::yoga::FloatOptional value);
facebook::react::LayoutMetrics facebook::react::layoutMetricsFromYogaNode(facebook::yoga::Node& yogaNode);
@@ -3700,7 +3699,6 @@ facebook::react::SharedColor facebook::react::clearColor();
facebook::react::SharedColor facebook::react::coerceColor(const facebook::react::RawValue& value, const facebook::react::PropsParserContext& context);
facebook::react::SharedColor facebook::react::colorFromComponents(facebook::react::ColorComponents components);
facebook::react::SharedColor facebook::react::colorFromRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
facebook::react::SharedColor facebook::react::fromCSSColor(const facebook::react::CSSColor& cssColor);
facebook::react::SharedColor facebook::react::parsePlatformColor(const facebook::react::ContextContainer& contextContainer, int32_t surfaceId, const facebook::react::RawValue& value);
facebook::react::SharedColor facebook::react::whiteColor();
facebook::react::Size facebook::react::ModalHostViewScreenSize(void);
@@ -3735,14 +3733,7 @@ size_t facebook::react::attributedStringHashDisplayWise(const facebook::react::A
size_t facebook::react::attributedStringHashLayoutWise(const facebook::react::AttributedString& attributedString);
size_t facebook::react::textAttributesHashLayoutWise(const facebook::react::TextAttributes& textAttributes);
std::optional<facebook::react::BlendMode> facebook::react::blendModeFromString(std::string_view blendModeName);
std::optional<facebook::react::BoxShadow> facebook::react::fromCSSShadow(const facebook::react::CSSShadow& cssShadow);
std::optional<facebook::react::BoxShadow> facebook::react::parseBoxShadowRawValue(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterFunction> facebook::react::fromCSSFilter(const facebook::react::CSSFilterFunction& cssFilter);
std::optional<facebook::react::FilterFunction> facebook::react::parseDropShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterFunction> facebook::react::parseFilterRawValue(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterType> facebook::react::filterTypeFromString(std::string_view filterName);
std::optional<facebook::react::Float> facebook::react::coerceAmount(const facebook::react::RawValue& value);
std::optional<facebook::react::Float> facebook::react::coerceAngle(const facebook::react::RawValue& value);
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);
@@ -3941,19 +3932,11 @@ 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::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::parseProcessedBoxShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseProcessedFilter(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::FilterFunction>& 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::parseUnprocessedBoxShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedBoxShadowList(const facebook::react::PropsParserContext& context, std::vector<facebook::react::RawValue>&& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedBoxShadowString(std::string&& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedFilter(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::FilterFunction>& result);
void facebook::react::parseUnprocessedFilterList(const facebook::react::PropsParserContext& context, std::vector<facebook::react::RawValue>&& value, std::vector<facebook::react::FilterFunction>& result);
void facebook::react::parseUnprocessedFilterString(std::string&& value, std::vector<facebook::react::FilterFunction>& 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);
@@ -3694,7 +3694,6 @@ facebook::react::ColorSpace facebook::react::getDefaultColorSpace();
facebook::react::ComponentBuilder facebook::react::simpleComponentBuilder(std::shared_ptr<const facebook::react::ContextContainer> contextContainer = nullptr);
facebook::react::ComponentRegistryFactory facebook::react::getDefaultComponentRegistryFactory();
facebook::react::DisplayType facebook::react::displayTypeFromYGDisplay(YGDisplay display);
facebook::react::FilterType facebook::react::filterTypeFromVariant(const facebook::react::CSSFilterFunction& filter);
facebook::react::Float facebook::react::floatFromYogaFloat(float value);
facebook::react::Float facebook::react::floatFromYogaOptionalFloat(facebook::yoga::FloatOptional value);
facebook::react::LayoutMetrics facebook::react::layoutMetricsFromYogaNode(facebook::yoga::Node& yogaNode);
@@ -3709,7 +3708,6 @@ facebook::react::SharedColor facebook::react::clearColor();
facebook::react::SharedColor facebook::react::coerceColor(const facebook::react::RawValue& value, const facebook::react::PropsParserContext& context);
facebook::react::SharedColor facebook::react::colorFromComponents(facebook::react::ColorComponents components);
facebook::react::SharedColor facebook::react::colorFromRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
facebook::react::SharedColor facebook::react::fromCSSColor(const facebook::react::CSSColor& cssColor);
facebook::react::SharedColor facebook::react::parsePlatformColor(const facebook::react::ContextContainer& contextContainer, int32_t surfaceId, const facebook::react::RawValue& value);
facebook::react::SharedColor facebook::react::whiteColor();
facebook::react::Size facebook::react::ModalHostViewScreenSize(void);
@@ -3745,14 +3743,7 @@ size_t facebook::react::attributedStringHashLayoutWise(const facebook::react::At
size_t facebook::react::textAttributesHashLayoutWise(const facebook::react::TextAttributes& textAttributes);
std::function<void(folly::dynamic)> facebook::react::makeCallback(std::weak_ptr<facebook::react::Instance> instance, const folly::dynamic& callbackId);
std::optional<facebook::react::BlendMode> facebook::react::blendModeFromString(std::string_view blendModeName);
std::optional<facebook::react::BoxShadow> facebook::react::fromCSSShadow(const facebook::react::CSSShadow& cssShadow);
std::optional<facebook::react::BoxShadow> facebook::react::parseBoxShadowRawValue(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterFunction> facebook::react::fromCSSFilter(const facebook::react::CSSFilterFunction& cssFilter);
std::optional<facebook::react::FilterFunction> facebook::react::parseDropShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterFunction> facebook::react::parseFilterRawValue(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterType> facebook::react::filterTypeFromString(std::string_view filterName);
std::optional<facebook::react::Float> facebook::react::coerceAmount(const facebook::react::RawValue& value);
std::optional<facebook::react::Float> facebook::react::coerceAngle(const facebook::react::RawValue& value);
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);
@@ -3952,19 +3943,11 @@ 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::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::parseProcessedBoxShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseProcessedFilter(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::FilterFunction>& 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::parseUnprocessedBoxShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedBoxShadowList(const facebook::react::PropsParserContext& context, std::vector<facebook::react::RawValue>&& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedBoxShadowString(std::string&& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedFilter(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::FilterFunction>& result);
void facebook::react::parseUnprocessedFilterList(const facebook::react::PropsParserContext& context, std::vector<facebook::react::RawValue>&& value, std::vector<facebook::react::FilterFunction>& result);
void facebook::react::parseUnprocessedFilterString(std::string&& value, std::vector<facebook::react::FilterFunction>& 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);
@@ -477,7 +477,6 @@ facebook::react::ColorSpace facebook::react::getDefaultColorSpace();
facebook::react::ComponentBuilder facebook::react::simpleComponentBuilder(std::shared_ptr<const facebook::react::ContextContainer> contextContainer = nullptr);
facebook::react::ComponentRegistryFactory facebook::react::getDefaultComponentRegistryFactory();
facebook::react::DisplayType facebook::react::displayTypeFromYGDisplay(YGDisplay display);
facebook::react::FilterType facebook::react::filterTypeFromVariant(const facebook::react::CSSFilterFunction& filter);
facebook::react::LayoutMetrics facebook::react::layoutMetricsFromYogaNode(facebook::yoga::Node& yogaNode);
facebook::react::ParagraphAttributes facebook::react::convertRawProp(const facebook::react::PropsParserContext& context, const facebook::react::RawProps& rawProps, const facebook::react::ParagraphAttributes& sourceParagraphAttributes, const facebook::react::ParagraphAttributes& defaultParagraphAttributes);
facebook::react::Rect facebook::react::insetBy(const facebook::react::Rect& rect, const facebook::react::EdgeInsets& insets) noexcept;
@@ -490,7 +489,6 @@ facebook::react::SharedColor facebook::react::clearColor();
facebook::react::SharedColor facebook::react::coerceColor(const facebook::react::RawValue& value, const facebook::react::PropsParserContext& context);
facebook::react::SharedColor facebook::react::colorFromComponents(facebook::react::ColorComponents components);
facebook::react::SharedColor facebook::react::colorFromRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
facebook::react::SharedColor facebook::react::fromCSSColor(const facebook::react::CSSColor& cssColor);
facebook::react::SharedColor facebook::react::whiteColor();
facebook::react::Size facebook::react::ModalHostViewScreenSize(void);
facebook::react::Size facebook::react::yogaMeassureToSize(int64_t value);
@@ -518,17 +516,10 @@ size_t facebook::react::attributedStringHashDisplayWise(const facebook::react::A
size_t facebook::react::attributedStringHashLayoutWise(const facebook::react::AttributedString& attributedString);
size_t facebook::react::textAttributesHashLayoutWise(const facebook::react::TextAttributes& textAttributes);
std::function<void(folly::dynamic)> facebook::react::makeCallback(std::weak_ptr<facebook::react::Instance> instance, const folly::dynamic& callbackId);
std::optional<Float> facebook::react::coerceAmount(const facebook::react::RawValue& value);
std::optional<Float> facebook::react::coerceAngle(const facebook::react::RawValue& value);
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::BoxShadow> facebook::react::fromCSSShadow(const facebook::react::CSSShadow& cssShadow);
std::optional<facebook::react::BoxShadow> facebook::react::parseBoxShadowRawValue(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterFunction> facebook::react::fromCSSFilter(const facebook::react::CSSFilterFunction& cssFilter);
std::optional<facebook::react::FilterFunction> facebook::react::parseDropShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterFunction> facebook::react::parseFilterRawValue(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
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);
@@ -712,19 +703,11 @@ void facebook::react::fromString(const std::string& string, facebook::react::Acc
void facebook::react::g_setNativeAnimatedNowTimestampFunction(facebook::react::TimePointFunction nowFunction);
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::parseProcessedBoxShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseProcessedFilter(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::FilterFunction>& 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::parseUnprocessedBoxShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedBoxShadowList(const facebook::react::PropsParserContext& context, std::vector<facebook::react::RawValue>&& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedBoxShadowString(std::string&& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedFilter(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::FilterFunction>& result);
void facebook::react::parseUnprocessedFilterList(const facebook::react::PropsParserContext& context, std::vector<facebook::react::RawValue>&& value, std::vector<facebook::react::FilterFunction>& result);
void facebook::react::parseUnprocessedFilterString(std::string&& value, std::vector<facebook::react::FilterFunction>& 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);
@@ -476,7 +476,6 @@ facebook::react::ColorSpace facebook::react::getDefaultColorSpace();
facebook::react::ComponentBuilder facebook::react::simpleComponentBuilder(std::shared_ptr<const facebook::react::ContextContainer> contextContainer = nullptr);
facebook::react::ComponentRegistryFactory facebook::react::getDefaultComponentRegistryFactory();
facebook::react::DisplayType facebook::react::displayTypeFromYGDisplay(YGDisplay display);
facebook::react::FilterType facebook::react::filterTypeFromVariant(const facebook::react::CSSFilterFunction& filter);
facebook::react::LayoutMetrics facebook::react::layoutMetricsFromYogaNode(facebook::yoga::Node& yogaNode);
facebook::react::ParagraphAttributes facebook::react::convertRawProp(const facebook::react::PropsParserContext& context, const facebook::react::RawProps& rawProps, const facebook::react::ParagraphAttributes& sourceParagraphAttributes, const facebook::react::ParagraphAttributes& defaultParagraphAttributes);
facebook::react::Rect facebook::react::insetBy(const facebook::react::Rect& rect, const facebook::react::EdgeInsets& insets) noexcept;
@@ -489,7 +488,6 @@ facebook::react::SharedColor facebook::react::clearColor();
facebook::react::SharedColor facebook::react::coerceColor(const facebook::react::RawValue& value, const facebook::react::PropsParserContext& context);
facebook::react::SharedColor facebook::react::colorFromComponents(facebook::react::ColorComponents components);
facebook::react::SharedColor facebook::react::colorFromRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
facebook::react::SharedColor facebook::react::fromCSSColor(const facebook::react::CSSColor& cssColor);
facebook::react::SharedColor facebook::react::whiteColor();
facebook::react::Size facebook::react::ModalHostViewScreenSize(void);
facebook::react::Size facebook::react::yogaMeassureToSize(int64_t value);
@@ -516,17 +514,10 @@ size_t facebook::react::attributedStringFragmentHashLayoutWise(const facebook::r
size_t facebook::react::attributedStringHashDisplayWise(const facebook::react::AttributedString& attributedString);
size_t facebook::react::attributedStringHashLayoutWise(const facebook::react::AttributedString& attributedString);
size_t facebook::react::textAttributesHashLayoutWise(const facebook::react::TextAttributes& textAttributes);
std::optional<Float> facebook::react::coerceAmount(const facebook::react::RawValue& value);
std::optional<Float> facebook::react::coerceAngle(const facebook::react::RawValue& value);
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::BoxShadow> facebook::react::fromCSSShadow(const facebook::react::CSSShadow& cssShadow);
std::optional<facebook::react::BoxShadow> facebook::react::parseBoxShadowRawValue(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterFunction> facebook::react::fromCSSFilter(const facebook::react::CSSFilterFunction& cssFilter);
std::optional<facebook::react::FilterFunction> facebook::react::parseDropShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterFunction> facebook::react::parseFilterRawValue(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
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);
@@ -709,19 +700,11 @@ void facebook::react::fromString(const std::string& string, facebook::react::Acc
void facebook::react::g_setNativeAnimatedNowTimestampFunction(facebook::react::TimePointFunction nowFunction);
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::parseProcessedBoxShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseProcessedFilter(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::FilterFunction>& 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::parseUnprocessedBoxShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedBoxShadowList(const facebook::react::PropsParserContext& context, std::vector<facebook::react::RawValue>&& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedBoxShadowString(std::string&& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedFilter(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::FilterFunction>& result);
void facebook::react::parseUnprocessedFilterList(const facebook::react::PropsParserContext& context, std::vector<facebook::react::RawValue>&& value, std::vector<facebook::react::FilterFunction>& result);
void facebook::react::parseUnprocessedFilterString(std::string&& value, std::vector<facebook::react::FilterFunction>& 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);
@@ -477,7 +477,6 @@ facebook::react::ColorSpace facebook::react::getDefaultColorSpace();
facebook::react::ComponentBuilder facebook::react::simpleComponentBuilder(std::shared_ptr<const facebook::react::ContextContainer> contextContainer = nullptr);
facebook::react::ComponentRegistryFactory facebook::react::getDefaultComponentRegistryFactory();
facebook::react::DisplayType facebook::react::displayTypeFromYGDisplay(YGDisplay display);
facebook::react::FilterType facebook::react::filterTypeFromVariant(const facebook::react::CSSFilterFunction& filter);
facebook::react::LayoutMetrics facebook::react::layoutMetricsFromYogaNode(facebook::yoga::Node& yogaNode);
facebook::react::ParagraphAttributes facebook::react::convertRawProp(const facebook::react::PropsParserContext& context, const facebook::react::RawProps& rawProps, const facebook::react::ParagraphAttributes& sourceParagraphAttributes, const facebook::react::ParagraphAttributes& defaultParagraphAttributes);
facebook::react::Rect facebook::react::insetBy(const facebook::react::Rect& rect, const facebook::react::EdgeInsets& insets) noexcept;
@@ -490,7 +489,6 @@ facebook::react::SharedColor facebook::react::clearColor();
facebook::react::SharedColor facebook::react::coerceColor(const facebook::react::RawValue& value, const facebook::react::PropsParserContext& context);
facebook::react::SharedColor facebook::react::colorFromComponents(facebook::react::ColorComponents components);
facebook::react::SharedColor facebook::react::colorFromRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a);
facebook::react::SharedColor facebook::react::fromCSSColor(const facebook::react::CSSColor& cssColor);
facebook::react::SharedColor facebook::react::whiteColor();
facebook::react::Size facebook::react::ModalHostViewScreenSize(void);
facebook::react::Size facebook::react::yogaMeassureToSize(int64_t value);
@@ -518,17 +516,10 @@ size_t facebook::react::attributedStringHashDisplayWise(const facebook::react::A
size_t facebook::react::attributedStringHashLayoutWise(const facebook::react::AttributedString& attributedString);
size_t facebook::react::textAttributesHashLayoutWise(const facebook::react::TextAttributes& textAttributes);
std::function<void(folly::dynamic)> facebook::react::makeCallback(std::weak_ptr<facebook::react::Instance> instance, const folly::dynamic& callbackId);
std::optional<Float> facebook::react::coerceAmount(const facebook::react::RawValue& value);
std::optional<Float> facebook::react::coerceAngle(const facebook::react::RawValue& value);
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::BoxShadow> facebook::react::fromCSSShadow(const facebook::react::CSSShadow& cssShadow);
std::optional<facebook::react::BoxShadow> facebook::react::parseBoxShadowRawValue(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterFunction> facebook::react::fromCSSFilter(const facebook::react::CSSFilterFunction& cssFilter);
std::optional<facebook::react::FilterFunction> facebook::react::parseDropShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
std::optional<facebook::react::FilterFunction> facebook::react::parseFilterRawValue(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value);
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);
@@ -712,19 +703,11 @@ void facebook::react::fromString(const std::string& string, facebook::react::Acc
void facebook::react::g_setNativeAnimatedNowTimestampFunction(facebook::react::TimePointFunction nowFunction);
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::parseProcessedBoxShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseProcessedFilter(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::FilterFunction>& 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::parseUnprocessedBoxShadow(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedBoxShadowList(const facebook::react::PropsParserContext& context, std::vector<facebook::react::RawValue>&& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedBoxShadowString(std::string&& value, std::vector<facebook::react::BoxShadow>& result);
void facebook::react::parseUnprocessedFilter(const facebook::react::PropsParserContext& context, const facebook::react::RawValue& value, std::vector<facebook::react::FilterFunction>& result);
void facebook::react::parseUnprocessedFilterList(const facebook::react::PropsParserContext& context, std::vector<facebook::react::RawValue>&& value, std::vector<facebook::react::FilterFunction>& result);
void facebook::react::parseUnprocessedFilterString(std::string&& value, std::vector<facebook::react::FilterFunction>& 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);