@depup/react-native 0.86.2-depup.0 → 0.87.0-depup.0

package/ReactCommon/react/renderer/animated/tests/ManagedPropsMountingOverrideTests.cpp

@@ -0,0 +1,204 @@
+/*
+ * 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 "AnimationTestsBase.h"
+
+#include <react/renderer/animated/drivers/AnimationDriverUtils.h>
+#include <react/renderer/core/ReactRootViewTagGenerator.h>
+
+namespace facebook::react {
+
+// Pins the getManagedProps / hasManagedProps seam re-merged by
+// AnimatedMountingOverrideDelegate to prevent the useNativeDriver mount flash.
+class ManagedPropsMountingOverrideTests : public AnimationTestsBase {
+ protected:
+  struct OpacityGraph {
+    Tag opacityTag;
+    Tag styleTag;
+    Tag propsTag;
+    Tag viewTag;
+  };
+
+  // value -> style -> props graph for an animated opacity; view left
+  // unconnected.
+  OpacityGraph buildOpacityGraph(float initialOpacity) {
+    const auto opacityTag = ++rootTag_;
+    nodesManager_->createAnimatedNode(
+        opacityTag,
+        folly::dynamic::object("type", "value")("value", initialOpacity)(
+            "offset", 0));
+
+    const auto styleTag = ++rootTag_;
+    nodesManager_->createAnimatedNode(
+        styleTag,
+        folly::dynamic::object("type", "style")(
+            "style", folly::dynamic::object("opacity", opacityTag)));
+    nodesManager_->connectAnimatedNodes(opacityTag, styleTag);
+
+    const auto propsTag = ++rootTag_;
+    nodesManager_->createAnimatedNode(
+        propsTag,
+        folly::dynamic::object("type", "props")(
+            "props", folly::dynamic::object("style", styleTag)));
+    nodesManager_->connectAnimatedNodes(styleTag, propsTag);
+
+    const auto viewTag = ++rootTag_;
+    return OpacityGraph{
+        .opacityTag = opacityTag,
+        .styleTag = styleTag,
+        .propsTag = propsTag,
+        .viewTag = viewTag};
+  }
+
+  Tag rootTag_{getNextRootViewTag()};
+};
+
+TEST_F(
+    ManagedPropsMountingOverrideTests,
+    getManagedPropsNullForUnconnectedView) {
+  initNodesManager();
+
+  const auto unknownTag = ++rootTag_;
+  EXPECT_TRUE(nodesManager_->getManagedProps(unknownTag).isNull());
+  EXPECT_FALSE(nodesManager_->hasManagedProps());
+}
+
+// Managed props mirror the live committed value every frame, never the frozen
+// start value nor the 1.0 default.
+TEST_F(
+    ManagedPropsMountingOverrideTests,
+    getManagedPropsReflectsLiveValueAcrossFrames) {
+  initNodesManager();
+
+  auto g = buildOpacityGraph(/*initialOpacity=*/0.0f);
+  nodesManager_->connectAnimatedNodeToView(g.propsTag, g.viewTag);
+
+  const auto frames = folly::dynamic::array(0.0f, 0.25f, 0.5f, 0.75f, 1.0f);
+  nodesManager_->startAnimatingNode(
+      /*animationId=*/1,
+      g.opacityTag,
+      folly::dynamic::object("type", "frames")("frames", frames)(
+          "toValue", 1.0f),
+      std::nullopt);
+
+  const double startTimeInTick = 1000;
+  for (int frame = 0; frame <= 4; ++frame) {
+    runAnimationFrame(startTimeInTick + frame * SingleFrameIntervalMs);
+
+    auto props = nodesManager_->getManagedProps(g.viewTag);
+    ASSERT_FALSE(props.isNull());
+    ASSERT_TRUE(props.isObject());
+    ASSERT_EQ(props.count("opacity"), 1u);
+
+    const double live = nodesManager_->getValue(g.opacityTag).value();
+    EXPECT_DOUBLE_EQ(props["opacity"].asDouble(), live);
+
+    if (frame == 0) {
+      EXPECT_DOUBLE_EQ(live, 0.0);
+    }
+  }
+
+  EXPECT_DOUBLE_EQ(nodesManager_->getValue(g.opacityTag).value(), 1.0);
+  auto finalProps = nodesManager_->getManagedProps(g.viewTag);
+  ASSERT_EQ(finalProps.count("opacity"), 1u);
+  EXPECT_DOUBLE_EQ(finalProps["opacity"].asDouble(), 1.0);
+}
+
+// Without the connect-time seed props_ is empty at connect, so the override has
+// nothing to merge: the opacity assertion fails pre-hardening, passes post.
+TEST_F(
+    ManagedPropsMountingOverrideTests,
+    getManagedPropsLiveImmediatelyOnConnect) {
+  initNodesManager();
+
+  auto g = buildOpacityGraph(/*initialOpacity=*/0.8f);
+  nodesManager_->connectAnimatedNodeToView(g.propsTag, g.viewTag);
+  // No runAnimationFrame: the value must be live the instant the view is
+  // managed.
+
+  auto props = nodesManager_->getManagedProps(g.viewTag);
+  EXPECT_FALSE(props.isNull());
+  ASSERT_TRUE(props.isObject());
+  ASSERT_EQ(props.count("opacity"), 1u);
+  EXPECT_DOUBLE_EQ(props["opacity"].asDouble(), static_cast<double>(0.8f));
+}
+
+// A brand-new view connected to an already mid-flight shared value, with no
+// frame in between: fails pre-hardening, passes post.
+TEST_F(
+    ManagedPropsMountingOverrideTests,
+    getManagedPropsLiveOnConnectWhileValueMidFlight) {
+  initNodesManager();
+
+  auto g = buildOpacityGraph(/*initialOpacity=*/0.0f);
+  nodesManager_->connectAnimatedNodeToView(g.propsTag, g.viewTag);
+
+  const auto frames = folly::dynamic::array(0.0f, 0.25f, 0.5f, 0.75f, 1.0f);
+  nodesManager_->startAnimatingNode(
+      /*animationId=*/1,
+      g.opacityTag,
+      folly::dynamic::object("type", "frames")("frames", frames)(
+          "toValue", 1.0f),
+      std::nullopt);
+  runAnimationFrame(1000);
+  runAnimationFrame(1000 + 2 * SingleFrameIntervalMs);
+
+  const double live = nodesManager_->getValue(g.opacityTag).value();
+  ASSERT_GT(live, 0.0);
+  ASSERT_LT(live, 1.0);
+
+  const auto styleTag2 = ++rootTag_;
+  nodesManager_->createAnimatedNode(
+      styleTag2,
+      folly::dynamic::object("type", "style")(
+          "style", folly::dynamic::object("opacity", g.opacityTag)));
+  nodesManager_->connectAnimatedNodes(g.opacityTag, styleTag2);
+  const auto propsTag2 = ++rootTag_;
+  nodesManager_->createAnimatedNode(
+      propsTag2,
+      folly::dynamic::object("type", "props")(
+          "props", folly::dynamic::object("style", styleTag2)));
+  nodesManager_->connectAnimatedNodes(styleTag2, propsTag2);
+  const auto viewTag2 = ++rootTag_;
+  nodesManager_->connectAnimatedNodeToView(propsTag2, viewTag2);
+
+  auto props = nodesManager_->getManagedProps(viewTag2);
+  EXPECT_FALSE(props.isNull());
+  ASSERT_EQ(props.count("opacity"), 1u);
+  EXPECT_DOUBLE_EQ(props["opacity"].asDouble(), live);
+}
+
+TEST_F(
+    ManagedPropsMountingOverrideTests,
+    hasManagedPropsTracksConnectAndDisconnect) {
+  initNodesManager();
+
+  auto g = buildOpacityGraph(/*initialOpacity=*/0.5f);
+
+  EXPECT_FALSE(nodesManager_->hasManagedProps());
+  EXPECT_TRUE(nodesManager_->getManagedProps(g.viewTag).isNull());
+
+  nodesManager_->connectAnimatedNodeToView(g.propsTag, g.viewTag);
+  EXPECT_TRUE(nodesManager_->hasManagedProps());
+  EXPECT_FALSE(nodesManager_->getManagedProps(g.viewTag).isNull());
+
+  nodesManager_->disconnectAnimatedNodeFromView(g.propsTag, g.viewTag);
+  EXPECT_FALSE(nodesManager_->hasManagedProps());
+  EXPECT_TRUE(nodesManager_->getManagedProps(g.viewTag).isNull());
+}
+
+TEST_F(ManagedPropsMountingOverrideTests, getManagedPropsIsolatedPerView) {
+  initNodesManager();
+
+  auto g = buildOpacityGraph(/*initialOpacity=*/0.3f);
+  nodesManager_->connectAnimatedNodeToView(g.propsTag, g.viewTag);
+
+  EXPECT_FALSE(nodesManager_->getManagedProps(g.viewTag).isNull());
+  EXPECT_TRUE(nodesManager_->getManagedProps(g.viewTag + 1000).isNull());
+}
+
+} // namespace facebook::react

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

@@ -15,7 +15,11 @@ void AnimatedPropsRegistry::update(
     const std::unordered_map<SurfaceId, SurfaceUpdates>& surfaceUpdates) {
   auto lock = std::lock_guard(mutex_);
   for (const auto& [surfaceId, updates] : surfaceUpdates) {
-    auto& surfaceContext = surfaceContexts_[surfaceId];
+    auto contextIt = surfaceContexts_.find(surfaceId);
+    if (contextIt == surfaceContexts_.end()) {
+      continue;
+    }
+    auto& surfaceContext = contextIt->second;
     auto& pendingMap = surfaceContext.pendingMap;
     auto& pendingFamilies = surfaceContext.pendingFamilies;
 
@@ -55,6 +59,11 @@ void AnimatedPropsRegistry::update(
   }
 }
 
+void AnimatedPropsRegistry::initializeSurface(SurfaceId surfaceId) {
+  auto lock = std::lock_guard(mutex_);
+  surfaceContexts_.try_emplace(surfaceId);
+}
+
 std::pair<
     std::unordered_set<std::shared_ptr<const ShadowNodeFamily>>&,
     SnapshotMap&>

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

@@ -38,6 +38,7 @@ using SnapshotMap = std::unordered_map<Tag, std::unique_ptr<PropsSnapshot>>;
 class AnimatedPropsRegistry {
  public:
   void update(const std::unordered_map<SurfaceId, SurfaceUpdates> &surfaceUpdates);
+  void initializeSurface(SurfaceId surfaceId);
   void clear(SurfaceId surfaceId);
   void clearOnSurfaceStop(SurfaceId surfaceId);
   std::pair<std::unordered_set<std::shared_ptr<const ShadowNodeFamily>> &, SnapshotMap &> getMap(SurfaceId surfaceId);

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

@@ -56,6 +56,23 @@ AnimationBackend::AnimationBackend(
       commitHook_(*uiManager, animatedPropsRegistry_),
       uiManager_(std::move(uiManager)) {
   react_native_assert(uiManager_.expired() == false);
+
+  auto weakAnimatedPropsRegistry =
+      std::weak_ptr<AnimatedPropsRegistry>(animatedPropsRegistry_);
+  auto initializeSurfaceContext =
+      [weakAnimatedPropsRegistry](const ShadowTree& shadowTree) {
+        if (auto animatedPropsRegistry = weakAnimatedPropsRegistry.lock()) {
+          animatedPropsRegistry->initializeSurface(shadowTree.getSurfaceId());
+        }
+      };
+
+  if (auto lockedUIManager = uiManager_.lock()) {
+    lockedUIManager->addOnSurfaceStartCallback(initializeSurfaceContext);
+    lockedUIManager->getShadowTreeRegistry().enumerate(
+        [&](const ShadowTree& shadowTree, bool& /*stop*/) {
+          animatedPropsRegistry_->initializeSurface(shadowTree.getSurfaceId());
+        });
+  }
 }
 
 void AnimationBackend::unpackMutations(

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

@@ -493,7 +493,6 @@ TEST(
 TEST(
     LayoutAnimationTest,
     stableSmallerTreeFewRepeatsFewStages_Overlapping_ManyConflicts_597132284) {
-  GTEST_SKIP();
   testShadowNodeTreeLifeCycleLayoutAnimations(
       /* seed */ 597132284,
       /* size */ 128,
@@ -514,7 +513,6 @@ TEST(
 TEST(
     LayoutAnimationTest,
     stableBiggerTreeFewRepeatsManyStages_Overlapping_ManyConflicts_2029343357) {
-  GTEST_SKIP();
   testShadowNodeTreeLifeCycleLayoutAnimations(
       /* seed */ 2029343357,
       /* size */ 512,

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

@@ -114,6 +114,8 @@ void TextAttributes::apply(TextAttributes textAttributes) {
       ? textAttributes.accessibilityRole
       : accessibilityRole;
   role = textAttributes.role.has_value() ? textAttributes.role : role;
+  textEffects = !textAttributes.textEffects.empty() ? textAttributes.textEffects
+                                                    : textEffects;
 }
 
 #pragma mark - Operators
@@ -141,7 +143,8 @@ bool TextAttributes::operator==(const TextAttributes& rhs) const {
              layoutDirection,
              accessibilityRole,
              role,
-             textTransform) ==
+             textTransform,
+             textEffects) ==
       std::tie(
              rhs.foregroundColor,
              rhs.backgroundColor,
@@ -164,7 +167,8 @@ bool TextAttributes::operator==(const TextAttributes& rhs) const {
              rhs.layoutDirection,
              rhs.accessibilityRole,
              rhs.role,
-             rhs.textTransform) &&
+             rhs.textTransform,
+             rhs.textEffects) &&
       floatEquality(maxFontSizeMultiplier, rhs.maxFontSizeMultiplier) &&
       floatEquality(opacity, rhs.opacity) &&
       floatEquality(fontSize, rhs.fontSize) &&

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

@@ -10,7 +10,9 @@
 #include <functional>
 #include <limits>
 #include <optional>
+#include <vector>
 
+#include <folly/dynamic.h>
 #include <react/renderer/attributedstring/primitives.h>
 #include <react/renderer/components/view/AccessibilityPrimitives.h>
 #include <react/renderer/core/LayoutPrimitives.h>
@@ -23,6 +25,12 @@
 
 namespace facebook::react {
 
+struct TextEffectInfo {
+  std::string name;
+  folly::dynamic props;
+  bool operator==(const TextEffectInfo &) const = default;
+};
+
 class TextAttributes;
 
 using SharedTextAttributes = std::shared_ptr<const TextAttributes>;
@@ -86,6 +94,9 @@ class TextAttributes : public DebugStringConvertible {
   std::optional<AccessibilityRole> accessibilityRole{};
   std::optional<Role> role{};
 
+  // Text Effects (ordered by nesting depth: index 0 = outermost = drawn first)
+  std::vector<TextEffectInfo> textEffects{};
+
 #pragma mark - Operations
 
   void apply(TextAttributes textAttributes);
@@ -105,10 +116,22 @@ class TextAttributes : public DebugStringConvertible {
 
 namespace std {
 
+template <>
+struct hash<facebook::react::TextEffectInfo> {
+  size_t operator()(const facebook::react::TextEffectInfo &info) const
+  {
+    return facebook::react::hash_combine(info.name, info.props);
+  }
+};
+
 template <>
 struct hash<facebook::react::TextAttributes> {
   size_t operator()(const facebook::react::TextAttributes &textAttributes) const
   {
+    size_t textEffectsHash = 0;
+    for (const auto &effect : textAttributes.textEffects) {
+      facebook::react::hash_combine(textEffectsHash, effect);
+    }
     return facebook::react::hash_combine(
         textAttributes.foregroundColor,
         textAttributes.backgroundColor,
@@ -138,7 +161,8 @@ struct hash<facebook::react::TextAttributes> {
         textAttributes.isPressable,
         textAttributes.layoutDirection,
         textAttributes.accessibilityRole,
-        textAttributes.role);
+        textAttributes.role,
+        textEffectsHash);
   }
 };
 } // namespace std

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

@@ -26,6 +26,7 @@
 #include <unordered_map>
 
 #ifdef RN_SERIALIZABLE_STATE
+#include <folly/json.h>
 #include <react/renderer/mapbuffer/MapBuffer.h>
 #include <react/renderer/mapbuffer/MapBufferBuilder.h>
 #endif
@@ -628,8 +629,12 @@ inline void fromRawValue(const PropsParserContext &context, const RawValue &valu
   react_native_expect(value.hasType<std::string>());
   if (value.hasType<std::string>()) {
     auto string = (std::string)value;
-    if (string == "auto" || string == "start") {
+    if (string == "auto") {
       result = TextAlignment::Natural;
+    } else if (string == "start") {
+      result = TextAlignment::Start;
+    } else if (string == "end") {
+      result = TextAlignment::End;
     } else if (string == "left") {
       result = TextAlignment::Left;
     } else if (string == "center") {
@@ -664,6 +669,10 @@ inline std::string toString(const TextAlignment &textAlignment)
       return "right";
     case TextAlignment::Justified:
       return "justified";
+    case TextAlignment::Start:
+      return "start";
+    case TextAlignment::End:
+      return "end";
   }
 
   LOG(ERROR) << "Unsupported TextAlignment value";
@@ -916,6 +925,8 @@ inline void fromRawValue(const PropsParserContext &context, const RawValue &valu
       result = TextDecorationStyle::Dotted;
     } else if (string == "dashed") {
       result = TextDecorationStyle::Dashed;
+    } else if (string == "wavy") {
+      result = TextDecorationStyle::Wavy;
     } else {
       LOG(ERROR) << "Unsupported TextDecorationStyle value: " << string;
       react_native_expect(false);
@@ -941,6 +952,8 @@ inline std::string toString(const TextDecorationStyle &textDecorationStyle)
       return "dotted";
     case TextDecorationStyle::Dashed:
       return "dashed";
+    case TextDecorationStyle::Wavy:
+      return "wavy";
   }
 
   LOG(ERROR) << "Unsupported TextDecorationStyle value";
@@ -1128,6 +1141,11 @@ constexpr static MapBuffer::Key TA_KEY_ROLE = 26;
 constexpr static MapBuffer::Key TA_KEY_TEXT_TRANSFORM = 27;
 constexpr static MapBuffer::Key TA_KEY_ALIGNMENT_VERTICAL = 28;
 constexpr static MapBuffer::Key TA_KEY_MAX_FONT_SIZE_MULTIPLIER = 29;
+constexpr static MapBuffer::Key TA_KEY_TEXT_EFFECTS = 30;
+
+// Keys within each text effect entry MapBuffer
+constexpr static MapBuffer::Key TE_KEY_NAME = 0;
+constexpr static MapBuffer::Key TE_KEY_PROPS = 1;
 
 // constants for ParagraphAttributes serialization
 constexpr static MapBuffer::Key PA_KEY_MAX_NUMBER_OF_LINES = 0;
@@ -1332,6 +1350,16 @@ inline MapBuffer toMapBuffer(const TextAttributes &textAttributes)
   if (textAttributes.role.has_value()) {
     builder.putInt(TA_KEY_ROLE, static_cast<int32_t>(*textAttributes.role));
   }
+  if (!textAttributes.textEffects.empty()) {
+    auto effectsBuilder = MapBufferBuilder();
+    for (size_t i = 0; i < textAttributes.textEffects.size(); i++) {
+      auto effectBuilder = MapBufferBuilder();
+      effectBuilder.putString(TE_KEY_NAME, textAttributes.textEffects[i].name);
+      effectBuilder.putString(TE_KEY_PROPS, folly::toJson(textAttributes.textEffects[i].props));
+      effectsBuilder.putMapBuffer(i, effectBuilder.build());
+    }
+    builder.putMapBuffer(TA_KEY_TEXT_EFFECTS, effectsBuilder.build());
+  }
   return builder.build();
 }
 

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

@@ -97,7 +97,9 @@ enum class TextAlignment {
   Left, // Visually left aligned.
   Center, // Visually centered.
   Right, // Visually right aligned.
-  Justified // Fully-justified. The last line in a paragraph is natural-aligned.
+  Justified, // Fully-justified. The last line in a paragraph is natural-aligned.
+  Start, // Aligned to the start side of the paragraph direction.
+  End // Aligned to the end side of the paragraph direction.
 };
 
 enum class TextAlignmentVertical {
@@ -134,7 +136,7 @@ enum class LineBreakMode {
 
 enum class TextDecorationLineType { None, Underline, Strikethrough, UnderlineStrikethrough };
 
-enum class TextDecorationStyle { Solid, Double, Dotted, Dashed };
+enum class TextDecorationStyle { Solid, Double, Dotted, Dashed, Wavy };
 
 enum class TextTransform {
   None,

package/ReactCommon/react/renderer/attributedstring/tests/ParagraphAttributesTest.cpp

@@ -0,0 +1,73 @@
+/*
+ * 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 <react/renderer/attributedstring/ParagraphAttributes.h>
+
+namespace facebook::react {
+
+// The three Float fields default to NaN, and NaN != NaN under IEEE-754.
+// operator== must special-case NaN via floatEquality so two freshly
+// default-constructed ParagraphAttributes compare equal.
+TEST(
+    ParagraphAttributesTest,
+    testOperatorEqualsDefaultConstructedInstancesAreEqual) {
+  ParagraphAttributes a{};
+  ParagraphAttributes b{};
+
+  EXPECT_TRUE(a == b);
+}
+
+// operator== compares Float fields with an epsilon tolerance (0.005) rather
+// than an exact ==. Differences below the epsilon must still compare equal;
+// differences well above the epsilon must compare unequal.
+TEST(
+    ParagraphAttributesTest,
+    testOperatorEqualsFloatFieldsUseEpsilonComparison) {
+  ParagraphAttributes a{};
+  a.minimumFontSize = 12.0f;
+  a.maximumFontSize = 48.0f;
+  a.minimumFontScale = 0.5f;
+  auto b = a;
+
+  b.minimumFontSize = a.minimumFontSize + 0.001f;
+  b.maximumFontSize = a.maximumFontSize + 0.001f;
+  b.minimumFontScale = a.minimumFontScale + 0.001f;
+  EXPECT_TRUE(a == b);
+
+  b = a;
+  b.minimumFontSize = a.minimumFontSize + 1.0f;
+  EXPECT_FALSE(a == b);
+}
+
+// floatEquality returns true only when *both* operands are NaN or when
+// *neither* is. A NaN-vs-finite mismatch in any of the three float fields
+// must therefore make the instances unequal, even though both operands are
+// "invalid" font sizes.
+TEST(
+    ParagraphAttributesTest,
+    testOperatorEqualsNaNVsFiniteFloatComparesUnequal) {
+  ParagraphAttributes withNaN{};
+  ParagraphAttributes withFinite{};
+  withFinite.minimumFontSize = 12.0f;
+
+  EXPECT_FALSE(withNaN == withFinite);
+}
+
+// textAlignVertical is a std::optional; operator== must treat "unset" and
+// "set" as distinct, independent of the wrapped value.
+TEST(
+    ParagraphAttributesTest,
+    testOperatorEqualsHandlesOptionalTextAlignVerticalSetVsUnset) {
+  ParagraphAttributes unset{};
+  ParagraphAttributes set{};
+  set.textAlignVertical = TextAlignmentVertical::Auto;
+
+  EXPECT_FALSE(unset == set);
+}
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/componentregistry/ComponentDescriptorRegistry.cpp

@@ -12,8 +12,10 @@
 #include <react/debug/react_native_assert.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
+#ifndef RCT_REMOVE_LEGACY_COMPONENT_INTEROP
 #include <react/renderer/components/legacyviewmanagerinterop/UnstableLegacyViewManagerAutomaticComponentDescriptor.h>
 #include <react/renderer/components/legacyviewmanagerinterop/UnstableLegacyViewManagerAutomaticShadowNode.h>
+#endif // RCT_REMOVE_LEGACY_COMPONENT_INTEROP
 #include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/ShadowNodeFragment.h>
 #include <utility>
@@ -84,6 +86,7 @@ const ComponentDescriptor& ComponentDescriptorRegistry::at(
   }
 
   if (it == _registryByName.end()) {
+#ifndef RCT_REMOVE_LEGACY_COMPONENT_INTEROP
     if (ReactNativeFeatureFlags::useFabricInterop()) {
       // When interop is enabled, if the component is not found we rely on
       // UnstableLegacyViewManagerAutomaticComponentDescriptor to support legacy
@@ -94,6 +97,7 @@ const ComponentDescriptor& ComponentDescriptorRegistry::at(
       registerComponentDescriptor(componentDescriptor);
       return *_registryByName.find(unifiedComponentName)->second;
     } else {
+#endif // RCT_REMOVE_LEGACY_COMPONENT_INTEROP
       // When interop is disabled, if the component is not found we rely on
       // fallbackComponentDescriptor (default:
       // UnimplementedNativeViewComponentDescriptor).
@@ -107,7 +111,9 @@ const ComponentDescriptor& ComponentDescriptorRegistry::at(
       } else {
         return *_fallbackComponentDescriptor.get();
       }
+#ifndef RCT_REMOVE_LEGACY_COMPONENT_INTEROP
     }
+#endif // RCT_REMOVE_LEGACY_COMPONENT_INTEROP
   }
 
   return *it->second;