react-native-tvos 0.75.3-0 → 0.76.0-0

package/ReactCommon/react/renderer/graphics/platform/ios/react/renderer/graphics/HostPlatformColor.h

@@ -29,6 +29,9 @@ struct Color {
   std::shared_ptr<void> getUIColor() const {
     return uiColor_;
   }
+
+  float getChannel(int channelId) const;
+
   ColorComponents getColorComponents() const {
     float ratio = 255;
     int32_t primitiveColor = getColor();
@@ -59,6 +62,18 @@ namespace HostPlatformColor {
 NO_DESTROY static const facebook::react::Color UndefinedColor = Color(nullptr);
 } // namespace HostPlatformColor
 
+inline Color
+hostPlatformColorFromRGBA(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
+  float ratio = 255;
+  const auto colorComponents = ColorComponents{
+      .red = r / ratio,
+      .green = g / ratio,
+      .blue = b / ratio,
+      .alpha = a / ratio,
+  };
+  return Color(colorComponents);
+}
+
 inline Color hostPlatformColorFromComponents(ColorComponents components) {
   return Color(components);
 }
@@ -67,6 +82,22 @@ inline ColorComponents colorComponentsFromHostPlatformColor(Color color) {
   return color.getColorComponents();
 }
 
+inline float alphaFromHostPlatformColor(Color color) {
+  return color.getChannel(3) * 255;
+}
+
+inline float redFromHostPlatformColor(Color color) {
+  return color.getChannel(0) * 255;
+}
+
+inline float greenFromHostPlatformColor(Color color) {
+  return color.getChannel(1) * 255;
+}
+
+inline float blueFromHostPlatformColor(Color color) {
+  return color.getChannel(2) * 255;
+}
+
 } // namespace facebook::react
 
 template <>

package/ReactCommon/react/renderer/graphics/platform/ios/react/renderer/graphics/HostPlatformColor.mm

@@ -133,6 +133,15 @@ int32_t Color::getColor() const
 {
   return ColorFromUIColor(uiColor_);
 }
+
+float Color::getChannel(int channelId) const
+{
+  CGFloat rgba[4];
+  UIColor *color = (__bridge UIColor *)getUIColor().get();
+  [color getRed:&rgba[0] green:&rgba[1] blue:&rgba[2] alpha:&rgba[3]];
+  return static_cast<float>(rgba[channelId]);
+}
+
 } // namespace facebook::react
 
 NS_ASSUME_NONNULL_END

package/ReactCommon/react/renderer/graphics/tests/ColorTest.cpp

@@ -0,0 +1,38 @@
+/*
+ * 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 <react/renderer/graphics/Color.h>
+
+#include <gtest/gtest.h>
+
+TEST(ColorTest, testColorConversion) {
+  using namespace facebook::react;
+  {
+    auto color = colorFromRGBA(255, 0, 15, 17);
+
+    EXPECT_EQ(alphaFromColor(color), 17);
+    EXPECT_EQ(redFromColor(color), 255);
+    EXPECT_EQ(greenFromColor(color), 0);
+    EXPECT_EQ(blueFromColor(color), 15);
+  }
+
+  {
+    auto color = colorFromComponents(
+        {.red = 0.1f, .green = 0.2f, .blue = 0, .alpha = 0.3f});
+
+    EXPECT_EQ(alphaFromColor(color), std::round(255 * 0.3f));
+    EXPECT_EQ(redFromColor(color), std::round(255 * 0.1f));
+    EXPECT_EQ(greenFromColor(color), 255 * 0.2f);
+    EXPECT_EQ(blueFromColor(color), 0.f);
+
+    auto colorComponents = colorComponentsFromColor(color);
+    EXPECT_EQ(std::round(colorComponents.alpha * 10) / 10.f, 0.3f);
+    EXPECT_EQ(std::round(colorComponents.red * 10) / 10.f, 0.1f);
+    EXPECT_EQ(std::round(colorComponents.green * 10) / 10.f, 0.2f);
+    EXPECT_EQ(std::round(colorComponents.blue * 10) / 10.f, 0);
+  }
+}

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

@@ -19,7 +19,7 @@ file(GLOB react_render_imagemanager_SRC CONFIGURE_DEPENDS
         platform/cxx/react/renderer/imagemanager/*.cpp)
 
 add_library(react_render_imagemanager
-        SHARED
+        OBJECT
         ${react_render_imagemanager_SRC})
 
 target_include_directories(react_render_imagemanager

package/ReactCommon/react/renderer/imagemanager/platform/ios/react/renderer/imagemanager/RCTImagePrimitivesConversions.h

@@ -109,6 +109,13 @@ inline static NSURLRequest *NSURLRequestFromImageSource(const facebook::react::I
   request.cachePolicy = ...;
   request.allHTTPHeaderFields = ...;
   */
+  for (const auto &header : imageSource.headers) {
+    NSString *key = [NSString stringWithUTF8String:header.first.c_str()];
+    NSString *value = [NSString stringWithUTF8String:header.second.c_str()];
+    if (key != NULL && value != NULL) {
+      [request setValue:value forHTTPHeaderField:key];
+    }
+  }
 
   return [request copy];
 }

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

@@ -24,6 +24,7 @@ class ImageSource {
   std::string bundle{};
   Float scale{3};
   Size size{0};
+  std::vector<std::pair<std::string, std::string>> headers{};
 
   bool operator==(const ImageSource& rhs) const {
     return std::tie(this->type, this->uri) == std::tie(rhs.type, rhs.uri);

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

@@ -15,7 +15,7 @@ add_compile_options(
         -DLOG_TAG=\"Fabric\")
 
 file(GLOB react_render_mapbuffer_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(react_render_mapbuffer SHARED ${react_render_mapbuffer_SRC})
+add_library(react_render_mapbuffer OBJECT ${react_render_mapbuffer_SRC})
 
 target_include_directories(react_render_mapbuffer PUBLIC ${REACT_COMMON_DIR})
 target_link_libraries(react_render_mapbuffer glog glog_init react_debug)

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

@@ -17,7 +17,7 @@ add_compile_options(
 file(GLOB react_render_mounting_SRC CONFIGURE_DEPENDS 
         *.cpp
         stubs/*.cpp)
-add_library(react_render_mounting STATIC ${react_render_mounting_SRC})
+add_library(react_render_mounting OBJECT ${react_render_mounting_SRC})
 
 target_include_directories(react_render_mounting PRIVATE .)
 target_include_directories(react_render_mounting PUBLIC ${REACT_COMMON_DIR})

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

@@ -232,24 +232,16 @@ static void sliceChildShadowNodeViewPairsRecursively(
     // This might not be a FormsView, or a FormsStackingContext. We let the
     // differ handle removal of flattened views from the Mounting layer and
     // shuffling their children around.
-    bool isConcreteView = false;
-    bool areChildrenFlattened = false;
-    if (ReactNativeFeatureFlags::allowCollapsableChildren()) {
-      bool childrenFormStackingContexts = shadowNode.getTraits().check(
-          ShadowNodeTraits::Trait::ChildrenFormStackingContext);
-      isConcreteView = childShadowNode.getTraits().check(
-                           ShadowNodeTraits::Trait::FormsView) ||
-          childrenFormStackingContexts;
-      areChildrenFlattened =
-          !childShadowNode.getTraits().check(
-              ShadowNodeTraits::Trait::FormsStackingContext) &&
-          !childrenFormStackingContexts;
-    } else {
-      isConcreteView =
-          childShadowNode.getTraits().check(ShadowNodeTraits::Trait::FormsView);
-      areChildrenFlattened = !childShadowNode.getTraits().check(
-          ShadowNodeTraits::Trait::FormsStackingContext);
-    }
+    bool childrenFormStackingContexts = shadowNode.getTraits().check(
+        ShadowNodeTraits::Trait::ChildrenFormStackingContext);
+    bool isConcreteView =
+        childShadowNode.getTraits().check(ShadowNodeTraits::Trait::FormsView) ||
+        childrenFormStackingContexts;
+    bool areChildrenFlattened =
+        !childShadowNode.getTraits().check(
+            ShadowNodeTraits::Trait::FormsStackingContext) &&
+        !childrenFormStackingContexts;
+
     Point storedOrigin = {};
     if (areChildrenFlattened) {
       storedOrigin = origin;
@@ -362,8 +354,7 @@ static void calculateShadowViewMutations(
     ShadowViewMutation::List& mutations,
     const ShadowView& parentShadowView,
     ShadowViewNodePair::NonOwningList&& oldChildPairs,
-    ShadowViewNodePair::NonOwningList&& newChildPairs,
-    bool isRecursionRedundant = false);
+    ShadowViewNodePair::NonOwningList&& newChildPairs);
 
 struct OrderedMutationInstructionContainer {
   ShadowViewMutation::List createMutations{};
@@ -1052,8 +1043,7 @@ static void calculateShadowViewMutations(
     ShadowViewMutation::List& mutations,
     const ShadowView& parentShadowView,
     ShadowViewNodePair::NonOwningList&& oldChildPairs,
-    ShadowViewNodePair::NonOwningList&& newChildPairs,
-    bool isRecursionRedundant) {
+    ShadowViewNodePair::NonOwningList&& newChildPairs) {
   if (oldChildPairs.empty() && newChildPairs.empty()) {
     return;
   }
@@ -1171,39 +1161,13 @@ static void calculateShadowViewMutations(
         continue;
       }
 
-      // If we take this path, technically the operations and recursion below
-      // are redundant. However, some parts of the Fabric ecosystem (namely, as
-      // of writing this, LayoutAnimations) rely heavily on getting /explicit/
-      // Remove/Delete instructions for every single node in the tree. Thus, we
-      // generate the "RemoveDeleteTree" instruction as well as all of the
-      // individual Remove/Delete operations below, but we mark those as
-      // redundant. The platform layer can then discard the unnecessary
-      // instructions. RemoveDeleteTreeMutation is a significant performance
-      // improvement but could be improved significantly by eliminating the need
-      // for any of the redundant instructions in the future.
-      if (ShadowViewMutation::PlatformSupportsRemoveDeleteTreeInstruction &&
-          !isRecursionRedundant) {
-        mutationContainer.removeMutations.push_back(
-            ShadowViewMutation::RemoveDeleteTreeMutation(
-                parentShadowView,
-                oldChildPair.shadowView,
-                static_cast<int>(oldChildPair.mountIndex)));
-      }
-
       mutationContainer.deleteMutations.push_back(
-          ShadowViewMutation::DeleteMutation(
-              oldChildPair.shadowView,
-              isRecursionRedundant ||
-                  ShadowViewMutation::
-                      PlatformSupportsRemoveDeleteTreeInstruction));
+          ShadowViewMutation::DeleteMutation(oldChildPair.shadowView));
       mutationContainer.removeMutations.push_back(
           ShadowViewMutation::RemoveMutation(
               parentShadowView,
               oldChildPair.shadowView,
-              static_cast<int>(oldChildPair.mountIndex),
-              isRecursionRedundant ||
-                  ShadowViewMutation::
-                      PlatformSupportsRemoveDeleteTreeInstruction));
+              static_cast<int>(oldChildPair.mountIndex)));
 
       // We also have to call the algorithm recursively to clean up the entire
       // subtree starting from the removed view.
@@ -1214,8 +1178,7 @@ static void calculateShadowViewMutations(
           oldChildPair.shadowView,
           sliceChildShadowNodeViewPairsFromViewNodePair(
               oldChildPair, innerScope),
-          {},
-          ShadowViewMutation::PlatformSupportsRemoveDeleteTreeInstruction);
+          {});
     }
   } else if (index == oldChildPairs.size()) {
     // If we don't have any more existing children we can choose a fast path

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

@@ -78,8 +78,8 @@ void MountingCoordinator::resetLatestRevision() const {
   lastRevision_.reset();
 }
 
-std::optional<MountingTransaction> MountingCoordinator::pullTransaction()
-    const {
+std::optional<MountingTransaction> MountingCoordinator::pullTransaction(
+    bool willPerformAsynchronously) const {
   SystraceSection section("MountingCoordinator::pullTransaction");
 
   std::scoped_lock lock(mutex_);
@@ -184,13 +184,20 @@ std::optional<MountingTransaction> MountingCoordinator::pullTransaction()
   if (lastRevision_.has_value()) {
     baseRevision_ = std::move(*lastRevision_);
     lastRevision_.reset();
+
+    hasPendingTransactionsOverride_ = willPerformAsynchronously;
   }
   return transaction;
 }
 
 bool MountingCoordinator::hasPendingTransactions() const {
   std::scoped_lock lock(mutex_);
-  return lastRevision_.has_value();
+  return lastRevision_.has_value() || hasPendingTransactionsOverride_;
+}
+
+void MountingCoordinator::didPerformAsyncTransactions() const {
+  std::scoped_lock lock(mutex_);
+  hasPendingTransactionsOverride_ = false;
 }
 
 const TelemetryController& MountingCoordinator::getTelemetryController() const {

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

@@ -55,8 +55,28 @@ class MountingCoordinator final {
    * The method is thread-safe and can be called from any thread.
    * However, a consumer should always call it on the same thread (e.g. on the
    * main thread) or ensure sequentiality of mount transactions separately.
+   *
+   * `willPerformAsynchronously` indicates if this transaction is going to be
+   * applied asynchronously after this call. The preferred model is to apply
+   * them synchronously but Android doesn't follow it yet (it calls
+   * `pullTransaction` from the JS thread and schedules the updates
+   * asynchronously on the UI thread).
+   * If this is `true`, then `hasPendingTransactions` will continue returning
+   * `true` until `didPerformAsyncTransactions` is called.
    */
-  std::optional<MountingTransaction> pullTransaction() const;
+  std::optional<MountingTransaction> pullTransaction(
+      // TODO: Clean up this parameter when Android migrates to a pull model.
+      bool willPerformAsynchronously = false) const;
+
+  /*
+   * This method is used to notify that transactions that weren't performed
+   * synchronously when calling `pullTransaction` were effectively applied
+   * on the UI thread.
+   *
+   * NOTE: This is only necessary on Android and can be removed when it's
+   * migrated to a pull model (as the rest of platforms).
+   */
+  void didPerformAsyncTransactions() const;
 
   /*
    * Indicates if there are transactions waiting to be consumed and mounted on
@@ -116,6 +136,7 @@ class MountingCoordinator final {
   // `mountingOverrideDelegate_`.
   mutable std::mutex mutex_;
   mutable ShadowTreeRevision baseRevision_;
+  mutable bool hasPendingTransactionsOverride_{false};
   mutable std::optional<ShadowTreeRevision> lastRevision_{};
   mutable MountingTransaction::Number number_{0};
   mutable std::condition_variable signal_;

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

@@ -11,12 +11,6 @@
 
 namespace facebook::react {
 
-/**
- * Initialize static feature flags for this module.
- * These flags should be treated as temporary.
- */
-bool ShadowViewMutation::PlatformSupportsRemoveDeleteTreeInstruction = false;
-
 ShadowViewMutation ShadowViewMutation::CreateMutation(ShadowView shadowView) {
   return {
       /* .type = */ Create,
@@ -27,16 +21,13 @@ ShadowViewMutation ShadowViewMutation::CreateMutation(ShadowView shadowView) {
   };
 }
 
-ShadowViewMutation ShadowViewMutation::DeleteMutation(
-    ShadowView shadowView,
-    bool isRedundantOperation) {
+ShadowViewMutation ShadowViewMutation::DeleteMutation(ShadowView shadowView) {
   return {
       /* .type = */ Delete,
       /* .parentShadowView = */ {},
       /* .oldChildShadowView = */ std::move(shadowView),
       /* .newChildShadowView = */ {},
       /* .index = */ -1,
-      /* .isRedundantOperation */ isRedundantOperation,
   };
 }
 
@@ -54,26 +45,11 @@ ShadowViewMutation ShadowViewMutation::InsertMutation(
 }
 
 ShadowViewMutation ShadowViewMutation::RemoveMutation(
-    ShadowView parentShadowView,
-    ShadowView childShadowView,
-    int index,
-    bool isRedundantOperation) {
-  return {
-      /* .type = */ Remove,
-      /* .parentShadowView = */ std::move(parentShadowView),
-      /* .oldChildShadowView = */ std::move(childShadowView),
-      /* .newChildShadowView = */ {},
-      /* .index = */ index,
-      /* .isRedundantOperation */ isRedundantOperation,
-  };
-}
-
-ShadowViewMutation ShadowViewMutation::RemoveDeleteTreeMutation(
     ShadowView parentShadowView,
     ShadowView childShadowView,
     int index) {
   return {
-      /* .type = */ RemoveDeleteTree,
+      /* .type = */ Remove,
       /* .parentShadowView = */ std::move(parentShadowView),
       /* .oldChildShadowView = */ std::move(childShadowView),
       /* .newChildShadowView = */ {},
@@ -115,14 +91,12 @@ ShadowViewMutation::ShadowViewMutation(
     ShadowView parentShadowView,
     ShadowView oldChildShadowView,
     ShadowView newChildShadowView,
-    int index,
-    bool isRedundantOperation)
+    int index)
     : type(type),
       parentShadowView(std::move(parentShadowView)),
       oldChildShadowView(std::move(oldChildShadowView)),
       newChildShadowView(std::move(newChildShadowView)),
-      index(index),
-      isRedundantOperation(isRedundantOperation) {}
+      index(index) {}
 
 #if RN_DEBUG_STRING_CONVERTIBLE
 
@@ -138,8 +112,6 @@ std::string getDebugName(const ShadowViewMutation& mutation) {
       return "Remove";
     case ShadowViewMutation::Update:
       return "Update";
-    case ShadowViewMutation::RemoveDeleteTree:
-      return "RemoveDeleteTree";
   }
 }
 

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

@@ -24,10 +24,6 @@ struct ShadowViewMutation final {
 
   ShadowViewMutation() = delete;
 
-#pragma mark - Platform feature flags
-
-  static bool PlatformSupportsRemoveDeleteTreeInstruction;
-
 #pragma mark - Designated Initializers
 
   /*
@@ -38,9 +34,7 @@ struct ShadowViewMutation final {
   /*
    * Creates and returns an `Delete` mutation.
    */
-  static ShadowViewMutation DeleteMutation(
-      ShadowView shadowView,
-      bool isRedundantOperation = false);
+  static ShadowViewMutation DeleteMutation(ShadowView shadowView);
 
   /*
    * Creates and returns an `Insert` mutation.
@@ -54,18 +48,6 @@ struct ShadowViewMutation final {
    * Creates and returns a `Remove` mutation.
    */
   static ShadowViewMutation RemoveMutation(
-      ShadowView parentShadowView,
-      ShadowView childShadowView,
-      int index,
-      bool isRedundantOperation = false);
-
-  /*
-   * Creates and returns a `RemoveDelete` mutation.
-   * This is a signal to (for supported platforms)
-   * remove and delete an entire subtree with a single
-   * instruction.
-   */
-  static ShadowViewMutation RemoveDeleteTreeMutation(
       ShadowView parentShadowView,
       ShadowView childShadowView,
       int index);
@@ -86,7 +68,6 @@ struct ShadowViewMutation final {
     Insert = 4,
     Remove = 8,
     Update = 16,
-    RemoveDeleteTree = 32
   };
 
 #pragma mark - Fields
@@ -97,12 +78,6 @@ struct ShadowViewMutation final {
   ShadowView newChildShadowView = {};
   int index = -1;
 
-  // RemoveDeleteTree causes many Remove/Delete operations to be redundant.
-  // However, we must internally produce all of them for any consumers that
-  // rely on explicit instructions to remove/delete every node in the tree.
-  // Notably (as of the time of writing this) LayoutAnimations.
-  bool isRedundantOperation = false;
-
   // Some platforms can have the notion of virtual views - views that are in the
   // ShadowTree hierarchy but never are on the platform. Generally this is used
   // so notify the platform that a view exists so that we can keep EventEmitters
@@ -116,8 +91,7 @@ struct ShadowViewMutation final {
       ShadowView parentShadowView,
       ShadowView oldChildShadowView,
       ShadowView newChildShadowView,
-      int index,
-      bool isRedundantOperation = false);
+      int index);
 };
 
 using ShadowViewMutationList = std::vector<ShadowViewMutation>;

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

@@ -205,11 +205,6 @@ void StubViewTree::mutate(const ShadowViewMutationList& mutations) {
         break;
       }
 
-      case ShadowViewMutation::RemoveDeleteTree: {
-        // TODO: do something here
-        break;
-      }
-
       case ShadowViewMutation::Update: {
         STUB_VIEW_LOG({
           LOG(ERROR) << "StubView: Update [" << mutation.newChildShadowView.tag

package/ReactCommon/react/renderer/observers/events/CMakeLists.txt

@@ -15,11 +15,14 @@ add_compile_options(
         -DLOG_TAG=\"Fabric\")
 
 file(GLOB react_render_observers_events_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(react_render_observers_events SHARED ${react_render_observers_events_SRC})
+add_library(react_render_observers_events OBJECT ${react_render_observers_events_SRC})
 
 target_include_directories(react_render_observers_events PUBLIC ${REACT_COMMON_DIR})
 target_link_libraries(react_render_observers_events
         react_performance_timeline
+        react_timing
         react_render_core
+        react_render_runtimescheduler
+        react_featureflags
         react_render_uimanager
         react_utils)

package/ReactCommon/react/renderer/observers/events/EventPerformanceLogger.cpp

@@ -7,6 +7,8 @@
 
 #include "EventPerformanceLogger.h"
 
+#include <react/featureflags/ReactNativeFeatureFlags.h>
+#include <react/timing/primitives.h>
 #include <react/utils/CoreFeatures.h>
 #include <unordered_map>
 
@@ -14,6 +16,21 @@ namespace facebook::react {
 
 namespace {
 
+bool isTargetInRootShadowNode(
+    const SharedEventTarget& target,
+    const RootShadowNode::Shared& rootShadowNode) {
+  return target && rootShadowNode &&
+      target->getSurfaceId() == rootShadowNode->getSurfaceId();
+}
+
+bool hasPendingRenderingUpdates(
+    const SharedEventTarget& target,
+    const std::unordered_set<SurfaceId>&
+        surfaceIdsWithPendingRenderingUpdates) {
+  return target != nullptr &&
+      surfaceIdsWithPendingRenderingUpdates.contains(target->getSurfaceId());
+}
+
 struct StrKey {
   size_t key;
   StrKey(std::string_view s) : key(std::hash<std::string_view>{}(s)) {}
@@ -84,7 +101,9 @@ EventPerformanceLogger::EventPerformanceLogger(
     std::weak_ptr<PerformanceEntryReporter> performanceEntryReporter)
     : performanceEntryReporter_(std::move(performanceEntryReporter)) {}
 
-EventTag EventPerformanceLogger::onEventStart(std::string_view name) {
+EventTag EventPerformanceLogger::onEventStart(
+    std::string_view name,
+    SharedEventTarget target) {
   auto performanceEntryReporter = performanceEntryReporter_.lock();
   if (performanceEntryReporter == nullptr) {
     return EMPTY_EVENT_TAG;
@@ -103,7 +122,8 @@ EventTag EventPerformanceLogger::onEventStart(std::string_view name) {
   auto timeStamp = performanceEntryReporter->getCurrentTimeStamp();
   {
     std::lock_guard lock(eventsInFlightMutex_);
-    eventsInFlight_.emplace(eventTag, EventEntry{reportedName, timeStamp, 0.0});
+    eventsInFlight_.emplace(
+        eventTag, EventEntry{reportedName, target, timeStamp, 0.0});
   }
   return eventTag;
 }
@@ -137,12 +157,13 @@ void EventPerformanceLogger::onEventProcessingEnd(EventTag tag) {
     if (it == eventsInFlight_.end()) {
       return;
     }
+
     auto& entry = it->second;
     entry.processingEndTime = timeStamp;
 
-    if (CoreFeatures::enableReportEventPaintTime) {
+    if (ReactNativeFeatureFlags::enableReportEventPaintTime()) {
       // If reporting paint time, don't send the entry just yet and wait for the
-      // mount hook callback to be called
+      // task to finish.
       return;
     }
 
@@ -159,10 +180,47 @@ void EventPerformanceLogger::onEventProcessingEnd(EventTag tag) {
   }
 }
 
+void EventPerformanceLogger::dispatchPendingEventTimingEntries(
+    const std::unordered_set<SurfaceId>&
+        surfaceIdsWithPendingRenderingUpdates) {
+  if (!ReactNativeFeatureFlags::enableReportEventPaintTime()) {
+    return;
+  }
+
+  auto performanceEntryReporter = performanceEntryReporter_.lock();
+  if (performanceEntryReporter == nullptr) {
+    return;
+  }
+
+  std::lock_guard lock(eventsInFlightMutex_);
+  auto it = eventsInFlight_.begin();
+  while (it != eventsInFlight_.end()) {
+    auto& entry = it->second;
+
+    if (entry.isWaitingForDispatch() || entry.isWaitingForMount) {
+      ++it;
+    } else if (hasPendingRenderingUpdates(
+                   entry.target, surfaceIdsWithPendingRenderingUpdates)) {
+      // We'll wait for mount to report the event
+      entry.isWaitingForMount = true;
+      ++it;
+    } else {
+      performanceEntryReporter->logEventEntry(
+          std::string(entry.name),
+          entry.startTime,
+          performanceEntryReporter->getCurrentTimeStamp() - entry.startTime,
+          entry.processingStartTime,
+          entry.processingEndTime,
+          entry.interactionId);
+      it = eventsInFlight_.erase(it);
+    }
+  }
+}
+
 void EventPerformanceLogger::shadowTreeDidMount(
-    const RootShadowNode::Shared& /*rootShadowNode*/,
+    const RootShadowNode::Shared& rootShadowNode,
     double mountTime) noexcept {
-  if (!CoreFeatures::enableReportEventPaintTime) {
+  if (!ReactNativeFeatureFlags::enableReportEventPaintTime()) {
     return;
   }
 
@@ -175,20 +233,19 @@ void EventPerformanceLogger::shadowTreeDidMount(
   auto it = eventsInFlight_.begin();
   while (it != eventsInFlight_.end()) {
     const auto& entry = it->second;
-    if (entry.processingEndTime == 0.0 || entry.processingEndTime > mountTime) {
-      // This mount doesn't correspond to the event
+    if (entry.isWaitingForMount &&
+        isTargetInRootShadowNode(entry.target, rootShadowNode)) {
+      performanceEntryReporter->logEventEntry(
+          std::string(entry.name),
+          entry.startTime,
+          mountTime - entry.startTime,
+          entry.processingStartTime,
+          entry.processingEndTime,
+          entry.interactionId);
+      it = eventsInFlight_.erase(it);
+    } else {
       ++it;
-      continue;
     }
-
-    performanceEntryReporter->logEventEntry(
-        std::string(entry.name),
-        entry.startTime,
-        mountTime - entry.startTime,
-        entry.processingStartTime,
-        entry.processingEndTime,
-        entry.interactionId);
-    it = eventsInFlight_.erase(it);
   }
 }