react-native-tvos 0.85.3-0 → 0.86.0-0

package/ReactCommon/react/performance/timeline/tests/PerformanceEntryTest.cpp

@@ -0,0 +1,62 @@
+/*
+ * 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 <gtest/gtest.h>
+
+#include <algorithm>
+#include <type_traits>
+#include <vector>
+
+#include "../PerformanceEntry.h"
+
+using namespace facebook::react;
+
+// Verify that PerformanceEntrySorter::operator() is const-qualified.
+// Without const, std::stable_sort may fail to compile on toolchains where
+// the comparator is passed through a const-qualified code path (e.g.
+// libc++ __insertion_sort on NDK 19.x), causing SIGSEGV at runtime on
+// others. See T263807207.
+TEST(PerformanceEntry, SorterOperatorIsConst) {
+  static_assert(
+      std::is_invocable_v<
+          const PerformanceEntrySorter,
+          const PerformanceEntry&,
+          const PerformanceEntry&>,
+      "PerformanceEntrySorter::operator() must be const-qualified");
+}
+
+TEST(PerformanceEntry, SortEntriesByStartTimeThenDuration) {
+  auto t0 = HighResTimeStamp::now();
+  auto t1 = t0 + HighResDuration::fromMilliseconds(1);
+  auto t2 = t0 + HighResDuration::fromMilliseconds(2);
+
+  std::vector<PerformanceEntry> entries = {
+      PerformanceMark{{.name = "c", .startTime = t2}},
+      PerformanceMark{{.name = "a", .startTime = t0}},
+      PerformanceMeasure{
+          {.name = "b",
+           .startTime = t0,
+           .duration = HighResDuration::fromMilliseconds(5)}},
+      PerformanceMark{
+          {.name = "d", .startTime = t1, .duration = HighResDuration::zero()}},
+  };
+
+  std::stable_sort(entries.begin(), entries.end(), PerformanceEntrySorter{});
+
+  // Entries with same startTime are ordered by duration (ascending).
+  // "a" (t0, dur=0) < "b" (t0, dur=5) < "d" (t1, dur=0) < "c" (t2, dur=0)
+  ASSERT_EQ(4, entries.size());
+
+  auto getName = [](const PerformanceEntry& e) {
+    return std::visit([](const auto& x) { return x.name; }, e);
+  };
+
+  EXPECT_EQ("a", getName(entries[0]));
+  EXPECT_EQ("b", getName(entries[1]));
+  EXPECT_EQ("d", getName(entries[2]));
+  EXPECT_EQ("c", getName(entries[3]));
+}

package/ReactCommon/react/renderer/animated/NativeAnimatedNodesManager.cpp

@@ -499,15 +499,23 @@ void NativeAnimatedNodesManager::handleAnimatedEvent(
     }
   }
 
-  if (foundAtLeastOneDriver && !isEventAnimationInProgress_) {
-    // There is an animation driver handling this event and
-    // event driven animation has not been started yet.
-    isEventAnimationInProgress_ = true;
-    // Some platforms (e.g. iOS) have UI tick listener disable
-    // when there are no active animations. Calling
-    // `startRenderCallbackIfNeeded` will call platform specific code to
-    // register UI tick listener.
-    startRenderCallbackIfNeeded(false);
+  if (foundAtLeastOneDriver) {
+    // Process event-driven animation updates synchronously, matching the
+    // behavior of the Java NativeAnimatedNodesManager which calls
+    // updateNodes() for every event. Without this, only the first event
+    // in a scroll sequence is processed synchronously — subsequent events
+    // just store the updated value and defer graph traversal + prop commit
+    // to the next choreographer frame, introducing 1-frame latency.
+    if (!isEventAnimationInProgress_) {
+      // There is an animation driver handling this event and
+      // event driven animation has not been started yet.
+      isEventAnimationInProgress_ = true;
+      // Some platforms (e.g. iOS) have UI tick listener disable
+      // when there are no active animations. Calling
+      // `startRenderCallbackIfNeeded` will call platform specific code to
+      // register UI tick listener.
+      startRenderCallbackIfNeeded(false);
+    }
     // Calling startOnRenderCallback_ will register a UI tick listener.
     // The UI ticker listener will not be called until the next frame.
     // That's why, in case this is called from the UI thread, we need to
@@ -555,9 +563,13 @@ void NativeAnimatedNodesManager::startRenderCallbackIfNeeded(bool isAsync) {
 
   if (ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
     if (auto animationBackend = animationBackend_.lock()) {
-      animationBackendCallbackId_ =
-          animationBackend->start([this](AnimationTimestamp timestamp) {
-            return pullAnimationMutations(timestamp);
+      auto weak = weak_from_this();
+      animationBackendCallbackId_ = animationBackend->start(
+          [weak](AnimationTimestamp timestamp) -> AnimationMutations {
+            if (auto self = weak.lock()) {
+              return self->pullAnimationMutations(timestamp);
+            }
+            return {};
           });
     }
 

package/ReactCommon/react/renderer/animated/NativeAnimatedNodesManager.h

@@ -51,7 +51,7 @@ using AnimationEndCallback = AsyncCallback<EndResult>;
 template <>
 struct Bridging<EndResult> : NativeAnimatedTurboModuleEndResultBridging<EndResult> {};
 
-class NativeAnimatedNodesManager {
+class NativeAnimatedNodesManager : public std::enable_shared_from_this<NativeAnimatedNodesManager> {
  public:
   using DirectManipulationCallback = std::function<void(Tag, const folly::dynamic &)>;
   using FabricCommitCallback = std::function<void(std::unordered_map<Tag, folly::dynamic> &)>;

package/ReactCommon/react/renderer/animationbackend/AnimatedPropSerializer.cpp

@@ -530,6 +530,9 @@ void packMixBlendMode(
     case BlendMode::Luminosity:
       blendModeStr = "luminosity";
       break;
+    case BlendMode::PlusLighter:
+      blendModeStr = "plus-lighter";
+      break;
     default:
       throw std::runtime_error("Unknown blend mode");
   }

package/ReactCommon/react/renderer/animationbackend/AnimatedPropsRegistry.cpp

@@ -93,10 +93,17 @@ AnimatedPropsRegistry::getMap(SurfaceId surfaceId) {
 
 void AnimatedPropsRegistry::clear(SurfaceId surfaceId) {
   auto lock = std::lock_guard(mutex_);
+  if (auto it = surfaceContexts_.find(surfaceId);
+      it != surfaceContexts_.end()) {
+    auto& surfaceContext = it->second;
+    surfaceContext.families.clear();
+    surfaceContext.map.clear();
+  }
+}
 
-  auto& surfaceContext = surfaceContexts_[surfaceId];
-  surfaceContext.families.clear();
-  surfaceContext.map.clear();
+void AnimatedPropsRegistry::clearOnSurfaceStop(SurfaceId surfaceId) {
+  auto lock = std::lock_guard(mutex_);
+  surfaceContexts_.erase(surfaceId);
 }
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/animationbackend/AnimatedPropsRegistry.h

@@ -39,6 +39,7 @@ class AnimatedPropsRegistry {
  public:
   void update(const std::unordered_map<SurfaceId, SurfaceUpdates> &surfaceUpdates);
   void clear(SurfaceId surfaceId);
+  void clearOnSurfaceStop(SurfaceId surfaceId);
   std::pair<std::unordered_set<std::shared_ptr<const ShadowNodeFamily>> &, SnapshotMap &> getMap(SurfaceId surfaceId);
 
  private:

package/ReactCommon/react/renderer/animationbackend/AnimationBackend.cpp

@@ -257,6 +257,10 @@ void AnimationBackend::clearRegistry(SurfaceId surfaceId) {
   animatedPropsRegistry_->clear(surfaceId);
 }
 
+void AnimationBackend::clearRegistryOnSurfaceStop(SurfaceId surfaceId) {
+  animatedPropsRegistry_->clearOnSurfaceStop(surfaceId);
+}
+
 void AnimationBackend::registerJSInvoker(
     std::shared_ptr<CallInvoker> jsInvoker) {
   if (!jsInvoker_) {

package/ReactCommon/react/renderer/animationbackend/AnimationBackend.h

@@ -8,7 +8,6 @@
 #pragma once
 
 #include <ReactCommon/CallInvoker.h>
-#include <folly/dynamic.h>
 #include <react/renderer/core/ReactPrimitives.h>
 #include <react/renderer/uimanager/UIManager.h>
 #include <react/renderer/uimanager/UIManagerAnimationBackend.h>
@@ -56,6 +55,7 @@ class AnimationBackend : public UIManagerAnimationBackend {
   void synchronouslyUpdateProps(const std::unordered_map<Tag, AnimatedProps> &updates);
   void requestAsyncFlushForSurfaces(const std::set<SurfaceId> &surfaces);
   void clearRegistry(SurfaceId surfaceId) override;
+  void clearRegistryOnSurfaceStop(SurfaceId surfaceId) override;
   void registerJSInvoker(std::shared_ptr<CallInvoker> jsInvoker) override;
 
   void onAnimationFrame(AnimationTimestamp timestamp) override;

package/ReactCommon/react/renderer/animationbackend/AnimationBackendCommitHook.h

@@ -7,7 +7,6 @@
 
 #pragma once
 
-#include <folly/dynamic.h>
 #include <react/renderer/core/ReactPrimitives.h>
 #include <react/renderer/uimanager/UIManager.h>
 #include <react/renderer/uimanager/UIManagerCommitHook.h>

package/ReactCommon/react/renderer/animations/LayoutAnimationDriver.cpp

@@ -74,6 +74,10 @@ void LayoutAnimationDriver::animationMutationsForFrame(
     }
   }
 
+  // Record boundary: animation-frame Updates above this point carry
+  // parentTag from before any structural changes and must execute first.
+  auto animationUpdatesEnd = mutationsList.size();
+
   // Clear out finished animations
   for (auto it = inflightAnimations_.begin();
        it != inflightAnimations_.end();) {
@@ -99,10 +103,11 @@ void LayoutAnimationDriver::animationMutationsForFrame(
     }
   }
 
-  // Final step: make sure that all operations execute in the proper order.
-  // REMOVE operations with highest indices must operate first.
+  // Sort only the final mutations from completed animations.
+  // Animation-frame Updates must stay before structural mutations because
+  // they reference views by their pre-structural-change parentTag.
   std::stable_sort(
-      mutationsList.begin(),
+      mutationsList.begin() + static_cast<ptrdiff_t>(animationUpdatesEnd),
       mutationsList.end(),
       &shouldFirstComeBeforeSecondMutation);
 }

package/ReactCommon/react/renderer/animations/tests/MutationComparatorTest.cpp

@@ -0,0 +1,273 @@
+/*
+ * 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 <algorithm>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+#include <react/renderer/animations/utils.h>
+#include <react/renderer/mounting/ShadowViewMutation.h>
+
+namespace facebook::react {
+
+namespace {
+
+ShadowView makeShadowView(Tag tag) {
+  ShadowView sv{};
+  sv.tag = tag;
+  return sv;
+}
+
+} // namespace
+
+// Verify strict weak ordering: irreflexivity
+// comp(a, a) must be false
+TEST(MutationComparatorTest, Irreflexivity) {
+  auto sv1 = makeShadowView(1);
+  auto sv2 = makeShadowView(2);
+
+  // Same-type mutations where the fallback path is exercised
+  auto update1 = ShadowViewMutation::UpdateMutation(sv1, sv2, /*parentTag=*/10);
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(update1, update1));
+
+  auto create1 = ShadowViewMutation::CreateMutation(sv1);
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(create1, create1));
+
+  auto insert1 =
+      ShadowViewMutation::InsertMutation(/*parentTag=*/10, sv1, /*index=*/0);
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(insert1, insert1));
+
+  auto remove1 =
+      ShadowViewMutation::RemoveMutation(/*parentTag=*/10, sv1, /*index=*/0);
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(remove1, remove1));
+
+  auto del1 = ShadowViewMutation::DeleteMutation(sv1);
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(del1, del1));
+}
+
+// Verify strict weak ordering: asymmetry
+// If comp(a, b) then !comp(b, a)
+TEST(MutationComparatorTest, Asymmetry) {
+  auto sv1 = makeShadowView(1);
+  auto sv2 = makeShadowView(2);
+  auto sv3 = makeShadowView(3);
+
+  // Two updates with same type but different parentTags (fallback path)
+  auto update1 = ShadowViewMutation::UpdateMutation(sv1, sv2, /*parentTag=*/10);
+  auto update2 = ShadowViewMutation::UpdateMutation(sv1, sv3, /*parentTag=*/20);
+
+  bool a_before_b = shouldFirstComeBeforeSecondMutation(update1, update2);
+  bool b_before_a = shouldFirstComeBeforeSecondMutation(update2, update1);
+
+  // Exactly one must be true (asymmetry)
+  EXPECT_NE(a_before_b, b_before_a);
+}
+
+// Verify strict weak ordering: transitivity
+// If comp(a, b) and comp(b, c) then comp(a, c)
+TEST(MutationComparatorTest, Transitivity) {
+  auto sv1 = makeShadowView(1);
+  auto sv2 = makeShadowView(2);
+  auto sv3 = makeShadowView(3);
+
+  auto update1 = ShadowViewMutation::UpdateMutation(sv1, sv1, /*parentTag=*/10);
+  auto update2 = ShadowViewMutation::UpdateMutation(sv1, sv1, /*parentTag=*/20);
+  auto update3 = ShadowViewMutation::UpdateMutation(sv1, sv1, /*parentTag=*/30);
+
+  bool a_b = shouldFirstComeBeforeSecondMutation(update1, update2);
+  bool b_c = shouldFirstComeBeforeSecondMutation(update2, update3);
+  bool a_c = shouldFirstComeBeforeSecondMutation(update1, update3);
+
+  if (a_b && b_c) {
+    EXPECT_TRUE(a_c) << "Transitivity violated: a<b and b<c but not a<c";
+  }
+}
+
+// Verify type-based ordering rules
+TEST(MutationComparatorTest, TypeOrdering) {
+  auto sv1 = makeShadowView(1);
+  auto sv2 = makeShadowView(2);
+
+  auto create = ShadowViewMutation::CreateMutation(sv1);
+  auto insert =
+      ShadowViewMutation::InsertMutation(/*parentTag=*/10, sv1, /*index=*/0);
+  auto remove =
+      ShadowViewMutation::RemoveMutation(/*parentTag=*/10, sv1, /*index=*/0);
+  auto update = ShadowViewMutation::UpdateMutation(sv1, sv2, /*parentTag=*/10);
+  auto del = ShadowViewMutation::DeleteMutation(sv1);
+
+  // Delete always comes last
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(del, create));
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(del, insert));
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(del, remove));
+  EXPECT_TRUE(shouldFirstComeBeforeSecondMutation(create, del));
+  EXPECT_TRUE(shouldFirstComeBeforeSecondMutation(insert, del));
+  EXPECT_TRUE(shouldFirstComeBeforeSecondMutation(remove, del));
+
+  // Remove comes before Insert
+  EXPECT_TRUE(shouldFirstComeBeforeSecondMutation(remove, insert));
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(insert, remove));
+
+  // Create comes before Insert
+  EXPECT_TRUE(shouldFirstComeBeforeSecondMutation(create, insert));
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(insert, create));
+
+  // Remove comes before Update
+  EXPECT_TRUE(shouldFirstComeBeforeSecondMutation(remove, update));
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(update, remove));
+}
+
+// Verify removes on same parent are sorted by descending index
+TEST(MutationComparatorTest, RemovesSameParentDescendingIndex) {
+  auto sv1 = makeShadowView(1);
+  auto sv2 = makeShadowView(2);
+
+  auto remove_idx0 =
+      ShadowViewMutation::RemoveMutation(/*parentTag=*/10, sv1, /*index=*/0);
+  auto remove_idx5 =
+      ShadowViewMutation::RemoveMutation(/*parentTag=*/10, sv2, /*index=*/5);
+
+  // Higher index should come first
+  EXPECT_TRUE(shouldFirstComeBeforeSecondMutation(remove_idx5, remove_idx0));
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(remove_idx0, remove_idx5));
+}
+
+// Verify the deterministic fallback uses parentTag, then child tags
+TEST(MutationComparatorTest, DeterministicFallbackByParentTag) {
+  auto sv1 = makeShadowView(1);
+  auto sv2 = makeShadowView(2);
+
+  // Two updates with same type, different parentTags
+  auto update_p10 =
+      ShadowViewMutation::UpdateMutation(sv1, sv2, /*parentTag=*/10);
+  auto update_p20 =
+      ShadowViewMutation::UpdateMutation(sv1, sv2, /*parentTag=*/20);
+
+  // Lower parentTag comes first
+  EXPECT_TRUE(shouldFirstComeBeforeSecondMutation(update_p10, update_p20));
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(update_p20, update_p10));
+}
+
+TEST(MutationComparatorTest, DeterministicFallbackByNewChildTag) {
+  auto sv1 = makeShadowView(1);
+  auto sv2 = makeShadowView(2);
+  auto sv3 = makeShadowView(3);
+
+  // Same parentTag, different newChildShadowView tags
+  auto update_new2 =
+      ShadowViewMutation::UpdateMutation(sv1, sv2, /*parentTag=*/10);
+  auto update_new3 =
+      ShadowViewMutation::UpdateMutation(sv1, sv3, /*parentTag=*/10);
+
+  EXPECT_TRUE(shouldFirstComeBeforeSecondMutation(update_new2, update_new3));
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(update_new3, update_new2));
+}
+
+TEST(MutationComparatorTest, DeterministicFallbackByOldChildTag) {
+  auto sv1 = makeShadowView(1);
+  auto sv2 = makeShadowView(2);
+  auto sv3 = makeShadowView(3);
+
+  // Same parentTag, same newChildShadowView tag, different oldChildShadowView
+  // tags
+  auto update_old1 =
+      ShadowViewMutation::UpdateMutation(sv1, sv3, /*parentTag=*/10);
+  auto update_old2 =
+      ShadowViewMutation::UpdateMutation(sv2, sv3, /*parentTag=*/10);
+
+  EXPECT_TRUE(shouldFirstComeBeforeSecondMutation(update_old1, update_old2));
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(update_old2, update_old1));
+}
+
+// Verify equal mutations return false (stability)
+TEST(MutationComparatorTest, EqualMutationsReturnFalse) {
+  auto sv1 = makeShadowView(1);
+  auto sv2 = makeShadowView(2);
+
+  auto update_a =
+      ShadowViewMutation::UpdateMutation(sv1, sv2, /*parentTag=*/10);
+  auto update_b =
+      ShadowViewMutation::UpdateMutation(sv1, sv2, /*parentTag=*/10);
+
+  // Two mutations with identical properties should return false (not less-than)
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(update_a, update_b));
+  EXPECT_FALSE(shouldFirstComeBeforeSecondMutation(update_b, update_a));
+}
+
+// Verify std::stable_sort doesn't crash with the comparator
+// (the original bug was a SIGSEGV during sort)
+TEST(MutationComparatorTest, StableSortDoesNotCrash) {
+  ShadowViewMutation::List mutations;
+
+  // Build a list with various mutation types and properties
+  for (int parent = 0; parent < 5; parent++) {
+    for (int child = 0; child < 10; child++) {
+      auto sv_old = makeShadowView(child);
+      auto sv_new = makeShadowView(child + 100);
+
+      mutations.push_back(
+          ShadowViewMutation::UpdateMutation(
+              sv_old, sv_new, /*parentTag=*/parent));
+      mutations.push_back(
+          ShadowViewMutation::InsertMutation(
+              /*parentTag=*/parent, sv_new, /*index=*/child));
+      mutations.push_back(
+          ShadowViewMutation::RemoveMutation(
+              /*parentTag=*/parent, sv_old, /*index=*/child));
+    }
+  }
+  mutations.push_back(ShadowViewMutation::CreateMutation(makeShadowView(999)));
+  mutations.push_back(ShadowViewMutation::DeleteMutation(makeShadowView(998)));
+
+  // This should not crash (the original bug was SIGSEGV here)
+  EXPECT_NO_FATAL_FAILURE(
+      std::stable_sort(
+          mutations.begin(),
+          mutations.end(),
+          &shouldFirstComeBeforeSecondMutation));
+
+  // Verify ordering invariants after sort
+  bool seen_delete = false;
+  for (const auto& m : mutations) {
+    if (m.type == ShadowViewMutation::Type::Delete) {
+      seen_delete = true;
+    } else if (seen_delete) {
+      FAIL() << "Non-delete mutation found after a delete mutation";
+    }
+  }
+}
+
+// Stress test: sort a large list of mutations with duplicates
+TEST(MutationComparatorTest, StableSortLargeListWithDuplicates) {
+  ShadowViewMutation::List mutations;
+
+  // Create many mutations with overlapping properties to stress the comparator
+  for (int i = 0; i < 200; i++) {
+    auto sv = makeShadowView(i % 10); // Deliberately create duplicates
+    auto sv2 = makeShadowView((i + 1) % 10);
+    int parent = i % 5;
+
+    mutations.push_back(ShadowViewMutation::UpdateMutation(sv, sv2, parent));
+    if (i % 3 == 0) {
+      mutations.push_back(
+          ShadowViewMutation::InsertMutation(parent, sv, i % 20));
+    }
+    if (i % 4 == 0) {
+      mutations.push_back(
+          ShadowViewMutation::RemoveMutation(parent, sv, i % 20));
+    }
+  }
+
+  EXPECT_NO_FATAL_FAILURE(
+      std::stable_sort(
+          mutations.begin(),
+          mutations.end(),
+          &shouldFirstComeBeforeSecondMutation));
+}
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/animations/utils.h

@@ -96,7 +96,18 @@ static inline bool shouldFirstComeBeforeSecondMutation(
     }
   }
 
-  return &lhs < &rhs;
+  // Deterministic fallback: when no type-specific rule applies, order by
+  // mutation properties to satisfy strict weak ordering.
+  if (lhs.parentTag != rhs.parentTag) {
+    return lhs.parentTag < rhs.parentTag;
+  }
+  if (lhs.newChildShadowView.tag != rhs.newChildShadowView.tag) {
+    return lhs.newChildShadowView.tag < rhs.newChildShadowView.tag;
+  }
+  if (lhs.oldChildShadowView.tag != rhs.oldChildShadowView.tag) {
+    return lhs.oldChildShadowView.tag < rhs.oldChildShadowView.tag;
+  }
+  return false;
 }
 
 std::pair<Float, Float>

package/ReactCommon/react/renderer/attributedstring/TextAttributes.cpp

@@ -88,7 +88,7 @@ void TextAttributes::apply(TextAttributes textAttributes) {
 
   // Shadow
   textShadowOffset = textAttributes.textShadowOffset.has_value()
-      ? textAttributes.textShadowOffset.value()
+      ? textAttributes.textShadowOffset
       : textShadowOffset;
   textShadowRadius = !std::isnan(textAttributes.textShadowRadius)
       ? textAttributes.textShadowRadius

package/ReactCommon/react/renderer/attributedstring/conversions.h

@@ -7,8 +7,8 @@
 
 #pragma once
 
-#include <folly/dynamic.h>
 #include <react/debug/react_native_expect.h>
+#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/attributedstring/AttributedString.h>
 #include <react/renderer/attributedstring/ParagraphAttributes.h>
 #include <react/renderer/attributedstring/TextAttributes.h>
@@ -21,6 +21,8 @@
 #include <react/renderer/core/conversions.h>
 #include <react/renderer/core/graphicsConversions.h>
 #include <react/renderer/core/propsConversions.h>
+#include <react/renderer/css/CSSFontVariant.h>
+#include <react/renderer/css/CSSValueParser.h>
 #include <unordered_map>
 
 #ifdef RN_SERIALIZABLE_STATE
@@ -317,7 +319,73 @@ inline std::string toString(const FontStyle &fontStyle)
   return "normal";
 }
 
-inline void fromRawValue(const PropsParserContext &context, const RawValue &value, FontVariant &result)
+inline std::optional<FontVariant> fontVariantFromCSSFontVariant(CSSFontVariant cssVariant)
+{
+  switch (cssVariant) {
+    case CSSFontVariant::SmallCaps:
+      return FontVariant::SmallCaps;
+    case CSSFontVariant::OldstyleNums:
+      return FontVariant::OldstyleNums;
+    case CSSFontVariant::LiningNums:
+      return FontVariant::LiningNums;
+    case CSSFontVariant::TabularNums:
+      return FontVariant::TabularNums;
+    case CSSFontVariant::ProportionalNums:
+      return FontVariant::ProportionalNums;
+    case CSSFontVariant::StylisticOne:
+      return FontVariant::StylisticOne;
+    case CSSFontVariant::StylisticTwo:
+      return FontVariant::StylisticTwo;
+    case CSSFontVariant::StylisticThree:
+      return FontVariant::StylisticThree;
+    case CSSFontVariant::StylisticFour:
+      return FontVariant::StylisticFour;
+    case CSSFontVariant::StylisticFive:
+      return FontVariant::StylisticFive;
+    case CSSFontVariant::StylisticSix:
+      return FontVariant::StylisticSix;
+    case CSSFontVariant::StylisticSeven:
+      return FontVariant::StylisticSeven;
+    case CSSFontVariant::StylisticEight:
+      return FontVariant::StylisticEight;
+    case CSSFontVariant::StylisticNine:
+      return FontVariant::StylisticNine;
+    case CSSFontVariant::StylisticTen:
+      return FontVariant::StylisticTen;
+    case CSSFontVariant::StylisticEleven:
+      return FontVariant::StylisticEleven;
+    case CSSFontVariant::StylisticTwelve:
+      return FontVariant::StylisticTwelve;
+    case CSSFontVariant::StylisticThirteen:
+      return FontVariant::StylisticThirteen;
+    case CSSFontVariant::StylisticFourteen:
+      return FontVariant::StylisticFourteen;
+    case CSSFontVariant::StylisticFifteen:
+      return FontVariant::StylisticFifteen;
+    case CSSFontVariant::StylisticSixteen:
+      return FontVariant::StylisticSixteen;
+    case CSSFontVariant::StylisticSeventeen:
+      return FontVariant::StylisticSeventeen;
+    case CSSFontVariant::StylisticEighteen:
+      return FontVariant::StylisticEighteen;
+    case CSSFontVariant::StylisticNineteen:
+      return FontVariant::StylisticNineteen;
+    case CSSFontVariant::StylisticTwenty:
+      return FontVariant::StylisticTwenty;
+    case CSSFontVariant::CommonLigatures:
+    case CSSFontVariant::NoCommonLigatures:
+    case CSSFontVariant::DiscretionaryLigatures:
+    case CSSFontVariant::NoDiscretionaryLigatures:
+    case CSSFontVariant::HistoricalLigatures:
+    case CSSFontVariant::NoHistoricalLigatures:
+    case CSSFontVariant::Contextual:
+    case CSSFontVariant::NoContextual:
+      return std::nullopt;
+  }
+}
+
+inline void
+parseProcessedFontVariant(const PropsParserContext & /*context*/, const RawValue &value, FontVariant &result)
 {
   result = FontVariant::Default;
   react_native_expect(value.hasType<std::vector<std::string>>());
@@ -376,7 +444,6 @@ inline void fromRawValue(const PropsParserContext &context, const RawValue &valu
         result = (FontVariant)((int)result | (int)FontVariant::StylisticTwenty);
       } else {
         LOG(ERROR) << "Unsupported FontVariant value: " << item;
-        react_native_expect(false);
       }
     }
   } else {
@@ -384,6 +451,40 @@ inline void fromRawValue(const PropsParserContext &context, const RawValue &valu
   }
 }
 
+inline void parseUnprocessedFontVariantString(const std::string &value, FontVariant &result)
+{
+  auto fontVariantList = parseCSSProperty<CSSFontVariantList>(value);
+  if (!std::holds_alternative<CSSFontVariantList>(fontVariantList)) {
+    result = FontVariant::Default;
+    return;
+  }
+
+  result = FontVariant::Default;
+  for (const auto &cssVariant : std::get<CSSFontVariantList>(fontVariantList)) {
+    if (auto fv = fontVariantFromCSSFontVariant(cssVariant)) {
+      result = (FontVariant)((int)result | (int)*fv);
+    }
+  }
+}
+
+inline void parseUnprocessedFontVariant(const PropsParserContext &context, const RawValue &value, FontVariant &result)
+{
+  if (value.hasType<std::string>()) {
+    parseUnprocessedFontVariantString((std::string)value, result);
+  } else {
+    parseProcessedFontVariant(context, value, result);
+  }
+}
+
+inline void fromRawValue(const PropsParserContext &context, const RawValue &value, FontVariant &result)
+{
+  if (ReactNativeFeatureFlags::enableNativeCSSParsing()) {
+    parseUnprocessedFontVariant(context, value, result);
+  } else {
+    parseProcessedFontVariant(context, value, result);
+  }
+}
+
 inline std::string toString(const FontVariant &fontVariant)
 {
   auto result = std::string{};