react-native-tvos 0.81.4-0 → 0.82.0-0

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

@@ -24,13 +24,39 @@
 
 namespace facebook::react {
 
+namespace {
+
+class UIManagerCommitHookManagerImpl : public UIManagerCommitHookManager {
+ public:
+  explicit UIManagerCommitHookManagerImpl(std::weak_ptr<UIManager> uiManager)
+      : uiManager_(std::move(uiManager)) {}
+
+  ~UIManagerCommitHookManagerImpl() override = default;
+
+  void registerCommitHook(UIManagerCommitHook& commitHook) override {
+    if (auto uiManager = uiManager_.lock()) {
+      uiManager->registerCommitHook(commitHook);
+    }
+  }
+
+  void unregisterCommitHook(UIManagerCommitHook& commitHook) override {
+    if (auto uiManager = uiManager_.lock()) {
+      uiManager->unregisterCommitHook(commitHook);
+    }
+  }
+
+ private:
+  std::weak_ptr<UIManager> uiManager_;
+};
+
+} // namespace
+
 Scheduler::Scheduler(
     const SchedulerToolbox& schedulerToolbox,
     UIManagerAnimationDelegate* animationDelegate,
-    SchedulerDelegate* delegate) {
-  runtimeExecutor_ = schedulerToolbox.runtimeExecutor;
-  contextContainer_ = schedulerToolbox.contextContainer;
-
+    SchedulerDelegate* delegate)
+    : runtimeExecutor_(schedulerToolbox.runtimeExecutor),
+      contextContainer_(schedulerToolbox.contextContainer) {
   // Creating a container for future `EventDispatcher` instance.
   eventDispatcher_ = std::make_shared<std::optional<const EventDispatcher>>();
 
@@ -39,11 +65,23 @@ Scheduler::Scheduler(
   auto performanceEntryReporter = PerformanceEntryReporter::getInstance();
   performanceEntryReporter_ = performanceEntryReporter;
 
+  if (ReactNativeFeatureFlags::enableBridgelessArchitecture() &&
+      ReactNativeFeatureFlags::cdpInteractionMetricsEnabled()) {
+    cdpMetricsReporter_.emplace(CdpMetricsReporter{runtimeExecutor_});
+    performanceEntryReporter_->addEventTimingListener(&*cdpMetricsReporter_);
+  }
+
   eventPerformanceLogger_ =
       std::make_shared<EventPerformanceLogger>(performanceEntryReporter_);
 
   auto uiManager =
       std::make_shared<UIManager>(runtimeExecutor_, contextContainer_);
+  if (ReactNativeFeatureFlags::enableImagePrefetchingAndroid()) {
+    contextContainer_->insert(
+        std::string(UIManagerCommitHookManagerKey),
+        std::make_shared<UIManagerCommitHookManagerImpl>(uiManager));
+  }
+
   auto eventOwnerBox = std::make_shared<EventBeat::OwnerBox>();
   eventOwnerBox->owner = eventDispatcher_;
 
@@ -165,6 +203,10 @@ Scheduler::~Scheduler() {
   uiManager_->setDelegate(nullptr);
   uiManager_->setAnimationDelegate(nullptr);
 
+  if (cdpMetricsReporter_) {
+    performanceEntryReporter_->removeEventTimingListener(&*cdpMetricsReporter_);
+  }
+
   // Then, let's verify that the requirement was satisfied.
   auto surfaceIds = std::vector<SurfaceId>{};
   uiManager_->getShadowTreeRegistry().enumerate(
@@ -348,7 +390,7 @@ void Scheduler::reportMount(SurfaceId surfaceId) const {
   uiManager_->reportMount(surfaceId);
 }
 
-ContextContainer::Shared Scheduler::getContextContainer() const {
+std::shared_ptr<const ContextContainer> Scheduler::getContextContainer() const {
   return contextContainer_;
 }
 

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

@@ -8,9 +8,9 @@
 #pragma once
 
 #include <memory>
-#include <mutex>
 
 #include <ReactCommon/RuntimeExecutor.h>
+#include <react/performance/cdpmetrics/CdpMetricsReporter.h>
 #include <react/performance/timeline/PerformanceEntryReporter.h>
 #include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
 #include <react/renderer/core/ComponentDescriptor.h>
@@ -106,7 +106,7 @@ class Scheduler final : public UIManagerDelegate {
   void uiManagerDidStartSurface(const ShadowTree& shadowTree) override;
 
 #pragma mark - ContextContainer
-  ContextContainer::Shared getContextContainer() const;
+  std::shared_ptr<const ContextContainer> getContextContainer() const;
 
 #pragma mark - UIManager
   std::shared_ptr<UIManager> getUIManager() const;
@@ -142,13 +142,14 @@ class Scheduler final : public UIManagerDelegate {
   std::shared_ptr<std::optional<const EventDispatcher>> eventDispatcher_;
 
   std::shared_ptr<PerformanceEntryReporter> performanceEntryReporter_;
+  std::optional<CdpMetricsReporter> cdpMetricsReporter_;
   std::shared_ptr<EventPerformanceLogger> eventPerformanceLogger_;
 
   /**
    * Hold onto ContextContainer. See SchedulerToolbox.
    * Must not be nullptr.
    */
-  ContextContainer::Shared contextContainer_;
+  std::shared_ptr<const ContextContainer> contextContainer_;
 
   RuntimeScheduler* runtimeScheduler_{nullptr};
 

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

@@ -29,7 +29,7 @@ struct SchedulerToolbox final {
    * Represents general purpose DI container for product components/needs.
    * Must not be `nullptr`.
    */
-  ContextContainer::Shared contextContainer;
+  std::shared_ptr<const ContextContainer> contextContainer;
 
   /*
    * Represents externally managed, lazily available collection of components.

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

@@ -46,7 +46,7 @@ SurfaceHandler& SurfaceHandler::operator=(SurfaceHandler&& other) noexcept {
 #pragma mark - Surface Life-Cycle Management
 
 void SurfaceHandler::setContextContainer(
-    ContextContainer::Shared contextContainer) const noexcept {
+    std::shared_ptr<const ContextContainer> contextContainer) const noexcept {
   parameters_.contextContainer = std::move(contextContainer);
 }
 

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

@@ -80,7 +80,7 @@ class SurfaceHandler {
    * Must be called before surface is started.
    */
   void setContextContainer(
-      ContextContainer::Shared contextContainer) const noexcept;
+      std::shared_ptr<const ContextContainer> contextContainer) const noexcept;
 
   /*
    * Returns a momentum value of the status.
@@ -187,7 +187,7 @@ class SurfaceHandler {
     folly::dynamic props{};
     LayoutConstraints layoutConstraints{};
     LayoutContext layoutContext{};
-    ContextContainer::Shared contextContainer{};
+    std::shared_ptr<const ContextContainer> contextContainer{};
   };
 
   /*

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

@@ -40,7 +40,7 @@ int countAttachments(const AttributedString& attributedString) {
 }
 
 Size measureText(
-    const ContextContainer::Shared& contextContainer,
+    const std::shared_ptr<const ContextContainer>& contextContainer,
     Tag rootTag,
     MapBuffer attributedString,
     MapBuffer paragraphAttributes,
@@ -82,7 +82,7 @@ Size measureText(
 }
 
 TextMeasurement doMeasure(
-    const ContextContainer::Shared& contextContainer,
+    const std::shared_ptr<const ContextContainer>& contextContainer,
     const AttributedString& attributedString,
     const ParagraphAttributes& paragraphAttributes,
     const TextLayoutContext& layoutContext,
@@ -155,8 +155,8 @@ TextMeasurement doMeasure(
 } // namespace
 
 TextLayoutManager::TextLayoutManager(
-    const ContextContainer::Shared& contextContainer)
-    : contextContainer_(contextContainer),
+    const std::shared_ptr<const ContextContainer>& contextContainer)
+    : contextContainer_(std::move(contextContainer)),
       textMeasureCache_(kSimpleThreadSafeCacheSizeCap),
       lineMeasureCache_(kSimpleThreadSafeCacheSizeCap),
       preparedTextCache_(static_cast<size_t>(
@@ -190,7 +190,8 @@ TextMeasurement TextLayoutManager::measure(
   };
 
   auto measurement =
-      ReactNativeFeatureFlags::disableTextLayoutManagerCacheAndroid()
+      (ReactNativeFeatureFlags::disableTextLayoutManagerCacheAndroid() ||
+       ReactNativeFeatureFlags::enablePreparedTextLayout())
       ? measureText()
       : textMeasureCache_.get(
             {.attributedString = attributedString,
@@ -235,7 +236,7 @@ TextMeasurement TextLayoutManager::measureCachedSpannableById(
   // TODO: currently we do not support attachments for cached IDs - should we?
   auto attachments = TextMeasurement::Attachments{};
 
-  return TextMeasurement{size, attachments};
+  return TextMeasurement{.size = size, .attachments = attachments};
 }
 
 LinesMeasurements TextLayoutManager::measureLines(
@@ -310,14 +311,19 @@ TextLayoutManager::PreparedLayout TextLayoutManager::prepareLayout(
               jfloat,
               jfloat)>("prepareTextLayout");
 
-  return preparedTextCache_.get(
+  static auto reusePreparedLayoutWithNewReactTags =
+      jni::findClassStatic("com/facebook/react/fabric/FabricUIManager")
+          ->getMethod<JPreparedLayout::javaobject(
+              JPreparedLayout::javaobject, jintArray)>(
+              "reusePreparedLayoutWithNewReactTags");
+
+  const auto [key, preparedText] = preparedTextCache_.getWithKey(
       {.attributedString = attributedString,
        .paragraphAttributes = paragraphAttributes,
        .layoutConstraints = layoutConstraints},
-      [&] {
+      [&]() {
         const auto& fabricUIManager =
             contextContainer_->at<jni::global_ref<jobject>>("FabricUIManager");
-
         auto attributedStringMB = JReadableMapBuffer::createWithContents(
             toMapBuffer(attributedString));
         auto paragraphAttributesMB = JReadableMapBuffer::createWithContents(
@@ -336,6 +342,39 @@ TextLayoutManager::PreparedLayout TextLayoutManager::prepareLayout(
             minimumSize.height,
             maximumSize.height))};
       });
+
+  // PreparedTextCacheKey allows equality of layouts which are the same
+  // display-wise, but ShadowView fragments (and thus react tags) may have
+  // changed.
+  const auto& fragments = attributedString.getFragments();
+  const auto& cacheKeyFragments = key->attributedString.getFragments();
+  bool needsNewReactTags = [&] {
+    for (size_t i = 0; i < fragments.size(); i++) {
+      if (fragments[i].parentShadowView.tag !=
+          cacheKeyFragments[i].parentShadowView.tag) {
+        return true;
+      }
+    }
+    return false;
+  }();
+
+  if (needsNewReactTags) {
+    std::vector<int> reactTags(fragments.size());
+    for (size_t i = 0; i < reactTags.size(); i++) {
+      reactTags[i] = fragments[i].parentShadowView.tag;
+    }
+
+    auto javaReactTags = jni::JArrayInt::newArray(fragments.size());
+    javaReactTags->setRegion(
+        0, static_cast<jsize>(reactTags.size()), reactTags.data());
+
+    const auto& fabricUIManager =
+        contextContainer_->at<jni::global_ref<jobject>>("FabricUIManager");
+    return PreparedLayout{jni::make_global(reusePreparedLayoutWithNewReactTags(
+        fabricUIManager, preparedText->get(), javaReactTags.get()))};
+  } else {
+    return PreparedLayout{*preparedText};
+  }
 }
 
 TextMeasurement TextLayoutManager::measurePreparedLayout(

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

@@ -31,7 +31,8 @@ class TextLayoutManager {
  public:
   using PreparedLayout = SafeReleaseJniRef<jni::global_ref<JPreparedLayout>>;
 
-  TextLayoutManager(const ContextContainer::Shared& contextContainer);
+  TextLayoutManager(
+      const std::shared_ptr<const ContextContainer>& contextContainer);
 
   /*
    * Not copyable.

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

@@ -10,7 +10,7 @@
 namespace facebook::react {
 
 TextLayoutManager::TextLayoutManager(
-    const ContextContainer::Shared& /*contextContainer*/)
+    const std::shared_ptr<const ContextContainer>& /*contextContainer*/)
     : textMeasureCache_(kSimpleThreadSafeCacheSizeCap) {}
 
 TextMeasurement TextLayoutManager::measure(

package/ReactCommon/react/renderer/textlayoutmanager/platform/cxx/react/renderer/textlayoutmanager/TextLayoutManager.h

@@ -25,7 +25,8 @@ class TextLayoutManager;
  */
 class TextLayoutManager {
  public:
-  TextLayoutManager(const ContextContainer::Shared& contextContainer);
+  explicit TextLayoutManager(
+      const std::shared_ptr<const ContextContainer>& contextContainer);
   virtual ~TextLayoutManager() = default;
 
   /*

package/ReactCommon/react/renderer/textlayoutmanager/platform/ios/react/renderer/textlayoutmanager/RCTTextLayoutManager.mm

@@ -187,34 +187,36 @@ static NSLineBreakMode RCTNSLineBreakModeFromEllipsizeMode(EllipsizeMode ellipsi
   std::vector<LineMeasurement> paragraphLines{};
   auto blockParagraphLines = &paragraphLines;
 
-  [layoutManager enumerateLineFragmentsForGlyphRange:glyphRange
-                                          usingBlock:^(
-                                              CGRect overallRect,
-                                              CGRect usedRect,
-                                              NSTextContainer *_Nonnull usedTextContainer,
-                                              NSRange lineGlyphRange,
-                                              BOOL *_Nonnull stop) {
-                                            NSRange range = [layoutManager characterRangeForGlyphRange:lineGlyphRange
-                                                                                      actualGlyphRange:nil];
-                                            NSString *renderedString = [textStorage.string substringWithRange:range];
-                                            UIFont *font = [[textStorage attributedSubstringFromRange:range]
-                                                     attribute:NSFontAttributeName
-                                                       atIndex:0
-                                                effectiveRange:nil];
-                                            auto rect = facebook::react::Rect{
-                                                facebook::react::Point{usedRect.origin.x, usedRect.origin.y},
-                                                facebook::react::Size{usedRect.size.width, usedRect.size.height}};
-
-                                            CGFloat baseline = [layoutManager locationForGlyphAtIndex:range.location].y;
-                                            auto line = LineMeasurement{
-                                                std::string([renderedString UTF8String]),
-                                                rect,
-                                                overallRect.size.height - baseline,
-                                                font.capHeight,
-                                                baseline,
-                                                font.xHeight};
-                                            blockParagraphLines->push_back(line);
-                                          }];
+  [layoutManager
+      enumerateLineFragmentsForGlyphRange:glyphRange
+                               usingBlock:^(
+                                   CGRect overallRect,
+                                   CGRect usedRect,
+                                   NSTextContainer *_Nonnull usedTextContainer,
+                                   NSRange lineGlyphRange,
+                                   BOOL *_Nonnull stop) {
+                                 NSRange range = [layoutManager characterRangeForGlyphRange:lineGlyphRange
+                                                                           actualGlyphRange:nil];
+                                 NSString *renderedString = [textStorage.string substringWithRange:range];
+                                 UIFont *font =
+                                     [[textStorage attributedSubstringFromRange:range] attribute:NSFontAttributeName
+                                                                                         atIndex:0
+                                                                                  effectiveRange:nil];
+                                 auto rect = facebook::react::Rect{
+                                     .origin = facebook::react::Point{.x = usedRect.origin.x, .y = usedRect.origin.y},
+                                     .size = facebook::react::Size{
+                                         .width = usedRect.size.width, .height = usedRect.size.height}};
+
+                                 CGFloat baseline = [layoutManager locationForGlyphAtIndex:range.location].y;
+                                 auto line = LineMeasurement{
+                                     std::string([renderedString UTF8String]),
+                                     rect,
+                                     overallRect.size.height - baseline,
+                                     font.capHeight,
+                                     baseline,
+                                     font.xHeight};
+                                 blockParagraphLines->push_back(line);
+                               }];
   return paragraphLines;
 }
 
@@ -412,19 +414,24 @@ static NSLineBreakMode RCTNSLineBreakModeFromEllipsizeMode(EllipsizeMode ellipsi
                   CGRect glyphRect = [layoutManager boundingRectForGlyphRange:range inTextContainer:textContainer];
 
                   CGRect frame;
-                  CGFloat baseline = [layoutManager locationForGlyphAtIndex:range.location].y;
-
-                  frame = {{glyphRect.origin.x, glyphRect.origin.y + baseline - attachmentSize.height}, attachmentSize};
+                  UIFont *font = [[textStorage attributedSubstringFromRange:range] attribute:NSFontAttributeName
+                                                                                     atIndex:0
+                                                                              effectiveRange:nil];
+                  frame = {
+                      .origin =
+                          {glyphRect.origin.x,
+                           glyphRect.origin.y + glyphRect.size.height - attachmentSize.height + font.descender},
+                      .size = attachmentSize};
 
                   auto rect = facebook::react::Rect{
-                      facebook::react::Point{frame.origin.x, frame.origin.y},
-                      facebook::react::Size{frame.size.width, frame.size.height}};
+                      .origin = facebook::react::Point{.x = frame.origin.x, .y = frame.origin.y},
+                      .size = facebook::react::Size{.width = frame.size.width, .height = frame.size.height}};
 
                   attachments.push_back(TextMeasurement::Attachment{.frame = rect, .isClipped = false});
                 }
               }];
 
-  return TextMeasurement{{size.width, size.height}, attachments};
+  return TextMeasurement{.size = {.width = size.width, .height = size.height}, .attachments = attachments};
 }
 
 @end

package/ReactCommon/react/renderer/textlayoutmanager/platform/ios/react/renderer/textlayoutmanager/TextLayoutManager.h

@@ -23,7 +23,8 @@ namespace facebook::react {
  */
 class TextLayoutManager {
  public:
-  TextLayoutManager(const ContextContainer::Shared& contextContainer);
+  TextLayoutManager(
+      const std::shared_ptr<const ContextContainer>& contextContainer);
 
   /*
    * Not copyable.

package/ReactCommon/react/renderer/textlayoutmanager/platform/ios/react/renderer/textlayoutmanager/TextLayoutManager.mm

@@ -14,7 +14,7 @@
 
 namespace facebook::react {
 
-TextLayoutManager::TextLayoutManager(const ContextContainer::Shared &contextContainer)
+TextLayoutManager::TextLayoutManager(const std::shared_ptr<const ContextContainer> & /*contextContainer*/)
 {
   nativeTextLayoutManager_ = wrapManagedObject([RCTTextLayoutManager new]);
 }
@@ -39,23 +39,27 @@ TextMeasurement TextLayoutManager::measure(
     case AttributedStringBox::Mode::Value: {
       auto attributedString = ensurePlaceholderIfEmpty_DO_NOT_USE(attributedStringBox.getValue());
 
-      measurement = textMeasureCache_.get({attributedString, paragraphAttributes, layoutConstraints}, [&]() {
-        auto telemetry = TransactionTelemetry::threadLocalTelemetry();
-        if (telemetry) {
-          telemetry->willMeasureText();
-        }
-
-        auto measurement = [textLayoutManager measureAttributedString:attributedString
-                                                  paragraphAttributes:paragraphAttributes
-                                                        layoutContext:layoutContext
-                                                    layoutConstraints:layoutConstraints];
-
-        if (telemetry) {
-          telemetry->didMeasureText();
-        }
-
-        return measurement;
-      });
+      measurement = textMeasureCache_.get(
+          {.attributedString = attributedString,
+           .paragraphAttributes = paragraphAttributes,
+           .layoutConstraints = layoutConstraints},
+          [&]() {
+            auto telemetry = TransactionTelemetry::threadLocalTelemetry();
+            if (telemetry) {
+              telemetry->willMeasureText();
+            }
+
+            auto measurement = [textLayoutManager measureAttributedString:attributedString
+                                                      paragraphAttributes:paragraphAttributes
+                                                            layoutContext:layoutContext
+                                                        layoutConstraints:layoutConstraints];
+
+            if (telemetry) {
+              telemetry->didMeasureText();
+            }
+
+            return measurement;
+          });
       break;
     }
 
@@ -96,12 +100,13 @@ LinesMeasurements TextLayoutManager::measureLines(
 
   RCTTextLayoutManager *textLayoutManager = (RCTTextLayoutManager *)unwrapManagedObject(nativeTextLayoutManager_);
 
-  auto measurement = lineMeasureCache_.get({attributedString, paragraphAttributes, size}, [&]() {
-    auto measurement = [textLayoutManager getLinesForAttributedString:attributedString
-                                                  paragraphAttributes:paragraphAttributes
-                                                                 size:{size.width, size.height}];
-    return measurement;
-  });
+  auto measurement = lineMeasureCache_.get(
+      {.attributedString = attributedString, .paragraphAttributes = paragraphAttributes, .size = size}, [&]() {
+        auto measurement = [textLayoutManager getLinesForAttributedString:attributedString
+                                                      paragraphAttributes:paragraphAttributes
+                                                                     size:{size.width, size.height}];
+        return measurement;
+      });
 
   return measurement;
 }

package/ReactCommon/react/renderer/uimanager/PointerHoverTracker.cpp

@@ -93,7 +93,7 @@ std::tuple<EventPath, EventPath> PointerHoverTracker::diffEventPath(
   for (auto nodeIt = myIt; nodeIt != myEventPath.rend(); nodeIt++) {
     const auto& latestNode = getLatestNode(*nodeIt, uiManager);
     if (latestNode != nullptr) {
-      removed.push_back(*latestNode);
+      removed.emplace_back(*latestNode);
     }
   }
 
@@ -101,7 +101,7 @@ std::tuple<EventPath, EventPath> PointerHoverTracker::diffEventPath(
   for (auto nodeIt = otherIt; nodeIt != otherEventPath.rend(); nodeIt++) {
     const auto& latestNode = other.getLatestNode(*nodeIt, uiManager);
     if (latestNode != nullptr) {
-      added.push_back(*latestNode);
+      added.emplace_back(*latestNode);
     }
   }
 

package/ReactCommon/react/renderer/uimanager/UIManager.cpp

@@ -44,7 +44,7 @@ ShadowNodeListWrapper::~ShadowNodeListWrapper() = default;
 
 UIManager::UIManager(
     const RuntimeExecutor& runtimeExecutor,
-    ContextContainer::Shared contextContainer)
+    std::shared_ptr<const ContextContainer> contextContainer)
     : runtimeExecutor_(runtimeExecutor),
       shadowTreeRegistry_(),
       contextContainer_(std::move(contextContainer)),
@@ -516,7 +516,7 @@ std::shared_ptr<const ShadowNode> UIManager::findShadowNodeByTag_DEPRECATED(
   auto shadowNode = std::shared_ptr<const ShadowNode>{};
 
   shadowTreeRegistry_.enumerate([&](const ShadowTree& shadowTree, bool& stop) {
-    const RootShadowNode* rootShadowNode;
+    const RootShadowNode* rootShadowNode = nullptr;
     // The public interface of `ShadowTree` discourages accessing a stored
     // pointer to a root node because of the possible data race.
     // To work around this, we ask for a commit and immediately cancel it

package/ReactCommon/react/renderer/uimanager/UIManager.h

@@ -41,7 +41,7 @@ class UIManager final : public ShadowTreeDelegate {
  public:
   UIManager(
       const RuntimeExecutor& runtimeExecutor,
-      ContextContainer::Shared contextContainer);
+      std::shared_ptr<const ContextContainer> contextContainer);
 
   ~UIManager() override;
 
@@ -207,8 +207,7 @@ class UIManager final : public ShadowTreeDelegate {
 
   void reportMount(SurfaceId surfaceId) const;
 
-  void updateShadowTree(
-      const std::unordered_map<Tag, folly::dynamic>& tagToProps);
+  void updateShadowTree(std::unordered_map<Tag, folly::dynamic>&& tagToProps);
 
 #pragma mark - Add & Remove event listener
 
@@ -247,7 +246,7 @@ class UIManager final : public ShadowTreeDelegate {
 
   const RuntimeExecutor runtimeExecutor_{};
   ShadowTreeRegistry shadowTreeRegistry_{};
-  ContextContainer::Shared contextContainer_;
+  std::shared_ptr<const ContextContainer> contextContainer_;
 
   mutable std::shared_mutex commitHookMutex_;
   mutable std::vector<UIManagerCommitHook*> commitHooks_;

package/ReactCommon/react/renderer/uimanager/UIManagerCommitHook.h

@@ -57,4 +57,15 @@ class UIManagerCommitHook {
   virtual ~UIManagerCommitHook() noexcept = default;
 };
 
+constexpr std::string_view UIManagerCommitHookManagerKey =
+    "UIManagerCommitHookManager";
+
+class UIManagerCommitHookManager {
+ public:
+  virtual ~UIManagerCommitHookManager() = default;
+
+  virtual void registerCommitHook(UIManagerCommitHook& commitHook) = 0;
+  virtual void unregisterCommitHook(UIManagerCommitHook& commitHook) = 0;
+};
+
 } // namespace facebook::react

package/ReactCommon/react/renderer/uimanager/UIManagerUpdateShadowTree.cpp

@@ -86,10 +86,15 @@ void addAncestorsToUpdateList(
  * license).
  */
 void UIManager::updateShadowTree(
-    const std::unordered_map<Tag, folly::dynamic>& tagToProps) {
+    std::unordered_map<Tag, folly::dynamic>&& tagToProps) {
   const auto& contextContainer = *contextContainer_;
 
-  std::unordered_map<Tag, folly::dynamic> remainingTagToProps = tagToProps;
+  auto remainingTagToProps = std::move(tagToProps);
+
+  if (delegate_ != nullptr) {
+    delegate_->uiManagerDidUpdateShadowTree(remainingTagToProps);
+  }
+
   getShadowTreeRegistry().enumerate([&](const ShadowTree& shadowTree,
                                         bool& stop) {
     if (remainingTagToProps.empty()) {
@@ -219,10 +224,6 @@ void UIManager::updateShadowTree(
       LOG(ERROR) << "Root ShadowNode has not been cloned";
     }
   });
-
-  if (delegate_ != nullptr) {
-    delegate_->uiManagerDidUpdateShadowTree(tagToProps);
-  }
 }
 
 } // namespace facebook::react

package/ReactCommon/react/renderer/uimanager/consistency/tests/LazyShadowTreeRevisionConsistencyManagerTest.cpp

@@ -22,11 +22,11 @@ class FakeShadowTreeDelegate : public ShadowTreeDelegate {
       const RootShadowNode::Unshared& newRootShadowNode,
       const ShadowTree::CommitOptions& /*commitOptions*/) const override {
     return newRootShadowNode;
-  };
+  }
 
   void shadowTreeDidFinishTransaction(
       std::shared_ptr<const MountingCoordinator> mountingCoordinator,
-      bool mountSynchronously) const override {};
+      bool /*mountSynchronously*/) const override {}
 };
 
 class LazyShadowTreeRevisionConsistencyManagerTest : public ::testing::Test {

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

@@ -112,7 +112,8 @@ inline static ShadowNode::UnsharedListOfWeak weakShadowNodeListFromValue(
     jsi::Runtime& runtime,
     const jsi::Value& value) {
   auto shadowNodeList = shadowNodeListFromValue(runtime, value);
-  auto weakShadowNodeList = std::make_shared<ShadowNode::ListOfWeak>();
+  auto weakShadowNodeList =
+      std::make_shared<std::vector<std::weak_ptr<const ShadowNode>>>();
   for (const auto& shadowNode : *shadowNodeList) {
     weakShadowNodeList->push_back(shadowNode);
   }