react-native 0.71.6 → 0.72.0-rc.1

package/ReactCommon/react/renderer/runtimescheduler/Task.cpp

@@ -17,18 +17,35 @@ Task::Task(
       callback(std::move(callback)),
       expirationTime(expirationTime) {}
 
+Task::Task(
+    SchedulerPriority priority,
+    RawCallback callback,
+    std::chrono::steady_clock::time_point expirationTime)
+    : priority(priority),
+      callback(std::move(callback)),
+      expirationTime(expirationTime) {}
+
 jsi::Value Task::execute(jsi::Runtime &runtime, bool didUserCallbackTimeout) {
   auto result = jsi::Value::undefined();
-  // Cancelled task doesn't have a callback.
-  if (callback) {
+  // Canceled task doesn't have a callback.
+  if (!callback) {
+    return result;
+  }
+
+  auto &cbVal = callback.value();
+
+  if (cbVal.index() == 0) {
     // Callback in JavaScript is expecting a single bool parameter.
     // React team plans to remove it in the future when a scheduler bug on web
     // is resolved.
-    result = callback.value().call(runtime, {didUserCallbackTimeout});
-
-    // Destroying callback to prevent calling it twice.
-    callback.reset();
+    result =
+        std::get<jsi::Function>(cbVal).call(runtime, {didUserCallbackTimeout});
+  } else {
+    // Calling a raw callback
+    std::get<RawCallback>(cbVal)(runtime);
   }
+  // Destroying callback to prevent calling it twice.
+  callback.reset();
   return result;
 }
 

package/ReactCommon/react/renderer/runtimescheduler/Task.h

@@ -7,30 +7,37 @@
 
 #pragma once
 
+#include <ReactCommon/SchedulerPriority.h>
 #include <jsi/jsi.h>
 #include <react/renderer/runtimescheduler/RuntimeSchedulerClock.h>
-#include <react/renderer/runtimescheduler/SchedulerPriority.h>
 
 #include <optional>
+#include <variant>
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 class RuntimeScheduler;
 class TaskPriorityComparer;
 
-struct Task final {
+using RawCallback = std::function<void(jsi::Runtime &)>;
+
+struct Task final : public jsi::NativeState {
   Task(
       SchedulerPriority priority,
       jsi::Function callback,
       std::chrono::steady_clock::time_point expirationTime);
 
+  Task(
+      SchedulerPriority priority,
+      RawCallback callback,
+      std::chrono::steady_clock::time_point expirationTime);
+
  private:
   friend RuntimeScheduler;
   friend TaskPriorityComparer;
 
   SchedulerPriority priority;
-  std::optional<jsi::Function> callback;
+  std::optional<std::variant<jsi::Function, RawCallback>> callback;
   RuntimeSchedulerClock::time_point expirationTime;
 
   jsi::Value execute(jsi::Runtime &runtime, bool didUserCallbackTimeout);
@@ -45,5 +52,4 @@ class TaskPriorityComparer {
   }
 };
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react

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

@@ -9,6 +9,7 @@
 
 #include <folly/dynamic.h>
 #include <jsi/jsi.h>
+#include <react/renderer/core/CoreFeatures.h>
 #include <react/renderer/runtimescheduler/Task.h>
 
 namespace facebook {
@@ -22,9 +23,15 @@ struct TaskWrapper : public jsi::HostObject {
 
 inline static jsi::Value valueFromTask(
     jsi::Runtime &runtime,
-    std::shared_ptr<Task> const &task) {
-  return jsi::Object::createFromHostObject(
-      runtime, std::make_shared<TaskWrapper>(task));
+    std::shared_ptr<Task> task) {
+  if (CoreFeatures::useNativeState) {
+    jsi::Object obj(runtime);
+    obj.setNativeState(runtime, std::move(task));
+    return obj;
+  } else {
+    return jsi::Object::createFromHostObject(
+        runtime, std::make_shared<TaskWrapper>(task));
+  }
 }
 
 inline static std::shared_ptr<Task> taskFromValue(
@@ -34,7 +41,11 @@ inline static std::shared_ptr<Task> taskFromValue(
     return nullptr;
   }
 
-  return value.getObject(runtime).getHostObject<TaskWrapper>(runtime)->task;
+  if (CoreFeatures::useNativeState) {
+    return value.getObject(runtime).getNativeState<Task>(runtime);
+  } else {
+    return value.getObject(runtime).getHostObject<TaskWrapper>(runtime)->task;
+  }
 }
 
 } // namespace react

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

@@ -6,7 +6,7 @@
  */
 
 #include <gtest/gtest.h>
-#include <hermes/API/hermes/hermes.h>
+#include <hermes/hermes.h>
 #include <jsi/jsi.h>
 #include <react/renderer/runtimescheduler/RuntimeScheduler.h>
 #include <memory>

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

@@ -6,6 +6,7 @@
  */
 
 #include <gtest/gtest.h>
+#include <react/renderer/runtimescheduler/SchedulerPriorityUtils.h>
 #include <react/renderer/runtimescheduler/Task.h>
 #include <chrono>
 

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

@@ -118,18 +118,26 @@ Scheduler::Scheduler(
     uiManager->registerCommitHook(*commitHook);
   }
 
-  if (animationDelegate != nullptr) {
-    animationDelegate->setComponentDescriptorRegistry(
-        componentDescriptorRegistry_);
-  }
-  uiManager_->setAnimationDelegate(animationDelegate);
-
 #ifdef ANDROID
   removeOutstandingSurfacesOnDestruction_ = true;
+  reduceDeleteCreateMutationLayoutAnimation_ = reactNativeConfig_->getBool(
+      "react_fabric:reduce_delete_create_mutation_layout_animation_android");
 #else
   removeOutstandingSurfacesOnDestruction_ = reactNativeConfig_->getBool(
       "react_fabric:remove_outstanding_surfaces_on_destruction_ios");
+  reduceDeleteCreateMutationLayoutAnimation_ = true;
 #endif
+
+  CoreFeatures::blockPaintForUseLayoutEffect = reactNativeConfig_->getBool(
+      "react_fabric:block_paint_for_use_layout_effect");
+
+  if (animationDelegate != nullptr) {
+    animationDelegate->setComponentDescriptorRegistry(
+        componentDescriptorRegistry_);
+    animationDelegate->setReduceDeleteCreateMutation(
+        reduceDeleteCreateMutationLayoutAnimation_);
+  }
+  uiManager_->setAnimationDelegate(animationDelegate);
 }
 
 Scheduler::~Scheduler() {
@@ -151,7 +159,7 @@ Scheduler::~Scheduler() {
   // Then, let's verify that the requirement was satisfied.
   auto surfaceIds = std::vector<SurfaceId>{};
   uiManager_->getShadowTreeRegistry().enumerate(
-      [&surfaceIds](ShadowTree const &shadowTree) {
+      [&surfaceIds](ShadowTree const &shadowTree, bool &) {
         surfaceIds.push_back(shadowTree.getSurfaceId());
       });
 
@@ -259,7 +267,8 @@ void Scheduler::renderTemplateToSurface(
                         std::make_shared<ShadowNode::ListOfShared>(
                             ShadowNode::ListOfShared{tree}),
                     });
-              });
+              },
+              {/* default commit options */});
         });
   } catch (const std::exception &e) {
     LOG(ERROR) << "    >>>> EXCEPTION <<<  rendering uiTemplate in "
@@ -293,11 +302,34 @@ void Scheduler::animationTick() const {
 #pragma mark - UIManagerDelegate
 
 void Scheduler::uiManagerDidFinishTransaction(
-    MountingCoordinator::Shared const &mountingCoordinator) {
+    MountingCoordinator::Shared mountingCoordinator,
+    bool mountSynchronously) {
   SystraceSection s("Scheduler::uiManagerDidFinishTransaction");
 
   if (delegate_ != nullptr) {
-    delegate_->schedulerDidFinishTransaction(mountingCoordinator);
+    if (CoreFeatures::blockPaintForUseLayoutEffect) {
+      auto weakRuntimeScheduler =
+          contextContainer_->find<std::weak_ptr<RuntimeScheduler>>(
+              "RuntimeScheduler");
+      auto runtimeScheduler = weakRuntimeScheduler.has_value()
+          ? weakRuntimeScheduler.value().lock()
+          : nullptr;
+      if (runtimeScheduler && !mountSynchronously) {
+        runtimeScheduler->scheduleTask(
+            SchedulerPriority::UserBlockingPriority,
+            [delegate = delegate_,
+             mountingCoordinator =
+                 std::move(mountingCoordinator)](jsi::Runtime &) {
+              delegate->schedulerDidFinishTransaction(
+                  std::move(mountingCoordinator));
+            });
+      } else {
+        delegate_->schedulerDidFinishTransaction(
+            std::move(mountingCoordinator));
+      }
+    } else {
+      delegate_->schedulerDidFinishTransaction(std::move(mountingCoordinator));
+    }
   }
 }
 void Scheduler::uiManagerDidCreateShadowNode(const ShadowNode &shadowNode) {

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

@@ -88,7 +88,8 @@ class Scheduler final : public UIManagerDelegate {
 #pragma mark - UIManagerDelegate
 
   void uiManagerDidFinishTransaction(
-      MountingCoordinator::Shared const &mountingCoordinator) override;
+      MountingCoordinator::Shared mountingCoordinator,
+      bool mountSynchronously) override;
   void uiManagerDidCreateShadowNode(const ShadowNode &shadowNode) override;
   void uiManagerDidDispatchCommand(
       const ShadowNode::Shared &shadowNode,
@@ -143,6 +144,7 @@ class Scheduler final : public UIManagerDelegate {
    * Temporary flags.
    */
   bool removeOutstandingSurfacesOnDestruction_{false};
+  bool reduceDeleteCreateMutationLayoutAnimation_{false};
 };
 
 } // namespace react

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

@@ -13,8 +13,7 @@
 #include <react/renderer/mounting/MountingCoordinator.h>
 #include <react/renderer/mounting/ShadowView.h>
 
-namespace facebook {
-namespace react {
+namespace facebook::react {
 
 /*
  * Abstract class for Scheduler's delegate.
@@ -27,7 +26,7 @@ class SchedulerDelegate {
    * to construct a new one.
    */
   virtual void schedulerDidFinishTransaction(
-      MountingCoordinator::Shared const &mountingCoordinator) = 0;
+      MountingCoordinator::Shared mountingCoordinator) = 0;
 
   /*
    * Called right after a new ShadowNode was created.
@@ -56,5 +55,4 @@ class SchedulerDelegate {
   virtual ~SchedulerDelegate() noexcept = default;
 };
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react

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

@@ -9,7 +9,6 @@
 
 #include <react/debug/react_native_assert.h>
 #include <react/renderer/debug/SystraceSection.h>
-#include <react/renderer/scheduler/Scheduler.h>
 #include <react/renderer/uimanager/UIManager.h>
 
 namespace facebook::react {
@@ -28,13 +27,10 @@ SurfaceHandler::SurfaceHandler(SurfaceHandler &&other) noexcept {
 }
 
 SurfaceHandler &SurfaceHandler::operator=(SurfaceHandler &&other) noexcept {
-  std::unique_lock<butter::shared_mutex> lock1(linkMutex_, std::defer_lock);
-  std::unique_lock<butter::shared_mutex> lock2(
-      parametersMutex_, std::defer_lock);
-  std::unique_lock<butter::shared_mutex> lock3(
-      other.linkMutex_, std::defer_lock);
-  std::unique_lock<butter::shared_mutex> lock4(
-      other.parametersMutex_, std::defer_lock);
+  std::unique_lock lock1(linkMutex_, std::defer_lock);
+  std::unique_lock lock2(parametersMutex_, std::defer_lock);
+  std::unique_lock lock3(other.linkMutex_, std::defer_lock);
+  std::unique_lock lock4(other.parametersMutex_, std::defer_lock);
   std::lock(lock1, lock2, lock3, lock4);
 
   link_ = other.link_;
@@ -54,13 +50,13 @@ void SurfaceHandler::setContextContainer(
 }
 
 Status SurfaceHandler::getStatus() const noexcept {
-  std::shared_lock<butter::shared_mutex> lock(linkMutex_);
+  std::shared_lock lock(linkMutex_);
   return link_.status;
 }
 
 void SurfaceHandler::start() const noexcept {
   SystraceSection s("SurfaceHandler::start");
-  std::unique_lock<butter::shared_mutex> lock(linkMutex_);
+  std::unique_lock lock(linkMutex_);
   react_native_assert(
       link_.status == Status::Registered && "Surface must be registered.");
   react_native_assert(
@@ -72,7 +68,7 @@ void SurfaceHandler::start() const noexcept {
   auto parameters = Parameters{};
   {
     SystraceSection s2("SurfaceHandler::start::paramsLock");
-    std::shared_lock<butter::shared_mutex> parametersLock(parametersMutex_);
+    std::shared_lock parametersLock(parametersMutex_);
     parameters = parameters_;
   }
 
@@ -99,7 +95,7 @@ void SurfaceHandler::start() const noexcept {
 void SurfaceHandler::stop() const noexcept {
   auto shadowTree = ShadowTree::Unique{};
   {
-    std::unique_lock<butter::shared_mutex> lock(linkMutex_);
+    std::unique_lock lock(linkMutex_);
     react_native_assert(
         link_.status == Status::Running && "Surface must be running.");
 
@@ -117,7 +113,7 @@ void SurfaceHandler::stop() const noexcept {
 
 void SurfaceHandler::setDisplayMode(DisplayMode displayMode) const noexcept {
   {
-    std::unique_lock<butter::shared_mutex> lock(parametersMutex_);
+    std::unique_lock lock(parametersMutex_);
     if (parameters_.displayMode == displayMode) {
       return;
     }
@@ -126,7 +122,7 @@ void SurfaceHandler::setDisplayMode(DisplayMode displayMode) const noexcept {
   }
 
   {
-    std::shared_lock<butter::shared_mutex> lock(linkMutex_);
+    std::shared_lock lock(linkMutex_);
 
     if (link_.status != Status::Running) {
       return;
@@ -143,41 +139,41 @@ void SurfaceHandler::setDisplayMode(DisplayMode displayMode) const noexcept {
 }
 
 DisplayMode SurfaceHandler::getDisplayMode() const noexcept {
-  std::shared_lock<butter::shared_mutex> lock(parametersMutex_);
+  std::shared_lock lock(parametersMutex_);
   return parameters_.displayMode;
 }
 
 #pragma mark - Accessors
 
 SurfaceId SurfaceHandler::getSurfaceId() const noexcept {
-  std::shared_lock<butter::shared_mutex> lock(parametersMutex_);
+  std::shared_lock lock(parametersMutex_);
   return parameters_.surfaceId;
 }
 
 void SurfaceHandler::setSurfaceId(SurfaceId surfaceId) const noexcept {
-  std::unique_lock<butter::shared_mutex> lock(parametersMutex_);
+  std::unique_lock lock(parametersMutex_);
   parameters_.surfaceId = surfaceId;
 }
 
 std::string SurfaceHandler::getModuleName() const noexcept {
-  std::shared_lock<butter::shared_mutex> lock(parametersMutex_);
+  std::shared_lock lock(parametersMutex_);
   return parameters_.moduleName;
 }
 
 void SurfaceHandler::setProps(folly::dynamic const &props) const noexcept {
   SystraceSection s("SurfaceHandler::setProps");
-  std::unique_lock<butter::shared_mutex> lock(parametersMutex_);
+  std::unique_lock lock(parametersMutex_);
   parameters_.props = props;
 }
 
 folly::dynamic SurfaceHandler::getProps() const noexcept {
-  std::shared_lock<butter::shared_mutex> lock(parametersMutex_);
+  std::shared_lock lock(parametersMutex_);
   return parameters_.props;
 }
 
 std::shared_ptr<MountingCoordinator const>
 SurfaceHandler::getMountingCoordinator() const noexcept {
-  std::shared_lock<butter::shared_mutex> lock(linkMutex_);
+  std::shared_lock lock(linkMutex_);
   react_native_assert(
       link_.status != Status::Unregistered && "Surface must be registered.");
   react_native_assert(
@@ -190,7 +186,7 @@ SurfaceHandler::getMountingCoordinator() const noexcept {
 Size SurfaceHandler::measure(
     LayoutConstraints const &layoutConstraints,
     LayoutContext const &layoutContext) const noexcept {
-  std::shared_lock<butter::shared_mutex> lock(linkMutex_);
+  std::shared_lock lock(linkMutex_);
 
   if (link_.status != Status::Running) {
     return layoutConstraints.clamp({0, 0});
@@ -216,7 +212,7 @@ void SurfaceHandler::constraintLayout(
     LayoutContext const &layoutContext) const noexcept {
   SystraceSection s("SurfaceHandler::constraintLayout");
   {
-    std::unique_lock<butter::shared_mutex> lock(parametersMutex_);
+    std::unique_lock lock(parametersMutex_);
 
     if (parameters_.layoutConstraints == layoutConstraints &&
         parameters_.layoutContext == layoutContext) {
@@ -228,7 +224,7 @@ void SurfaceHandler::constraintLayout(
   }
 
   {
-    std::shared_lock<butter::shared_mutex> lock(linkMutex_);
+    std::shared_lock lock(linkMutex_);
 
     if (link_.status != Status::Running) {
       return;
@@ -239,20 +235,22 @@ void SurfaceHandler::constraintLayout(
 
     react_native_assert(
         link_.shadowTree && "`link_.shadowTree` must not be null.");
-    link_.shadowTree->commit([&](RootShadowNode const &oldRootShadowNode) {
-      return oldRootShadowNode.clone(
-          propsParserContext, layoutConstraints, layoutContext);
-    });
+    link_.shadowTree->commit(
+        [&](RootShadowNode const &oldRootShadowNode) {
+          return oldRootShadowNode.clone(
+              propsParserContext, layoutConstraints, layoutContext);
+        },
+        {/* default commit options */});
   }
 }
 
 LayoutConstraints SurfaceHandler::getLayoutConstraints() const noexcept {
-  std::shared_lock<butter::shared_mutex> lock(parametersMutex_);
+  std::shared_lock lock(parametersMutex_);
   return parameters_.layoutConstraints;
 }
 
 LayoutContext SurfaceHandler::getLayoutContext() const noexcept {
-  std::shared_lock<butter::shared_mutex> lock(parametersMutex_);
+  std::shared_lock lock(parametersMutex_);
   return parameters_.layoutContext;
 }
 
@@ -285,15 +283,15 @@ void SurfaceHandler::applyDisplayMode(DisplayMode displayMode) const noexcept {
       link_.shadowTree->commit(
           [&](RootShadowNode const & /*oldRootShadowNode*/) {
             return std::static_pointer_cast<RootShadowNode>(
-                revision.rootShadowNode->ShadowNode::clone(
-                    ShadowNodeFragment{}));
-          });
+                revision.rootShadowNode->ShadowNode::clone({}));
+          },
+          {/* default commit options */});
       break;
   }
 }
 
 void SurfaceHandler::setUIManager(UIManager const *uiManager) const noexcept {
-  std::unique_lock<butter::shared_mutex> lock(linkMutex_);
+  std::unique_lock lock(linkMutex_);
 
   react_native_assert(
       link_.status != Status::Running && "Surface must not be running.");

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

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <memory>
+#include <shared_mutex>
 
 #include <react/renderer/core/LayoutConstraints.h>
 #include <react/renderer/core/LayoutContext.h>
@@ -182,7 +183,7 @@ class SurfaceHandler {
   };
 
   /*
-   * Represents an underlying link to a `ShadowTree` and an `UIMananger`.
+   * Represents an underlying link to a `ShadowTree` and an `UIManager`.
    * Registering, unregistering, starting, and stopping the surface requires
    * acquiring a unique lock; other access needs only a shared lock.
    */
@@ -195,13 +196,13 @@ class SurfaceHandler {
   /*
    * `link_` and `linkMutex_` pair.
    */
-  mutable butter::shared_mutex linkMutex_;
+  mutable std::shared_mutex linkMutex_;
   mutable Link link_;
 
   /*
    * `parameters_` and `parametersMutex_` pair.
    */
-  mutable butter::shared_mutex parametersMutex_;
+  mutable std::shared_mutex parametersMutex_;
   mutable Parameters parameters_;
 };
 

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

@@ -21,7 +21,7 @@ void SurfaceManager::startSurface(
     LayoutConstraints const &layoutConstraints,
     LayoutContext const &layoutContext) const noexcept {
   {
-    std::unique_lock<butter::shared_mutex> lock(mutex_);
+    std::unique_lock lock(mutex_);
     auto surfaceHandler = SurfaceHandler{moduleName, surfaceId};
     surfaceHandler.setContextContainer(scheduler_.getContextContainer());
     registry_.emplace(surfaceId, std::move(surfaceHandler));
@@ -44,7 +44,7 @@ void SurfaceManager::stopSurface(SurfaceId surfaceId) const noexcept {
   });
 
   {
-    std::unique_lock<butter::shared_mutex> lock(mutex_);
+    std::unique_lock lock(mutex_);
 
     auto iterator = registry_.find(surfaceId);
     registry_.erase(iterator);
@@ -88,7 +88,7 @@ void SurfaceManager::visit(
     SurfaceId surfaceId,
     std::function<void(SurfaceHandler const &surfaceHandler)> const &callback)
     const noexcept {
-  std::shared_lock<butter::shared_mutex> lock(mutex_);
+  std::shared_lock lock(mutex_);
 
   auto iterator = registry_.find(surfaceId);
 

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

@@ -9,6 +9,7 @@
 
 #include <butter/map.h>
 #include <mutex>
+#include <shared_mutex>
 
 #include <react/renderer/core/LayoutConstraints.h>
 #include <react/renderer/mounting/MountingCoordinator.h>
@@ -59,7 +60,7 @@ class SurfaceManager final {
       const noexcept;
 
   Scheduler const &scheduler_;
-  mutable butter::shared_mutex mutex_; // Protects `registry_`.
+  mutable std::shared_mutex mutex_; // Protects `registry_`.
   mutable butter::map<SurfaceId, SurfaceHandler> registry_{};
 };
 

package/ReactCommon/react/renderer/telemetry/tests/TransactionTelemetryTest.cpp

@@ -26,7 +26,7 @@ MockClock::time_point MockClock::time_ = {};
  * The OS might decide right before the specified time elapsed to schedule
  * another thread/process, with the result that more time passes in reality than
  * the caller intended. Prefer the `MockClock` and only use this function to
- * verify that at least the specifid time has passed but wihtout making exact
+ * verify that at least the specified time has passed but without making exact
  * verifications.
  */
 static void sleepAtLeast(double durationInSeconds) {

package/ReactCommon/react/renderer/templateprocessor/BUCK

@@ -32,6 +32,8 @@ rn_xplat_cxx_library(
         prefix = "react/renderer/templateprocessor",
     ),
     compiler_flags_pedantic = True,
+    # TODO(145803035) Fix Android tests
+    fbandroid_tests_override = [],
     fbobjc_compiler_flags = APPLE_COMPILER_FLAGS,
     fbobjc_preprocessor_flags = get_preprocessor_flags_for_build_mode() + get_apple_inspector_flags(),
     force_static = True,

package/ReactCommon/react/renderer/textlayoutmanager/BUCK

@@ -14,6 +14,8 @@ load(
     "subdir_glob",
 )
 
+oncall("react_native")
+
 APPLE_COMPILER_FLAGS = get_apple_compiler_flags()
 
 rn_xplat_cxx_library(
@@ -83,7 +85,7 @@ rn_xplat_cxx_library(
     ],
     ios_exported_headers = subdir_glob(
         [
-            ("platform/ios", "*.h"),
+            ("platform/ios/react/renderer/textlayoutmanager", "*.h"),
         ],
         prefix = "react/renderer/textlayoutmanager",
     ),
@@ -94,7 +96,7 @@ rn_xplat_cxx_library(
     ],
     ios_headers = subdir_glob(
         [
-            ("platform/ios", "**/*.h"),
+            ("platform/ios/react/renderer/textlayoutmanager", "**/*.h"),
         ],
         prefix = "",
     ),

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

@@ -7,6 +7,7 @@
 
 #pragma once
 
+#include <folly/Hash.h>
 #include <react/renderer/attributedstring/AttributedString.h>
 #include <react/renderer/attributedstring/ParagraphAttributes.h>
 #include <react/renderer/core/LayoutConstraints.h>

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

@@ -12,6 +12,7 @@
 #include <react/common/mapbuffer/JReadableMapBuffer.h>
 #include <react/jni/ReadableNativeMap.h>
 #include <react/renderer/attributedstring/conversions.h>
+#include <react/renderer/core/CoreFeatures.h>
 #include <react/renderer/core/conversions.h>
 #include <react/renderer/mapbuffer/MapBuffer.h>
 #include <react/renderer/mapbuffer/MapBufferBuilder.h>
@@ -146,7 +147,10 @@ Size measureAndroidComponentMapBuffer(
 TextLayoutManager::TextLayoutManager(
     const ContextContainer::Shared &contextContainer)
     : contextContainer_(contextContainer),
-      measureCache_(kSimpleThreadSafeCacheSizeCap) {}
+      measureCache_(
+          CoreFeatures::cacheLastTextMeasurement
+              ? 8096
+              : kSimpleThreadSafeCacheSizeCap) {}
 
 void *TextLayoutManager::getNativeTextLayoutManager() const {
   return self_;
@@ -154,8 +158,9 @@ void *TextLayoutManager::getNativeTextLayoutManager() const {
 
 TextMeasurement TextLayoutManager::measure(
     AttributedStringBox const &attributedStringBox,
-    ParagraphAttributes paragraphAttributes,
-    LayoutConstraints layoutConstraints) const {
+    ParagraphAttributes const &paragraphAttributes,
+    LayoutConstraints layoutConstraints,
+    std::shared_ptr<void> /* hostTextStorage */) const {
   auto &attributedString = attributedStringBox.getValue();
 
   auto measurement = measureCache_.get(
@@ -179,6 +184,12 @@ TextMeasurement TextLayoutManager::measure(
   measurement.size = layoutConstraints.clamp(measurement.size);
   return measurement;
 }
+std::shared_ptr<void> TextLayoutManager::getHostTextStorage(
+    AttributedString const & /* attributedStringBox */,
+    ParagraphAttributes const & /* paragraphAttributes */,
+    LayoutConstraints /* layoutConstraints */) const {
+  return nullptr;
+}
 
 TextMeasurement TextLayoutManager::measureCachedSpannableById(
     int64_t cacheId,