@depup/react-native 0.84.1-depup.2 → 0.85.0-depup.0

package/ReactCommon/react/renderer/components/view/BackgroundImagePropsConversions.cpp

@@ -119,14 +119,12 @@ void parseProcessedBackgroundImage(
           std::string directionType = (std::string)(directionTypeIt->second);
 
           if (directionType == "angle") {
-            linearGradient.direction.type = GradientDirectionType::Angle;
             if (valueIt->second.hasType<Float>()) {
-              linearGradient.direction.value = (Float)(valueIt->second);
+              linearGradient.direction = (Float)(valueIt->second);
             }
           } else if (directionType == "keyword") {
-            linearGradient.direction.type = GradientDirectionType::Keyword;
             if (valueIt->second.hasType<std::string>()) {
-              linearGradient.direction.value =
+              linearGradient.direction =
                   parseGradientKeyword((std::string)(valueIt->second));
             }
           }
@@ -309,30 +307,26 @@ void parseUnprocessedBackgroundImageList(
                 std::get<CSSLinearGradientDirection>(cssDirection);
 
             if (std::holds_alternative<CSSAngle>(direction.value)) {
-              linearGradient.direction.type = GradientDirectionType::Angle;
-              linearGradient.direction.value =
+              linearGradient.direction =
                   std::get<CSSAngle>(direction.value).degrees;
             } else if (std::holds_alternative<
                            CSSLinearGradientDirectionKeyword>(
                            direction.value)) {
-              linearGradient.direction.type = GradientDirectionType::Keyword;
               auto keyword =
                   std::get<CSSLinearGradientDirectionKeyword>(direction.value);
 
               switch (keyword) {
                 case CSSLinearGradientDirectionKeyword::ToTopLeft:
-                  linearGradient.direction.value = GradientKeyword::ToTopLeft;
+                  linearGradient.direction = GradientKeyword::ToTopLeft;
                   break;
                 case CSSLinearGradientDirectionKeyword::ToTopRight:
-                  linearGradient.direction.value = GradientKeyword::ToTopRight;
+                  linearGradient.direction = GradientKeyword::ToTopRight;
                   break;
                 case CSSLinearGradientDirectionKeyword::ToBottomLeft:
-                  linearGradient.direction.value =
-                      GradientKeyword::ToBottomLeft;
+                  linearGradient.direction = GradientKeyword::ToBottomLeft;
                   break;
                 case CSSLinearGradientDirectionKeyword::ToBottomRight:
-                  linearGradient.direction.value =
-                      GradientKeyword::ToBottomRight;
+                  linearGradient.direction = GradientKeyword::ToBottomRight;
                   break;
               }
             }
@@ -477,7 +471,7 @@ void fromCSSColorStop(
 }
 
 std::optional<BackgroundImage> fromCSSBackgroundImage(
-    const CSSBackgroundImageVariant& cssBackgroundImage) {
+    const CSSBackgroundImage& cssBackgroundImage) {
   if (std::holds_alternative<CSSLinearGradientFunction>(cssBackgroundImage)) {
     const auto& gradient =
         std::get<CSSLinearGradientFunction>(cssBackgroundImage);
@@ -486,26 +480,23 @@ std::optional<BackgroundImage> fromCSSBackgroundImage(
     if (gradient.direction.has_value()) {
       if (std::holds_alternative<CSSAngle>(gradient.direction->value)) {
         const auto& angle = std::get<CSSAngle>(gradient.direction->value);
-        linearGradient.direction.type = GradientDirectionType::Angle;
-        linearGradient.direction.value = angle.degrees;
+        linearGradient.direction = angle.degrees;
       } else if (std::holds_alternative<CSSLinearGradientDirectionKeyword>(
                      gradient.direction->value)) {
         const auto& dirKeyword = std::get<CSSLinearGradientDirectionKeyword>(
             gradient.direction->value);
-        linearGradient.direction.type = GradientDirectionType::Keyword;
-
         switch (dirKeyword) {
           case CSSLinearGradientDirectionKeyword::ToTopLeft:
-            linearGradient.direction.value = GradientKeyword::ToTopLeft;
+            linearGradient.direction = GradientKeyword::ToTopLeft;
             break;
           case CSSLinearGradientDirectionKeyword::ToTopRight:
-            linearGradient.direction.value = GradientKeyword::ToTopRight;
+            linearGradient.direction = GradientKeyword::ToTopRight;
             break;
           case CSSLinearGradientDirectionKeyword::ToBottomLeft:
-            linearGradient.direction.value = GradientKeyword::ToBottomLeft;
+            linearGradient.direction = GradientKeyword::ToBottomLeft;
             break;
           case CSSLinearGradientDirectionKeyword::ToBottomRight:
-            linearGradient.direction.value = GradientKeyword::ToBottomRight;
+            linearGradient.direction = GradientKeyword::ToBottomRight;
             break;
         }
       }
@@ -606,14 +597,14 @@ void parseUnprocessedBackgroundImageString(
   for (const auto& cssBackgroundImage :
        std::get<CSSBackgroundImageList>(backgroundImageList)) {
     if (auto backgroundImage = fromCSSBackgroundImage(cssBackgroundImage)) {
-      backgroundImages.push_back(*backgroundImage);
+      backgroundImages.push_back(std::move(*backgroundImage));
     } else {
       result = {};
       return;
     }
   }
 
-  result = backgroundImages;
+  result = std::move(backgroundImages);
 }
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/components/view/BaseTouch.h

@@ -22,39 +22,39 @@ struct BaseTouch {
   /*
    * The coordinate of point relative to the root component in points.
    */
-  Point pagePoint;
+  Point pagePoint{};
 
   /*
    * The coordinate of point relative to the target component in points.
    */
-  Point offsetPoint;
+  Point offsetPoint{};
 
   /*
    * The coordinate of point relative to the screen component in points.
    */
-  Point screenPoint;
+  Point screenPoint{};
 
   /*
    * An identification number for each touch point.
    */
-  int identifier;
+  int identifier{0};
 
   /*
    * The tag of a component on which the touch point started when it was first
    * placed on the surface, even if the touch point has since moved outside the
    * interactive area of that element.
    */
-  Tag target;
+  Tag target{0};
 
   /*
    * The force of the touch.
    */
-  Float force;
+  Float force{0.0f};
 
   /*
    * The time in seconds when the touch occurred or when it was last mutated.
    */
-  Float timestamp;
+  Float timestamp{0.0f};
 
   /*
    * The particular implementation of `Hasher` and (especially) `Comparator`

package/ReactCommon/react/renderer/components/view/ConcreteViewShadowNode.h

@@ -12,10 +12,7 @@
 #include <react/renderer/components/view/ViewProps.h>
 #include <react/renderer/components/view/YogaLayoutableShadowNode.h>
 #include <react/renderer/core/ConcreteShadowNode.h>
-#include <react/renderer/core/LayoutableShadowNode.h>
-#include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/core/ShadowNodeFragment.h>
-#include <react/renderer/debug/DebugStringConvertibleItem.h>
 #include <type_traits>
 
 namespace facebook::react {

package/ReactCommon/react/renderer/components/view/FilterPropsConversions.h

@@ -45,70 +45,70 @@ parseProcessedFilter(const PropsParserContext &context, const RawValue &value, s
 
     auto rawFilterFunction = static_cast<std::unordered_map<std::string, RawValue>>(rawFilterPrimitive);
     FilterFunction filterFunction{};
-    try {
-      filterFunction.type = filterTypeFromString(rawFilterFunction.begin()->first);
-      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;
-        }
+    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;
+      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>()) {
+      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.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);
-        }
+        dropShadowParams.standardDeviation = (Float)standardDeviation->second;
+      }
 
-        filterFunction.parameters = dropShadowParams;
-      } else {
-        filterFunction.parameters = (float)rawFilterFunction.begin()->second;
+      auto color = rawDropShadow.find("color");
+      if (color != rawDropShadow.end()) {
+        fromRawValue(context.contextContainer, context.surfaceId, color->second, dropShadowParams.color);
       }
-      filter.push_back(std::move(filterFunction));
-    } catch (const std::exception &e) {
-      LOG(ERROR) << "Could not parse FilterFunction: " << e.what();
-      result = {};
-      return;
+
+      filterFunction.parameters = dropShadowParams;
+    } else {
+      filterFunction.parameters = (float)rawFilterFunction.begin()->second;
     }
+    filter.push_back(filterFunction);
   }
 
   result = filter;
 }
 
-inline FilterType filterTypeFromVariant(const CSSFilterFunctionVariant &filter)
+inline FilterType filterTypeFromVariant(const CSSFilterFunction &filter)
 {
   return std::visit(
       [](auto &&filter) -> FilterType {
@@ -148,7 +148,7 @@ inline FilterType filterTypeFromVariant(const CSSFilterFunctionVariant &filter)
       filter);
 }
 
-inline std::optional<FilterFunction> fromCSSFilter(const CSSFilterFunctionVariant &cssFilter)
+inline std::optional<FilterFunction> fromCSSFilter(const CSSFilterFunction &cssFilter)
 {
   return std::visit(
       [&](auto &&filter) -> std::optional<FilterFunction> {
@@ -313,11 +313,15 @@ inline std::optional<FilterFunction> parseFilterRawValue(const PropsParserContex
     }
     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 = filterTypeFromString(filterKey), .parameters = *amount};
+      return FilterFunction{.type = *filterType, .parameters = *amount};
     }
     return {};
   }

package/ReactCommon/react/renderer/components/view/ViewShadowNode.cpp

@@ -48,6 +48,7 @@ void ViewShadowNode::initialize() noexcept {
   };
 
   bool formsStackingContext = !viewProps.collapsable ||
+      viewProps.pointerEvents == PointerEventsMode::BoxOnly ||
       viewProps.pointerEvents == PointerEventsMode::None ||
       !viewProps.nativeId.empty() || viewProps.accessible ||
       viewProps.opacity != 1.0 || viewProps.transform != Transform{} ||

package/ReactCommon/react/renderer/components/view/conversions.h

@@ -9,6 +9,7 @@
 
 #include <glog/logging.h>
 #include <react/debug/react_native_expect.h>
+#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/components/view/primitives.h>
 #include <react/renderer/core/LayoutMetrics.h>
 #include <react/renderer/core/PropsParserContext.h>
@@ -17,6 +18,9 @@
 #include <react/renderer/css/CSSAngle.h>
 #include <react/renderer/css/CSSNumber.h>
 #include <react/renderer/css/CSSPercentage.h>
+#include <react/renderer/css/CSSRatio.h>
+#include <react/renderer/css/CSSTransform.h>
+#include <react/renderer/css/CSSTransformOrigin.h>
 #include <react/renderer/css/CSSValueParser.h>
 #include <react/renderer/debug/flags.h>
 #include <react/renderer/graphics/BackgroundPosition.h>
@@ -533,7 +537,136 @@ inline void fromRawValue(const PropsParserContext & /*context*/, const RawValue
   result = toValueUnit(value);
 }
 
-inline void fromRawValue(const PropsParserContext & /*context*/, const RawValue &value, Transform &result)
+inline ValueUnit cssLengthPercentageToValueUnit(const std::variant<CSSLength, CSSPercentage> &value)
+{
+  if (std::holds_alternative<CSSLength>(value)) {
+    auto len = std::get<CSSLength>(value);
+    if (len.unit != CSSLengthUnit::Px) {
+      return {};
+    }
+    return {len.value, UnitType::Point};
+  } else {
+    return {std::get<CSSPercentage>(value).value, UnitType::Percent};
+  }
+}
+
+inline std::optional<TransformOperation> fromCSSTransformFunction(const CSSTransformFunction &cssTransform)
+{
+  constexpr auto Zero = ValueUnit(0, UnitType::Point);
+  constexpr auto One = ValueUnit(1, UnitType::Point);
+
+  return std::visit(
+      [&](auto &&func) -> std::optional<TransformOperation> {
+        using T = std::decay_t<decltype(func)>;
+
+        if constexpr (std::is_same_v<T, CSSRotate>) {
+          auto radians = static_cast<float>(func.degrees * M_PI / 180.0f);
+          return TransformOperation{
+              .type = TransformOperationType::Rotate, .x = Zero, .y = Zero, .z = ValueUnit(radians, UnitType::Point)};
+        }
+
+        if constexpr (std::is_same_v<T, CSSRotateX>) {
+          auto radians = static_cast<float>(func.degrees * M_PI / 180.0f);
+          return TransformOperation{
+              .type = TransformOperationType::Rotate, .x = ValueUnit(radians, UnitType::Point), .y = Zero, .z = Zero};
+        }
+
+        if constexpr (std::is_same_v<T, CSSRotateY>) {
+          auto radians = static_cast<float>(func.degrees * M_PI / 180.0f);
+          return TransformOperation{
+              .type = TransformOperationType::Rotate, .x = Zero, .y = ValueUnit(radians, UnitType::Point), .z = Zero};
+        }
+
+        if constexpr (std::is_same_v<T, CSSRotateZ>) {
+          auto radians = static_cast<float>(func.degrees * M_PI / 180.0f);
+          return TransformOperation{
+              .type = TransformOperationType::Rotate, .x = Zero, .y = Zero, .z = ValueUnit(radians, UnitType::Point)};
+        }
+
+        if constexpr (std::is_same_v<T, CSSTranslate>) {
+          auto x = cssLengthPercentageToValueUnit(func.x);
+          auto y = cssLengthPercentageToValueUnit(func.y);
+          if (!x || !y) {
+            return std::nullopt;
+          }
+          return TransformOperation{.type = TransformOperationType::Translate, .x = x, .y = y, .z = Zero};
+        }
+
+        if constexpr (std::is_same_v<T, CSSTranslateX>) {
+          auto x = cssLengthPercentageToValueUnit(func.value);
+          if (!x) {
+            return std::nullopt;
+          }
+          return TransformOperation{.type = TransformOperationType::Translate, .x = x, .y = Zero, .z = Zero};
+        }
+
+        if constexpr (std::is_same_v<T, CSSTranslateY>) {
+          auto y = cssLengthPercentageToValueUnit(func.value);
+          if (!y) {
+            return std::nullopt;
+          }
+          return TransformOperation{.type = TransformOperationType::Translate, .x = Zero, .y = y, .z = Zero};
+        }
+
+        if constexpr (std::is_same_v<T, CSSTranslate3D>) {
+          auto x = cssLengthPercentageToValueUnit(func.x);
+          auto y = cssLengthPercentageToValueUnit(func.y);
+          if (!x || !y || func.z.unit != CSSLengthUnit::Px) {
+            return std::nullopt;
+          }
+          return TransformOperation{
+              .type = TransformOperationType::Translate, .x = x, .y = y, .z = ValueUnit(func.z.value, UnitType::Point)};
+        }
+
+        if constexpr (std::is_same_v<T, CSSScale>) {
+          return TransformOperation{
+              .type = TransformOperationType::Scale,
+              .x = ValueUnit(func.x, UnitType::Point),
+              .y = ValueUnit(func.y, UnitType::Point),
+              .z = One};
+        }
+
+        if constexpr (std::is_same_v<T, CSSScaleX>) {
+          return TransformOperation{
+              .type = TransformOperationType::Scale, .x = ValueUnit(func.value, UnitType::Point), .y = One, .z = One};
+        }
+
+        if constexpr (std::is_same_v<T, CSSScaleY>) {
+          return TransformOperation{
+              .type = TransformOperationType::Scale, .x = One, .y = ValueUnit(func.value, UnitType::Point), .z = One};
+        }
+
+        if constexpr (std::is_same_v<T, CSSSkewX>) {
+          auto radians = static_cast<float>(func.degrees * M_PI / 180.0f);
+          return TransformOperation{
+              .type = TransformOperationType::Skew, .x = ValueUnit(radians, UnitType::Point), .y = Zero, .z = Zero};
+        }
+
+        if constexpr (std::is_same_v<T, CSSSkewY>) {
+          auto radians = static_cast<float>(func.degrees * M_PI / 180.0f);
+          return TransformOperation{
+              .type = TransformOperationType::Skew, .x = Zero, .y = ValueUnit(radians, UnitType::Point), .z = Zero};
+        }
+
+        if constexpr (std::is_same_v<T, CSSPerspective>) {
+          if (func.length.unit != CSSLengthUnit::Px) {
+            return std::nullopt;
+          }
+          return TransformOperation{
+              .type = TransformOperationType::Perspective,
+              .x = ValueUnit(func.length.value, UnitType::Point),
+              .y = Zero,
+              .z = Zero};
+        }
+
+        if constexpr (std::is_same_v<T, CSSMatrix>) {
+          return TransformOperation{.type = TransformOperationType::Arbitrary, .x = Zero, .y = Zero, .z = Zero};
+        }
+      },
+      cssTransform);
+}
+
+inline void parseProcessedTransform(const PropsParserContext & /*context*/, const RawValue &value, Transform &result)
 {
   auto transformMatrix = Transform{};
   react_native_expect(value.hasType<std::vector<RawValue>>());
@@ -770,7 +903,73 @@ inline void fromRawValue(const PropsParserContext & /*context*/, const RawValue
   result = transformMatrix;
 }
 
-inline void fromRawValue(const PropsParserContext &context, const RawValue &value, TransformOrigin &result)
+inline void parseUnprocessedTransformString(const std::string &value, Transform &result)
+{
+  auto transformList = parseCSSProperty<CSSTransformList>(value);
+  if (!std::holds_alternative<CSSTransformList>(transformList)) {
+    result = {};
+    return;
+  }
+
+  auto transformMatrix = Transform{};
+  const auto &cssFuncs = std::get<CSSTransformList>(transformList);
+  transformMatrix.operations.reserve(cssFuncs.size());
+  for (const auto &cssFunc : cssFuncs) {
+    auto op = fromCSSTransformFunction(cssFunc);
+    if (!op.has_value()) {
+      result = {};
+      return;
+    }
+
+    if (op->type == TransformOperationType::Arbitrary) {
+      // CSSMatrix: expand 6-value 2D matrix to 4x4 matrix
+      if (std::holds_alternative<CSSMatrix>(cssFunc)) {
+        const auto &m = std::get<CSSMatrix>(cssFunc);
+        transformMatrix.matrix[0] = m.values[0];
+        transformMatrix.matrix[1] = m.values[1];
+        transformMatrix.matrix[2] = 0;
+        transformMatrix.matrix[3] = 0;
+        transformMatrix.matrix[4] = m.values[2];
+        transformMatrix.matrix[5] = m.values[3];
+        transformMatrix.matrix[6] = 0;
+        transformMatrix.matrix[7] = 0;
+        transformMatrix.matrix[8] = 0;
+        transformMatrix.matrix[9] = 0;
+        transformMatrix.matrix[10] = 1;
+        transformMatrix.matrix[11] = 0;
+        transformMatrix.matrix[12] = m.values[4];
+        transformMatrix.matrix[13] = m.values[5];
+        transformMatrix.matrix[14] = 0;
+        transformMatrix.matrix[15] = 1;
+      }
+    }
+
+    transformMatrix.operations.push_back(*op);
+  }
+
+  result = transformMatrix;
+}
+
+inline void parseUnprocessedTransform(const PropsParserContext &context, const RawValue &value, Transform &result)
+{
+  if (value.hasType<std::string>()) {
+    parseUnprocessedTransformString((std::string)value, result);
+  } else {
+    parseProcessedTransform(context, value, result);
+  }
+}
+
+inline void fromRawValue(const PropsParserContext &context, const RawValue &value, Transform &result)
+{
+  if (ReactNativeFeatureFlags::enableNativeCSSParsing()) {
+    parseUnprocessedTransform(context, value, result);
+  } else {
+    parseProcessedTransform(context, value, result);
+  }
+}
+
+inline void
+parseProcessedTransformOrigin(const PropsParserContext & /*context*/, const RawValue &value, TransformOrigin &result)
 {
   if (!value.hasType<std::vector<RawValue>>()) {
     result = {};
@@ -804,6 +1003,55 @@ inline void fromRawValue(const PropsParserContext &context, const RawValue &valu
   result = transformOrigin;
 }
 
+inline void parseUnprocessedTransformOriginString(const std::string &value, TransformOrigin &result)
+{
+  auto cssOrigin = parseCSSProperty<CSSTransformOrigin>(value);
+  if (!std::holds_alternative<CSSTransformOrigin>(cssOrigin)) {
+    result = {};
+    return;
+  }
+
+  const auto &origin = std::get<CSSTransformOrigin>(cssOrigin);
+  TransformOrigin transformOrigin;
+
+  auto x = cssLengthPercentageToValueUnit(origin.x);
+  auto y = cssLengthPercentageToValueUnit(origin.y);
+  if (!x || !y) {
+    result = {};
+    return;
+  }
+
+  transformOrigin.xy[0] = x;
+  transformOrigin.xy[1] = y;
+
+  if (origin.z.unit != CSSLengthUnit::Px) {
+    result = {};
+    return;
+  }
+  transformOrigin.z = origin.z.value;
+
+  result = transformOrigin;
+}
+
+inline void
+parseUnprocessedTransformOrigin(const PropsParserContext &context, const RawValue &value, TransformOrigin &result)
+{
+  if (value.hasType<std::string>()) {
+    parseUnprocessedTransformOriginString((std::string)value, result);
+  } else {
+    parseProcessedTransformOrigin(context, value, result);
+  }
+}
+
+inline void fromRawValue(const PropsParserContext &context, const RawValue &value, TransformOrigin &result)
+{
+  if (ReactNativeFeatureFlags::enableNativeCSSParsing()) {
+    parseUnprocessedTransformOrigin(context, value, result);
+  } else {
+    parseProcessedTransformOrigin(context, value, result);
+  }
+}
+
 inline void fromRawValue(const PropsParserContext &context, const RawValue &value, PointerEventsMode &result)
 {
   result = PointerEventsMode::Auto;