react-native-tvos 0.84.1-0 → 0.85.0-0

package/ReactCommon/react/renderer/mounting/ShadowTreeDelegate.h

@@ -38,6 +38,17 @@ class ShadowTreeDelegate {
       std::shared_ptr<const MountingCoordinator> mountingCoordinator,
       bool mountSynchronously) const = 0;
 
+  /*
+   * Called right after Shadow Tree commits a new React revision of the tree.
+   */
+  virtual void shadowTreeDidFinishReactCommit(const ShadowTree &shadowTree) const = 0;
+
+  /*
+   * Called right after Shadow Tree promotes a React revision of the tree to
+   * be merged.
+   */
+  virtual void shadowTreeDidPromoteReactRevision(const ShadowTree &shadowTree) const = 0;
+
   virtual ~ShadowTreeDelegate() noexcept = default;
 };
 

package/ReactCommon/react/renderer/mounting/ShadowView.cpp

@@ -50,10 +50,6 @@ bool ShadowView::operator==(const ShadowView& rhs) const {
              rhs.state);
 }
 
-bool ShadowView::operator!=(const ShadowView& rhs) const {
-  return !(*this == rhs);
-}
-
 #if RN_DEBUG_STRING_CONVERTIBLE
 
 std::string getDebugName(const ShadowView& object) {

package/ReactCommon/react/renderer/mounting/ShadowView.h

@@ -35,7 +35,6 @@ struct ShadowView final {
   ShadowView &operator=(ShadowView &&other) = default;
 
   bool operator==(const ShadowView &rhs) const;
-  bool operator!=(const ShadowView &rhs) const;
 
   ComponentName componentName{};
   ComponentHandle componentHandle{};

package/ReactCommon/react/renderer/mounting/internal/DiffMap.h

@@ -0,0 +1,170 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <react/featureflags/ReactNativeFeatureFlags.h>
+#include <optional>
+#include <unordered_map>
+#include "TinyMap.h"
+
+namespace facebook::react {
+
+/**
+ * A facade that delegates to either TinyMap or std::unordered_map based on
+ * the useUnorderedMapInDifferentiator feature flag. This allows safe rollout
+ * of the unordered_map change in the Differentiator.
+ *
+ * Exposes a subset of the std::unordered_map interface used by the
+ * Differentiator: find, insert, erase, begin, end, and range-for.
+ *
+ * The Iterator returns const references because it uses a cached copy
+ * internally (the two backends have different pair types). The Differentiator
+ * only reads through iterators, never writes.
+ */
+template <typename KeyT, typename ValueT>
+class DiffMap final {
+ public:
+  using Pair = std::pair<KeyT, ValueT>;
+
+  class Iterator {
+   public:
+    const Pair &operator*() const
+    {
+      syncCached();
+      return cached_;
+    }
+
+    const Pair *operator->() const
+    {
+      syncCached();
+      return &cached_;
+    }
+
+    Iterator &operator++()
+    {
+      if (useUnorderedMap_) {
+        ++umIt_;
+      } else {
+        ++tinyIt_;
+      }
+      dirty_ = true;
+      return *this;
+    }
+
+    bool operator==(const Iterator &other) const
+    {
+      if (useUnorderedMap_) {
+        return umIt_ == other.umIt_;
+      }
+      return tinyIt_ == other.tinyIt_;
+    }
+
+    bool operator!=(const Iterator &other) const
+    {
+      return !(*this == other);
+    }
+
+   private:
+    friend class DiffMap;
+
+    void syncCached() const
+    {
+      if (!dirty_) {
+        return;
+      }
+      if (useUnorderedMap_) {
+        cached_ = {umIt_->first, umIt_->second};
+      } else {
+        cached_ = {tinyIt_->first, tinyIt_->second};
+      }
+      dirty_ = false;
+    }
+
+    bool useUnorderedMap_{false};
+    typename TinyMap<KeyT, ValueT>::Iterator tinyIt_{nullptr};
+    typename std::unordered_map<KeyT, ValueT>::iterator umIt_{};
+    mutable Pair cached_{};
+    mutable bool dirty_{true};
+  };
+
+  DiffMap() : useUnorderedMap_(ReactNativeFeatureFlags::useUnorderedMapInDifferentiator())
+  {
+    if (useUnorderedMap_) {
+      unorderedMap_.emplace();
+    }
+  }
+
+  explicit DiffMap(size_t sizeHint) : useUnorderedMap_(ReactNativeFeatureFlags::useUnorderedMapInDifferentiator())
+  {
+    if (useUnorderedMap_) {
+      unorderedMap_.emplace();
+      unorderedMap_->reserve(sizeHint);
+    }
+  }
+
+  Iterator begin()
+  {
+    Iterator it;
+    it.useUnorderedMap_ = useUnorderedMap_;
+    if (useUnorderedMap_) {
+      it.umIt_ = unorderedMap_->begin();
+    } else {
+      it.tinyIt_ = tinyMap_.begin();
+    }
+    return it;
+  }
+
+  Iterator end()
+  {
+    Iterator it;
+    it.useUnorderedMap_ = useUnorderedMap_;
+    if (useUnorderedMap_) {
+      it.umIt_ = unorderedMap_->end();
+    } else {
+      it.tinyIt_ = tinyMap_.end();
+    }
+    return it;
+  }
+
+  Iterator find(KeyT key)
+  {
+    Iterator it;
+    it.useUnorderedMap_ = useUnorderedMap_;
+    if (useUnorderedMap_) {
+      it.umIt_ = unorderedMap_->find(key);
+    } else {
+      it.tinyIt_ = tinyMap_.find(key);
+    }
+    return it;
+  }
+
+  void insert(Pair pair)
+  {
+    if (useUnorderedMap_) {
+      unorderedMap_->insert(std::move(pair));
+    } else {
+      tinyMap_.insert(std::move(pair));
+    }
+  }
+
+  void erase(Iterator it)
+  {
+    if (useUnorderedMap_) {
+      unorderedMap_->erase(it.umIt_);
+    } else {
+      tinyMap_.erase(it.tinyIt_);
+    }
+  }
+
+ private:
+  bool useUnorderedMap_;
+  TinyMap<KeyT, ValueT> tinyMap_;
+  std::optional<std::unordered_map<KeyT, ValueT>> unorderedMap_;
+};
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/mounting/internal/ShadowViewNodePair.h

@@ -51,11 +51,6 @@ struct ShadowViewNodePair final {
     return this->shadowNode == rhs.shadowNode;
   }
 
-  bool operator!=(const ShadowViewNodePair &rhs) const
-  {
-    return !(*this == rhs);
-  }
-
   bool inOtherTree() const
   {
     return this->otherTreePair != nullptr;

package/ReactCommon/react/renderer/mounting/internal/sliceChildShadowNodeViewPairs.h

@@ -18,10 +18,10 @@ struct ShadowViewNodePair;
 /**
  * During differ, we need to keep some `ShadowViewNodePair`s in memory.
  * Some `ShadowViewNodePair`s are referenced from std::vectors returned
- * by `sliceChildShadowNodeViewPairs`; some are referenced in TinyMaps
+ * by `sliceChildShadowNodeViewPairs`; some are referenced in maps
  * for view (un)flattening especially; and it is not always clear which
- * std::vectors will outlive which TinyMaps, and vice-versa, so it doesn't
- * make sense for the std::vector or TinyMap to own any `ShadowViewNodePair`s.
+ * std::vectors will outlive which maps, and vice-versa, so it doesn't
+ * make sense for the std::vector or map to own any `ShadowViewNodePair`s.
  *
  * Thus, we introduce the concept of a scope.
  *

package/ReactCommon/react/renderer/mounting/stubs/StubView.cpp

@@ -59,10 +59,6 @@ bool operator==(const StubView& lhs, const StubView& rhs) {
   return true;
 }
 
-bool operator!=(const StubView& lhs, const StubView& rhs) {
-  return !(lhs == rhs);
-}
-
 #if RN_DEBUG_STRING_CONVERTIBLE
 
 std::string getDebugName(const StubView& stubView) {

package/ReactCommon/react/renderer/mounting/stubs/StubView.h

@@ -44,7 +44,6 @@ class StubView final {
 };
 
 bool operator==(const StubView &lhs, const StubView &rhs);
-bool operator!=(const StubView &lhs, const StubView &rhs);
 
 #if RN_DEBUG_STRING_CONVERTIBLE
 

package/ReactCommon/react/renderer/mounting/stubs/StubViewTree.cpp

@@ -302,10 +302,6 @@ bool operator==(const StubViewTree& lhs, const StubViewTree& rhs) {
   return true;
 }
 
-bool operator!=(const StubViewTree& lhs, const StubViewTree& rhs) {
-  return !(lhs == rhs);
-}
-
 void StubViewTree::recordMutation(const ShadowViewMutation& mutation) {
   switch (mutation.type) {
     case ShadowViewMutation::Create: {

package/ReactCommon/react/renderer/mounting/stubs/StubViewTree.h

@@ -52,7 +52,6 @@ class StubViewTree {
   std::vector<std::string> mountingLogs_{};
 
   friend bool operator==(const StubViewTree &lhs, const StubViewTree &rhs);
-  friend bool operator!=(const StubViewTree &lhs, const StubViewTree &rhs);
 
   std::ostream &dumpTags(std::ostream &stream) const;
 
@@ -62,6 +61,5 @@ class StubViewTree {
 };
 
 bool operator==(const StubViewTree &lhs, const StubViewTree &rhs);
-bool operator!=(const StubViewTree &lhs, const StubViewTree &rhs);
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/mounting/tests/StateReconciliationTest.cpp

@@ -37,6 +37,12 @@ class DummyShadowTreeDelegate : public ShadowTreeDelegate {
   void shadowTreeDidFinishTransaction(
       std::shared_ptr<const MountingCoordinator> mountingCoordinator,
       bool /*mountSynchronously*/) const override {}
+
+  void shadowTreeDidFinishReactCommit(
+      const ShadowTree& /*shadowTree*/) const override {}
+
+  void shadowTreeDidPromoteReactRevision(
+      const ShadowTree& /*shadowTree*/) const override {}
 };
 
 namespace {

package/ReactCommon/react/renderer/mounting/updateMountedFlag.cpp

@@ -50,8 +50,12 @@ void updateMountedFlag(
     newChild->setMounted(true);
     oldChild->setMounted(false);
 
-    if (commitSource == ShadowTreeCommitSource::React &&
-        ReactNativeFeatureFlags::updateRuntimeShadowNodeReferencesOnCommit()) {
+    if ((commitSource == ShadowTreeCommitSource::React &&
+         ReactNativeFeatureFlags::
+             updateRuntimeShadowNodeReferencesOnCommit()) ||
+        (ReactNativeFeatureFlags::
+             updateRuntimeShadowNodeReferencesOnCommitThread() &&
+         ShadowNode::getUseRuntimeShadowNodeReferenceUpdateOnThread())) {
       newChild->updateRuntimeShadowNodeReference(newChild);
     }
 
@@ -66,8 +70,12 @@ void updateMountedFlag(
     const auto& newChild = newChildren[index];
     newChild->setMounted(true);
 
-    if (commitSource == ShadowTreeCommitSource::React &&
-        ReactNativeFeatureFlags::updateRuntimeShadowNodeReferencesOnCommit()) {
+    if ((commitSource == ShadowTreeCommitSource::React &&
+         ReactNativeFeatureFlags::
+             updateRuntimeShadowNodeReferencesOnCommit()) ||
+        (ReactNativeFeatureFlags::
+             updateRuntimeShadowNodeReferencesOnCommitThread() &&
+         ShadowNode::getUseRuntimeShadowNodeReferenceUpdateOnThread())) {
       newChild->updateRuntimeShadowNodeReference(newChild);
     }
 

package/ReactCommon/react/renderer/observers/intersection/IntersectionObserver.cpp

@@ -32,6 +32,7 @@ std::vector<MarginValue> parseNormalizedRootMargin(
 
   std::vector<MarginValue> values;
   CSSSyntaxParser syntaxParser(marginStr);
+  CSSValueParser valueParser(syntaxParser);
 
   // Parse exactly 4 space-separated values
   while (!syntaxParser.isFinished() && values.size() < 4) {
@@ -40,7 +41,7 @@ std::vector<MarginValue> parseNormalizedRootMargin(
       break;
     }
 
-    auto parsed = parseNextCSSValue<CSSLength, CSSPercentage>(syntaxParser);
+    auto parsed = valueParser.parseNextValue<CSSLength, CSSPercentage>();
 
     if (std::holds_alternative<CSSLength>(parsed)) {
       auto length = std::get<CSSLength>(parsed);

package/ReactCommon/react/renderer/observers/intersection/IntersectionObserverState.cpp

@@ -55,9 +55,4 @@ bool IntersectionObserverState::operator==(
   return threshold_ == other.threshold_ &&
       rootThreshold_ == other.rootThreshold_;
 }
-
-bool IntersectionObserverState::operator!=(
-    const IntersectionObserverState& other) const {
-  return !(*this == other);
-}
 } // namespace facebook::react

package/ReactCommon/react/renderer/observers/intersection/IntersectionObserverState.h

@@ -30,7 +30,6 @@ class IntersectionObserverState {
   bool isIntersecting() const;
 
   bool operator==(const IntersectionObserverState &other) const;
-  bool operator!=(const IntersectionObserverState &other) const;
 
  private:
   explicit IntersectionObserverState(IntersectionObserverStateType state);

package/ReactCommon/react/renderer/runtimescheduler/tests/RuntimeSchedulerTest.cpp

@@ -728,7 +728,7 @@ TEST_P(RuntimeSchedulerTest, normalTaskYieldsToSynchronousAccessAndResumes) {
   // the test would be flaky in a multithreaded environment.
   stubQueue_->waitForTasks(2);
 
-  // Normal priority task immediatelly yield in favour of the sync task.
+  // Normal priority task immediately yield in favour of the sync task.
   stubQueue_->tick();
 
   EXPECT_EQ(stubQueue_->size(), 1);

package/ReactCommon/react/renderer/scheduler/CMakeLists.txt

@@ -21,6 +21,7 @@ target_link_libraries(react_renderer_scheduler
         react_featureflags
         react_performance_cdpmetrics
         react_performance_timeline
+        react_renderer_animationbackend
         react_renderer_componentregistry
         react_renderer_core
         react_renderer_debug

package/ReactCommon/react/renderer/scheduler/Scheduler.cpp

@@ -13,6 +13,7 @@
 #include <cxxreact/TraceSection.h>
 #include <react/debug/react_native_assert.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
+#include <react/renderer/animationbackend/AnimationBackend.h>
 #include <react/renderer/componentregistry/ComponentDescriptorRegistry.h>
 #include <react/renderer/core/EventQueueProcessor.h>
 #include <react/renderer/core/LayoutContext.h>
@@ -55,6 +56,16 @@ Scheduler::Scheduler(
   auto uiManager =
       std::make_shared<UIManager>(runtimeExecutor_, contextContainer_);
 
+  if (ReactNativeFeatureFlags::useSharedAnimatedBackend()) {
+    auto animationBackend = std::make_shared<AnimationBackend>(
+        schedulerToolbox.animationChoreographer, uiManager);
+
+    schedulerToolbox.animationChoreographer->setAnimationBackend(
+        animationBackend);
+
+    uiManager->unstable_setAnimationBackend(animationBackend);
+  }
+
   auto eventOwnerBox = std::make_shared<EventBeat::OwnerBox>();
   eventOwnerBox->owner = eventDispatcher_;
 
@@ -74,7 +85,7 @@ Scheduler::Scheduler(
 
   auto eventPipe = [uiManager](
                        jsi::Runtime& runtime,
-                       const EventTarget* eventTarget,
+                       EventTarget* eventTarget,
                        const std::string& type,
                        ReactEventPriority priority,
                        const EventPayload& payload) {
@@ -355,6 +366,22 @@ void Scheduler::uiManagerShouldRemoveEventListener(
   removeEventListener(listener);
 }
 
+void Scheduler::uiManagerDidFinishReactCommit(const ShadowTree& shadowTree) {
+  auto surfaceId = shadowTree.getSurfaceId();
+  runtimeScheduler_->scheduleRenderingUpdate(
+      surfaceId, [surfaceId, uiManager = uiManager_]() {
+        uiManager->getShadowTreeRegistry().visit(
+            surfaceId,
+            [](const ShadowTree& tree) { tree.promoteReactRevision(); });
+      });
+}
+
+void Scheduler::uiManagerDidPromoteReactRevision(const ShadowTree& shadowTree) {
+  if (delegate_ != nullptr) {
+    delegate_->schedulerShouldMergeReactRevision(shadowTree.getSurfaceId());
+  }
+}
+
 void Scheduler::uiManagerDidStartSurface(const ShadowTree& shadowTree) {
   std::shared_lock lock(onSurfaceStartCallbackMutex_);
   if (onSurfaceStartCallback_) {

package/ReactCommon/react/renderer/scheduler/Scheduler.h

@@ -46,8 +46,6 @@ class Scheduler final : public UIManagerDelegate {
 
   /*
    * Registers and unregisters a `SurfaceHandler` object in the `Scheduler`.
-   * All registered `SurfaceHandler` objects must be unregistered
-   * (with the same `Scheduler`) before their deallocation.
    */
   void registerSurface(const SurfaceHandler &surfaceHandler) const noexcept;
   void unregisterSurface(const SurfaceHandler &surfaceHandler) const noexcept;
@@ -97,6 +95,8 @@ class Scheduler final : public UIManagerDelegate {
   void uiManagerDidUpdateShadowTree(const std::unordered_map<Tag, folly::dynamic> &tagToProps) override;
   void uiManagerShouldAddEventListener(std::shared_ptr<const EventListener> listener) final;
   void uiManagerShouldRemoveEventListener(const std::shared_ptr<const EventListener> &listener) final;
+  void uiManagerDidFinishReactCommit(const ShadowTree &shadowTree) override;
+  void uiManagerDidPromoteReactRevision(const ShadowTree &shadowTree) override;
   void uiManagerDidStartSurface(const ShadowTree &shadowTree) override;
 
 #pragma mark - ContextContainer

package/ReactCommon/react/renderer/scheduler/SchedulerDelegate.h

@@ -38,6 +38,12 @@ class SchedulerDelegate {
   virtual void schedulerShouldRenderTransactions(
       const std::shared_ptr<const MountingCoordinator> &mountingCoordinator) = 0;
 
+  /*
+   * Called at the end of the event loop if there were commits to the JS
+   * during the pass and JS branch should be "merged" to the main revision.
+   */
+  virtual void schedulerShouldMergeReactRevision(SurfaceId surfaceId) = 0;
+
   /*
    * Called right after a new ShadowNode was created.
    */

package/ReactCommon/react/renderer/scheduler/SchedulerToolbox.h

@@ -10,6 +10,7 @@
 #include <memory>
 
 #include <ReactCommon/RuntimeExecutor.h>
+#include <react/renderer/animationbackend/AnimationChoreographer.h>
 #include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
 #include <react/renderer/core/EventBeat.h>
 #include <react/renderer/leakchecker/LeakChecker.h>
@@ -58,6 +59,12 @@ struct SchedulerToolbox final {
    * A list of `UIManagerCommitHook`s that should be registered in `UIManager`.
    */
   std::vector<std::shared_ptr<UIManagerCommitHook>> commitHooks;
+
+  /*
+   * Platform-specific choreographer for scheduling animation frame
+   * callbacks. Required when useSharedAnimatedBackend() is enabled.
+   */
+  std::shared_ptr<AnimationChoreographer> animationChoreographer;
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/scheduler/SurfaceHandler.cpp

@@ -224,8 +224,8 @@ std::shared_ptr<const ShadowNode> SurfaceHandler::dirtyMeasurableNodesRecursive(
     return nullptr;
   }
 
-  ShadowNode::SharedListOfShared newChildren =
-      ShadowNodeFragment::childrenPlaceholder();
+  std::shared_ptr<const std::vector<std::shared_ptr<const ShadowNode>>>
+      newChildren = ShadowNodeFragment::childrenPlaceholder();
 
   if (nodeHasChildren) {
     std::shared_ptr<std::vector<std::shared_ptr<const ShadowNode>>>

package/ReactCommon/react/renderer/textlayoutmanager/TextLayoutManagerExtended.h

@@ -19,31 +19,31 @@
 namespace facebook::react {
 
 template <typename TextLayoutManagerT>
-concept TextLayoutManagerWithPreparedLayout = requires(
+concept TextLayoutManagerWithPreparedTextLayout = requires(
     TextLayoutManagerT textLayoutManager,
     AttributedString attributedString,
     ParagraphAttributes paragraphAttributes,
     TextLayoutContext layoutContext,
     LayoutConstraints layoutConstraints,
-    typename TextLayoutManagerT::PreparedLayout preparedLayout) {
-  sizeof(typename TextLayoutManagerT::PreparedLayout);
+    typename TextLayoutManagerT::PreparedTextLayout preparedTextLayout) {
+  sizeof(typename TextLayoutManagerT::PreparedTextLayout);
   {
     textLayoutManager.prepareLayout(attributedString, paragraphAttributes, layoutContext, layoutConstraints)
-  } -> std::same_as<typename TextLayoutManagerT::PreparedLayout>;
+  } -> std::same_as<typename TextLayoutManagerT::PreparedTextLayout>;
   {
-    textLayoutManager.measurePreparedLayout(preparedLayout, layoutContext, layoutConstraints)
+    textLayoutManager.measurePreparedLayout(preparedTextLayout, layoutContext, layoutConstraints)
   } -> std::same_as<TextMeasurement>;
 };
 
 namespace detail {
 template <typename T>
-struct PreparedLayoutT {
+struct PreparedTextLayoutT {
   using type = std::nullptr_t;
 };
 
-template <TextLayoutManagerWithPreparedLayout T>
-struct PreparedLayoutT<T> {
-  using type = typename T::PreparedLayout;
+template <TextLayoutManagerWithPreparedTextLayout T>
+struct PreparedTextLayoutT<T> {
+  using type = typename T::PreparedTextLayout;
 };
 
 /**
@@ -64,12 +64,12 @@ class TextLayoutManagerExtended {
     };
   }
 
-  static constexpr bool supportsPreparedLayout()
+  static constexpr bool supportsPreparedTextLayout()
   {
-    return TextLayoutManagerWithPreparedLayout<TextLayoutManagerT>;
+    return TextLayoutManagerWithPreparedTextLayout<TextLayoutManagerT>;
   }
 
-  using PreparedLayout = typename PreparedLayoutT<TextLayoutManagerT>::type;
+  using PreparedTextLayout = typename PreparedTextLayoutT<TextLayoutManagerT>::type;
 
   TextLayoutManagerExtended(const TextLayoutManagerT &textLayoutManager) : textLayoutManager_(textLayoutManager) {}
 
@@ -84,24 +84,24 @@ class TextLayoutManagerExtended {
     LOG(FATAL) << "Platform TextLayoutManager does not support measureLines";
   }
 
-  PreparedLayout prepareLayout(
+  PreparedTextLayout prepareLayout(
       const AttributedString &attributedString,
       const ParagraphAttributes &paragraphAttributes,
       const TextLayoutContext &layoutContext,
       const LayoutConstraints &layoutConstraints) const
   {
-    if constexpr (supportsPreparedLayout()) {
+    if constexpr (supportsPreparedTextLayout()) {
       return textLayoutManager_.prepareLayout(attributedString, paragraphAttributes, layoutContext, layoutConstraints);
     }
     LOG(FATAL) << "Platform TextLayoutManager does not support prepareLayout";
   }
 
   TextMeasurement measurePreparedLayout(
-      const PreparedLayout &layout,
+      const PreparedTextLayout &layout,
       const TextLayoutContext &layoutContext,
       const LayoutConstraints &layoutConstraints) const
   {
-    if constexpr (supportsPreparedLayout()) {
+    if constexpr (supportsPreparedTextLayout()) {
       return textLayoutManager_.measurePreparedLayout(layout, layoutContext, layoutConstraints);
     }
     LOG(FATAL) << "Platform TextLayoutManager does not support measurePreparedLayout";
@@ -114,10 +114,10 @@ class TextLayoutManagerExtended {
 
 using TextLayoutManagerExtended = detail::TextLayoutManagerExtended<TextLayoutManager>;
 
-struct MeasuredPreparedLayout {
+struct MeasuredPreparedTextLayout {
   LayoutConstraints layoutConstraints;
   TextMeasurement measurement;
-  TextLayoutManagerExtended::PreparedLayout preparedLayout{};
+  TextLayoutManagerExtended::PreparedTextLayout preparedTextLayout{};
 };
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/textlayoutmanager/platform/android/react/renderer/textlayoutmanager/TextLayoutManager.cpp

@@ -23,7 +23,7 @@
 namespace facebook::react {
 
 static_assert(TextLayoutManagerExtended::supportsLineMeasurement());
-static_assert(TextLayoutManagerExtended::supportsPreparedLayout());
+static_assert(TextLayoutManagerExtended::supportsPreparedTextLayout());
 
 namespace {
 
@@ -296,7 +296,7 @@ LinesMeasurements TextLayoutManager::measureLines(
             std::move(doMeasureLines));
 }
 
-TextLayoutManager::PreparedLayout TextLayoutManager::prepareLayout(
+TextLayoutManager::PreparedTextLayout TextLayoutManager::prepareLayout(
     const AttributedString& attributedString,
     const ParagraphAttributes& paragraphAttributes,
     const TextLayoutContext& layoutContext,
@@ -333,7 +333,7 @@ TextLayoutManager::PreparedLayout TextLayoutManager::prepareLayout(
         auto minimumSize = layoutConstraints.minimumSize;
         auto maximumSize = layoutConstraints.maximumSize;
 
-        return PreparedLayout{jni::make_global(prepareTextLayout(
+        return PreparedTextLayout{jni::make_global(prepareTextLayout(
             fabricUIManager,
             layoutContext.surfaceId,
             attributedStringMB.get(),
@@ -371,15 +371,16 @@ TextLayoutManager::PreparedLayout TextLayoutManager::prepareLayout(
 
     const auto& fabricUIManager =
         contextContainer_->at<jni::global_ref<jobject>>("FabricUIManager");
-    return PreparedLayout{jni::make_global(reusePreparedLayoutWithNewReactTags(
-        fabricUIManager, preparedText->get(), javaReactTags.get()))};
+    return PreparedTextLayout{
+        jni::make_global(reusePreparedLayoutWithNewReactTags(
+            fabricUIManager, preparedText->get(), javaReactTags.get()))};
   } else {
-    return PreparedLayout{*preparedText};
+    return PreparedTextLayout{*preparedText};
   }
 }
 
 TextMeasurement TextLayoutManager::measurePreparedLayout(
-    const PreparedLayout& preparedLayout,
+    const PreparedTextLayout& preparedLayout,
     const TextLayoutContext& /*layoutContext*/,
     const LayoutConstraints& layoutConstraints) const {
   const auto& fabricUIManager =