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

package/ReactCommon/react/nativemodule/featureflags/NativeReactNativeFeatureFlags.h

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<e13caa80ac317feb98cf4db5ac89be79>>
+ * @generated SignedSource<<7e65025b9bdd8b515b31f02d2a1489b1>>
  */
 
 /**
@@ -37,27 +37,61 @@ class NativeReactNativeFeatureFlags
 
   bool commonTestFlag(jsi::Runtime& runtime);
 
-  bool allowCollapsableChildren(jsi::Runtime& runtime);
-
   bool allowRecursiveCommitsWithSynchronousMountOnAndroid(jsi::Runtime& runtime);
 
   bool batchRenderingUpdatesInEventLoop(jsi::Runtime& runtime);
 
+  bool completeReactInstanceCreationOnBgThreadOnAndroid(jsi::Runtime& runtime);
+
   bool destroyFabricSurfacesInReactInstanceManager(jsi::Runtime& runtime);
 
-  bool enableBackgroundExecutor(jsi::Runtime& runtime);
+  bool enableAlignItemsBaselineOnFabricIOS(jsi::Runtime& runtime);
+
+  bool enableAndroidMixBlendModeProp(jsi::Runtime& runtime);
+
+  bool enableBackgroundStyleApplicator(jsi::Runtime& runtime);
 
   bool enableCleanTextInputYogaNode(jsi::Runtime& runtime);
 
+  bool enableEagerRootViewAttachment(jsi::Runtime& runtime);
+
+  bool enableEventEmitterRetentionDuringGesturesOnAndroid(jsi::Runtime& runtime);
+
+  bool enableFabricLogs(jsi::Runtime& runtime);
+
+  bool enableFabricRendererExclusively(jsi::Runtime& runtime);
+
   bool enableGranularShadowTreeStateReconciliation(jsi::Runtime& runtime);
 
+  bool enableIOSViewClipToPaddingBox(jsi::Runtime& runtime);
+
+  bool enableLayoutAnimationsOnIOS(jsi::Runtime& runtime);
+
+  bool enableLongTaskAPI(jsi::Runtime& runtime);
+
   bool enableMicrotasks(jsi::Runtime& runtime);
 
+  bool enablePropsUpdateReconciliationAndroid(jsi::Runtime& runtime);
+
+  bool enableReportEventPaintTime(jsi::Runtime& runtime);
+
   bool enableSynchronousStateUpdates(jsi::Runtime& runtime);
 
   bool enableUIConsistency(jsi::Runtime& runtime);
 
-  bool fixStoppedSurfaceRemoveDeleteTreeUIFrameCallbackLeak(jsi::Runtime& runtime);
+  bool enableViewRecycling(jsi::Runtime& runtime);
+
+  bool excludeYogaFromRawProps(jsi::Runtime& runtime);
+
+  bool fetchImagesInViewPreallocation(jsi::Runtime& runtime);
+
+  bool fixIncorrectScrollViewStateUpdateOnAndroid(jsi::Runtime& runtime);
+
+  bool fixMappingOfEventPrioritiesBetweenFabricAndReact(jsi::Runtime& runtime);
+
+  bool fixMissedFabricStateUpdatesOnAndroid(jsi::Runtime& runtime);
+
+  bool fixMountingCoordinatorReportedPendingTransactionsOnAndroid(jsi::Runtime& runtime);
 
   bool forceBatchingMountItemsOnAndroid(jsi::Runtime& runtime);
 
@@ -65,23 +99,37 @@ class NativeReactNativeFeatureFlags
 
   bool fuseboxEnabledRelease(jsi::Runtime& runtime);
 
+  bool initEagerTurboModulesOnNativeModulesQueueAndroid(jsi::Runtime& runtime);
+
   bool lazyAnimationCallbacks(jsi::Runtime& runtime);
 
-  bool preventDoubleTextMeasure(jsi::Runtime& runtime);
+  bool loadVectorDrawablesOnImages(jsi::Runtime& runtime);
 
   bool setAndroidLayoutDirection(jsi::Runtime& runtime);
 
+  bool traceTurboModulePromiseRejectionsOnAndroid(jsi::Runtime& runtime);
+
+  bool useFabricInterop(jsi::Runtime& runtime);
+
   bool useImmediateExecutorInAndroidBridgeless(jsi::Runtime& runtime);
 
   bool useModernRuntimeScheduler(jsi::Runtime& runtime);
 
   bool useNativeViewConfigsInBridgelessMode(jsi::Runtime& runtime);
 
+  bool useNewReactImageViewBackgroundDrawing(jsi::Runtime& runtime);
+
+  bool useOptimisedViewPreallocationOnAndroid(jsi::Runtime& runtime);
+
+  bool useOptimizedEventBatchingOnAndroid(jsi::Runtime& runtime);
+
   bool useRuntimeShadowNodeReferenceUpdate(jsi::Runtime& runtime);
 
   bool useRuntimeShadowNodeReferenceUpdateOnLayout(jsi::Runtime& runtime);
 
   bool useStateAlignmentMechanism(jsi::Runtime& runtime);
+
+  bool useTurboModuleInterop(jsi::Runtime& runtime);
 };
 
 } // namespace facebook::react

package/ReactCommon/react/nativemodule/idlecallbacks/CMakeLists.txt

@@ -15,7 +15,7 @@ add_compile_options(
         -DLOG_TAG=\"ReactNative\")
 
 file(GLOB react_nativemodule_idlecallbacks_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(react_nativemodule_idlecallbacks STATIC ${react_nativemodule_idlecallbacks_SRC})
+add_library(react_nativemodule_idlecallbacks OBJECT ${react_nativemodule_idlecallbacks_SRC})
 
 target_include_directories(react_nativemodule_idlecallbacks PUBLIC ${REACT_COMMON_DIR})
 

package/ReactCommon/react/nativemodule/microtasks/CMakeLists.txt

@@ -15,7 +15,7 @@ add_compile_options(
         -DLOG_TAG=\"ReactNative\")
 
 file(GLOB react_nativemodule_microtasks_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(react_nativemodule_microtasks SHARED ${react_nativemodule_microtasks_SRC})
+add_library(react_nativemodule_microtasks OBJECT ${react_nativemodule_microtasks_SRC})
 
 target_include_directories(react_nativemodule_microtasks PUBLIC ${REACT_COMMON_DIR})
 

package/ReactCommon/react/nativemodule/mutationobserver/NativeMutationObserver.cpp

@@ -58,17 +58,6 @@ void NativeMutationObserver::connect(
     SyncCallback<jsi::Value(jsi::Value)> getPublicInstanceFromInstanceHandle) {
   auto& uiManager = getUIManagerFromRuntime(runtime);
 
-  // MutationObserver is not compatible with background executor.
-  // When using background executor, we commit trees outside the JS thread.
-  // In that case, we can't safely access the JS runtime in commit hooks to
-  // get references to mutated nodes (which we need to do at that point
-  // to ensure we are retaining removed nodes).
-  if (uiManager.hasBackgroundExecutor()) {
-    throw jsi::JSError(
-        runtime,
-        "MutationObserver: could not start observation because MutationObserver is incompatible with UIManager using background executor.");
-  }
-
   runtime_ = &runtime;
   notifyMutationObservers_.emplace(std::move(notifyMutationObservers));
   getPublicInstanceFromInstanceHandle_.emplace(

package/ReactCommon/react/nativemodule/samples/ReactCommon-Samples.podspec

@@ -49,6 +49,8 @@ Pod::Spec.new do |s|
                                "USE_HEADERMAP" => "YES",
                                "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard(),
                                "GCC_WARN_PEDANTIC" => "YES" }
+  s.framework = "UIKit"
+
   if ENV['USE_FRAMEWORKS']
     s.header_mappings_dir     = './'
   end

package/ReactCommon/react/nativemodule/samples/platform/android/CMakeLists.txt

@@ -23,5 +23,5 @@ target_include_directories(sampleturbomodule PUBLIC .)
 target_link_libraries(sampleturbomodule
         fbjni
         jsi
-        react_nativemodule_core
-        turbomodulejsijni)
+        reactnative
+)

package/ReactCommon/react/nativemodule/samples/platform/android/NativeSampleTurboModuleSpec.java

@@ -40,6 +40,22 @@ public abstract class NativeSampleTurboModuleSpec extends ReactContextBaseJavaMo
     return NAME;
   }
 
+  protected final void emitOnPress() {
+    mEventEmitterCallback.invoke("onPress");
+  }
+
+  protected final void emitOnClick(String value) {
+    mEventEmitterCallback.invoke("onClick", value);
+  }
+
+  protected final void emitOnChange(ReadableMap value) {
+    mEventEmitterCallback.invoke("onChange", value);
+  }
+
+  protected void emitOnSubmit(ReadableArray value) {
+    mEventEmitterCallback.invoke("onSubmit", value);
+  }
+
   protected abstract Map<String, Object> getTypedExportedConstants();
 
   @Override

package/ReactCommon/react/nativemodule/samples/platform/android/ReactCommon/SampleTurboModuleSpec.cpp

@@ -351,6 +351,15 @@ NativeSampleTurboModuleSpecJSI::NativeSampleTurboModuleSpecJSI(
       1, __hostFunction_NativeSampleTurboModuleSpecJSI_getObjectAssert};
   methodMap_["promiseAssert"] = MethodMetadata{
       0, __hostFunction_NativeSampleTurboModuleSpecJSI_promiseAssert};
+  eventEmitterMap_["onPress"] =
+      std::make_shared<AsyncEventEmitter<folly::dynamic>>();
+  eventEmitterMap_["onClick"] =
+      std::make_shared<AsyncEventEmitter<folly::dynamic>>();
+  eventEmitterMap_["onChange"] =
+      std::make_shared<AsyncEventEmitter<folly::dynamic>>();
+  eventEmitterMap_["onSubmit"] =
+      std::make_shared<AsyncEventEmitter<folly::dynamic>>();
+  setEventEmitterCallback(params.instance);
 }
 
 std::shared_ptr<TurboModule> SampleTurboModuleSpec_ModuleProvider(

package/ReactCommon/react/nativemodule/samples/platform/android/SampleTurboModule.java

@@ -104,7 +104,26 @@ public class SampleTurboModule extends NativeSampleTurboModuleSpec
   @Override
   public void voidFunc() {
     log("voidFunc", "<void>", "<void>");
-    return;
+    emitOnPress();
+    emitOnClick("click");
+    {
+      WritableNativeMap map = new WritableNativeMap();
+      map.putInt("a", 1);
+      map.putString("b", "two");
+      emitOnChange(map);
+    }
+    {
+      WritableNativeArray array = new WritableNativeArray();
+      WritableNativeMap map = new WritableNativeMap();
+      map.putInt("a", 1);
+      map.putString("b", "two");
+      array.pushMap(map);
+      WritableNativeMap map1 = new WritableNativeMap();
+      map1.putInt("a", 3);
+      map1.putString("b", "four");
+      array.pushMap(map1);
+      emitOnSubmit(array);
+    }
   }
 
   // This function returns {@link WritableMap} instead of {@link Map} for backward compat with

package/ReactCommon/react/nativemodule/samples/platform/ios/ReactCommon/RCTNativeSampleTurboModuleSpec.h

@@ -43,6 +43,17 @@
 
 @end
 
+@interface NativeSampleTurboModuleSpecBase : NSObject {
+ @protected
+  facebook::react::EventEmitterCallback _eventEmitterCallback;
+}
+- (void)setEventEmitterCallback:(EventEmitterCallbackWrapper *_Nonnull)eventEmitterCallbackWrapper;
+- (void)emitOnPress;
+- (void)emitOnClick:(NSString *)value;
+- (void)emitOnChange:(NSDictionary *)value;
+- (void)emitOnSubmit:(NSArray *)value;
+@end
+
 namespace facebook::react {
 
 /**

package/ReactCommon/react/nativemodule/samples/platform/ios/ReactCommon/RCTNativeSampleTurboModuleSpec.mm

@@ -224,6 +224,40 @@ NativeSampleTurboModuleSpecJSI::NativeSampleTurboModuleSpecJSI(const ObjCTurboMo
   methodMap_["getObjectAssert"] = MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getObjectAssert};
   methodMap_["promiseAssert"] = MethodMetadata{0, __hostFunction_NativeSampleTurboModuleSpecJSI_promiseAssert};
   methodMap_["getConstants"] = MethodMetadata{0, __hostFunction_NativeSampleTurboModuleSpecJSI_getConstants};
+  eventEmitterMap_["onPress"] = std::make_shared<AsyncEventEmitter<id>>();
+  eventEmitterMap_["onClick"] = std::make_shared<AsyncEventEmitter<id>>();
+  eventEmitterMap_["onChange"] = std::make_shared<AsyncEventEmitter<id>>();
+  eventEmitterMap_["onSubmit"] = std::make_shared<AsyncEventEmitter<id>>();
+  setEventEmitterCallback([&](const std::string &name, id value) {
+    static_cast<AsyncEventEmitter<id> &>(*eventEmitterMap_[name]).emit(value);
+  });
 }
 
 } // namespace facebook::react
+
+@implementation NativeSampleTurboModuleSpecBase
+- (void)setEventEmitterCallback:(EventEmitterCallbackWrapper *_Nonnull)eventEmitterCallbackWrapper
+{
+  _eventEmitterCallback = std::move(eventEmitterCallbackWrapper->_eventEmitterCallback);
+}
+
+- (void)emitOnPress
+{
+  _eventEmitterCallback("onPress", nil);
+}
+
+- (void)emitOnClick:(NSString *)value
+{
+  _eventEmitterCallback("onClick", value);
+}
+
+- (void)emitOnChange:(NSDictionary *)value
+{
+  _eventEmitterCallback("onChange", value);
+}
+
+- (void)emitOnSubmit:(NSArray *)value
+{
+  _eventEmitterCallback("onSubmit", value);
+}
+@end

package/ReactCommon/react/nativemodule/samples/platform/ios/ReactCommon/RCTSampleTurboModule.h

@@ -13,6 +13,6 @@
  * Sample iOS-specific impl of a TurboModule, conforming to the spec protocol.
  * This class is also 100% compatible with the NativeModule system.
  */
-@interface RCTSampleTurboModule : NSObject <NativeSampleTurboModuleSpec>
+@interface RCTSampleTurboModule : NativeSampleTurboModuleSpecBase <NativeSampleTurboModuleSpec>
 
 @end

package/ReactCommon/react/nativemodule/samples/platform/ios/ReactCommon/RCTSampleTurboModule.mm

@@ -82,6 +82,10 @@ RCT_EXPORT_MODULE()
 RCT_EXPORT_METHOD(voidFunc)
 {
   // Nothing to do
+  [self emitOnPress];
+  [self emitOnClick:@"click"];
+  [self emitOnChange:@{@"a" : @1, @"b" : @"two"}];
+  [self emitOnSubmit:@[ @{@"a" : @1, @"b" : @"two"}, @{@"a" : @3, @"b" : @"four"} ]];
 }
 
 RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(NSNumber *, getBool : (BOOL)arg)

package/ReactCommon/react/nativemodule/webperformance/NativePerformance.cpp

@@ -15,7 +15,8 @@
 #include <cxxreact/ReactMarker.h>
 #include <jsi/instrumentation.h>
 #include <react/performance/timeline/PerformanceEntryReporter.h>
-
+#include <reactperflogger/fusebox/FuseboxTracer.h>
+#include "NativePerformance.h"
 #include "Plugins.h"
 
 #ifdef WITH_PERFETTO
@@ -32,12 +33,17 @@ namespace facebook::react {
 
 namespace {
 
-#ifdef WITH_PERFETTO
+#if defined(__clang__)
+#define NO_DESTROY [[clang::no_destroy]]
+#else
+#define NO_DESTROY
+#endif
 
-const std::string TRACK_PREFIX = "Track:";
-const std::string DEFAULT_TRACK_NAME = "Web Performance";
+NO_DESTROY const std::string TRACK_PREFIX = "Track:";
+NO_DESTROY const std::string DEFAULT_TRACK_NAME = "# Web Performance";
+NO_DESTROY const std::string CUSTOM_TRACK_NAME_PREFIX = "# Web Performance: ";
 
-std::tuple<perfetto::Track, std::string_view> parsePerfettoTrack(
+std::tuple<std::string, std::string_view> parseTrackName(
     const std::string& name) {
   // Until there's a standard way to pass through track information, parse it
   // manually, e.g., "Track:Foo:Event name"
@@ -47,18 +53,18 @@ std::tuple<perfetto::Track, std::string_view> parsePerfettoTrack(
   if (name.starts_with(TRACK_PREFIX)) {
     const auto trackNameDelimiter = name.find(':', TRACK_PREFIX.length());
     if (trackNameDelimiter != std::string::npos) {
-      trackName = name.substr(
-          TRACK_PREFIX.length(), trackNameDelimiter - TRACK_PREFIX.length());
+      trackName = CUSTOM_TRACK_NAME_PREFIX +
+          name.substr(
+              TRACK_PREFIX.length(),
+              trackNameDelimiter - TRACK_PREFIX.length());
       eventName = std::string_view(name).substr(trackNameDelimiter + 1);
     }
   }
 
   auto& trackNameRef = trackName.has_value() ? *trackName : DEFAULT_TRACK_NAME;
-  return std::make_tuple(getPerfettoWebPerfTrack(trackNameRef), eventName);
+  return std::make_tuple(trackNameRef, eventName);
 }
 
-#endif
-
 } // namespace
 
 NativePerformance::NativePerformance(std::shared_ptr<CallInvoker> jsInvoker)
@@ -76,17 +82,18 @@ void NativePerformance::mark(
     jsi::Runtime& rt,
     std::string name,
     double startTime) {
+  PerformanceEntryReporter::getInstance()->mark(name, startTime);
+
 #ifdef WITH_PERFETTO
   if (TRACE_EVENT_CATEGORY_ENABLED("react-native")) {
-    auto [track, eventName] = parsePerfettoTrack(name);
+    auto [trackName, eventName] = parseTrackName(name);
     TRACE_EVENT_INSTANT(
         "react-native",
         perfetto::DynamicString(eventName.data(), eventName.size()),
-        track,
+        getPerfettoWebPerfTrackSync(trackName),
         performanceNowToPerfettoTraceTime(startTime));
   }
 #endif
-  PerformanceEntryReporter::getInstance()->mark(name, startTime);
 }
 
 void NativePerformance::measure(
@@ -97,11 +104,18 @@ void NativePerformance::measure(
     std::optional<double> duration,
     std::optional<std::string> startMark,
     std::optional<std::string> endMark) {
+  auto [trackName, eventName] = parseTrackName(name);
+
+  FuseboxTracer::getFuseboxTracer().addEvent(
+      eventName, (uint64_t)startTime, (uint64_t)endTime, trackName);
+  PerformanceEntryReporter::getInstance()->measure(
+      eventName, startTime, endTime, duration, startMark, endMark);
+
 #ifdef WITH_PERFETTO
   if (TRACE_EVENT_CATEGORY_ENABLED("react-native")) {
     // TODO T190600850 support startMark/endMark
     if (!startMark && !endMark) {
-      auto [track, eventName] = parsePerfettoTrack(name);
+      auto track = getPerfettoWebPerfTrackAsync(trackName);
       TRACE_EVENT_BEGIN(
           "react-native",
           perfetto::DynamicString(eventName.data(), eventName.size()),
@@ -112,8 +126,6 @@ void NativePerformance::measure(
     }
   }
 #endif
-  PerformanceEntryReporter::getInstance()->measure(
-      name, startTime, endTime, duration, startMark, endMark);
 }
 
 std::unordered_map<std::string, double> NativePerformance::getSimpleMemoryInfo(

package/ReactCommon/react/nativemodule/webperformance/NativePerformanceObserver.cpp

@@ -9,6 +9,7 @@
 
 #include "NativePerformanceObserver.h"
 
+#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/performance/timeline/PerformanceEntryReporter.h>
 #include <react/renderer/uimanager/UIManagerBinding.h>
 #include <react/utils/CoreFeatures.h>
@@ -113,11 +114,17 @@ std::vector<PerformanceEntry> NativePerformanceObserver::getEntries(
 std::vector<PerformanceEntryType>
 NativePerformanceObserver::getSupportedPerformanceEntryTypes(
     jsi::Runtime& /*rt*/) {
-  return {
+  std::vector supportedEntries = {
       PerformanceEntryType::MARK,
       PerformanceEntryType::MEASURE,
       PerformanceEntryType::EVENT,
   };
+
+  if (ReactNativeFeatureFlags::enableLongTaskAPI()) {
+    supportedEntries.push_back(PerformanceEntryType::LONGTASK);
+  }
+
+  return supportedEntries;
 }
 
 } // namespace facebook::react

package/ReactCommon/react/performance/timeline/CMakeLists.txt

@@ -15,8 +15,9 @@ add_compile_options(
         -DLOG_TAG=\"ReactNative\")
 
 file(GLOB react_performance_timeline_SRC CONFIGURE_DEPENDS *.cpp)
-add_library(react_performance_timeline SHARED ${react_performance_timeline_SRC})
+add_library(react_performance_timeline OBJECT ${react_performance_timeline_SRC})
 
 target_include_directories(react_performance_timeline PUBLIC ${REACT_COMMON_DIR})
 target_link_libraries(react_performance_timeline
+        react_timing
         react_cxxreact)

package/ReactCommon/react/performance/timeline/PerformanceEntryReporter.cpp

@@ -229,7 +229,7 @@ std::vector<PerformanceEntry> PerformanceEntryReporter::getEntries(
 }
 
 void PerformanceEntryReporter::measure(
-    const std::string& name,
+    const std::string_view& name,
     DOMHighResTimeStamp startTime,
     DOMHighResTimeStamp endTime,
     const std::optional<DOMHighResTimeStamp>& duration,
@@ -249,7 +249,7 @@ void PerformanceEntryReporter::measure(
       duration ? *duration : endTimeVal - startTimeVal;
 
   logEntry(
-      {.name = name,
+      {.name = std::string(name),
        .entryType = PerformanceEntryType::MEASURE,
        .startTime = startTimeVal,
        .duration = durationVal});
@@ -287,6 +287,16 @@ void PerformanceEntryReporter::logEventEntry(
        .interactionId = interactionId});
 }
 
+void PerformanceEntryReporter::logLongTaskEntry(
+    DOMHighResTimeStamp startTime,
+    DOMHighResTimeStamp duration) {
+  logEntry(
+      {.name = std::string{"self"},
+       .entryType = PerformanceEntryType::LONGTASK,
+       .startTime = startTime,
+       .duration = duration});
+}
+
 void PerformanceEntryReporter::scheduleFlushBuffer() {
   if (callback_) {
     callback_();

package/ReactCommon/react/performance/timeline/PerformanceEntryReporter.h

@@ -7,6 +7,7 @@
 
 #pragma once
 
+#include <react/timing/primitives.h>
 #include "BoundedConsumableBuffer.h"
 
 #include <array>
@@ -20,8 +21,6 @@
 
 namespace facebook::react {
 
-using DOMHighResTimeStamp = double;
-
 using PerformanceEntryInteractionId = uint32_t;
 
 enum class PerformanceEntryType {
@@ -29,7 +28,8 @@ enum class PerformanceEntryType {
   MARK = 1,
   MEASURE = 2,
   EVENT = 3,
-  _NEXT = 4,
+  LONGTASK = 4,
+  _NEXT = 5,
 };
 
 struct PerformanceEntry {
@@ -81,6 +81,8 @@ struct PerformanceEntryBuffer {
 constexpr size_t NUM_PERFORMANCE_ENTRY_TYPES =
     (size_t)PerformanceEntryType::_NEXT - 1; // Valid types start from 1.
 
+constexpr DOMHighResTimeStamp LONG_TASK_DURATION_THRESHOLD_MS = 50.0;
+
 class PerformanceEntryReporter {
  public:
   PerformanceEntryReporter();
@@ -135,7 +137,7 @@ class PerformanceEntryReporter {
       const std::optional<double>& startTime = std::nullopt);
 
   void measure(
-      const std::string& name,
+      const std::string_view& name,
       double startTime,
       double endTime,
       const std::optional<double>& duration = std::nullopt,
@@ -158,6 +160,8 @@ class PerformanceEntryReporter {
       double processingEnd,
       uint32_t interactionId);
 
+  void logLongTaskEntry(double startTime, double duration);
+
   const std::unordered_map<std::string, uint32_t>& getEventCounts() const {
     return eventCounts_;
   }

package/ReactCommon/react/performance/timeline/React-performancetimeline.podspec

@@ -51,6 +51,7 @@ Pod::Spec.new do |s|
     s.header_mappings_dir  = "../../.."
   end
 
+  s.dependency "React-timing"
   s.dependency "React-cxxreact"
   s.dependency "RCT-Folly", folly_version
 end

package/ReactCommon/react/renderer/animations/LayoutAnimationKeyFrameManager.cpp

@@ -291,10 +291,6 @@ LayoutAnimationKeyFrameManager::pullTransaction(
       std::vector<AnimationKeyFrame> keyFramesToAnimate;
       const auto layoutAnimationConfig = animation.layoutAnimationConfig;
       for (const auto& mutation : mutations) {
-        if (mutation.type == ShadowViewMutation::Type::RemoveDeleteTree) {
-          continue;
-        }
-
         ShadowView baselineShadowView =
             (mutation.type == ShadowViewMutation::Type::Delete ||
                      mutation.type == ShadowViewMutation::Type::Remove ||
@@ -794,10 +790,7 @@ LayoutAnimationKeyFrameManager::pullTransaction(
           finalConflictingMutations.end(),
           &shouldFirstComeBeforeSecondMutation);
 
-      std::stable_sort(
-          immediateMutations.begin(),
-          immediateMutations.end(),
-          &shouldFirstComeBeforeSecondRemovesOnly);
+      handleShouldFirstComeBeforeSecondRemovesOnly(immediateMutations);
 
       animation.keyFrames = keyFramesToAnimate;
       inflightAnimations_.push_back(std::move(animation));
@@ -1191,16 +1184,6 @@ void LayoutAnimationKeyFrameManager::queueFinalMutationsForCompletedKeyFrame(
           mutationsList.push_back(ShadowViewMutation::RemoveMutation(
               finalMutation.parentShadowView, prev, finalMutation.index));
           break;
-        case ShadowViewMutation::Type::RemoveDeleteTree:
-          // Note: Currently, there is a guarantee that if RemoveDeleteTree
-          // operations are generated, we /also/ generate corresponding
-          // Remove/Delete operations that are marked as "redundant".
-          // LayoutAnimations will process the redundant operations here, and
-          // ignore this mega-op. In the future for perf reasons it would be
-          // nice to remove the redundant operations entirely but we would need
-          // to find a way to make the RemoveDeleteTree operation work with
-          // LayoutAnimations (that might not be possible).
-          break;
         case ShadowViewMutation::Type::Update:
           mutationsList.push_back(ShadowViewMutation::UpdateMutation(
               prev,
@@ -1492,10 +1475,6 @@ void LayoutAnimationKeyFrameManager::getAndEraseConflictingAnimations(
     std::vector<AnimationKeyFrame>& conflictingAnimations) const {
   ShadowViewMutationList localConflictingMutations{};
   for (const auto& mutation : mutations) {
-    if (mutation.type == ShadowViewMutation::Type::RemoveDeleteTree) {
-      continue;
-    }
-
     bool mutationIsCreateOrDelete =
         mutation.type == ShadowViewMutation::Type::Create ||
         mutation.type == ShadowViewMutation::Type::Delete;

package/ReactCommon/react/renderer/animations/utils.h

@@ -24,6 +24,40 @@ static inline bool shouldFirstComeBeforeSecondRemovesOnly(
       (lhs.index > rhs.index);
 }
 
+static inline void handleShouldFirstComeBeforeSecondRemovesOnly(
+    ShadowViewMutation::List& list) noexcept {
+  std::unordered_map<std::string, std::vector<ShadowViewMutation>>
+      removeMutationsByTag;
+  ShadowViewMutation::List finalList;
+  for (auto& mutation : list) {
+    if (mutation.type == ShadowViewMutation::Type::Remove) {
+      auto key = std::to_string(mutation.parentShadowView.tag);
+      removeMutationsByTag[key].push_back(mutation);
+    } else {
+      finalList.push_back(mutation);
+    }
+  }
+
+  if (removeMutationsByTag.size() == 0) {
+    return;
+  }
+
+  for (auto& mutationsPair : removeMutationsByTag) {
+    if (mutationsPair.second.size() > 1) {
+      std::stable_sort(
+          mutationsPair.second.begin(),
+          mutationsPair.second.end(),
+          &shouldFirstComeBeforeSecondRemovesOnly);
+    }
+    finalList.insert(
+        finalList.begin(),
+        mutationsPair.second.begin(),
+        mutationsPair.second.end());
+  }
+
+  list = finalList;
+}
+
 static inline bool shouldFirstComeBeforeSecondMutation(
     const ShadowViewMutation& lhs,
     const ShadowViewMutation& rhs) noexcept {
@@ -55,6 +89,17 @@ static inline bool shouldFirstComeBeforeSecondMutation(
         lhs.type == ShadowViewMutation::Type::Insert) {
       return false;
     }
+
+    // Remove comes before Update
+    if (lhs.type == ShadowViewMutation::Type::Remove &&
+        rhs.type == ShadowViewMutation::Type::Update) {
+      return true;
+    }
+    if (rhs.type == ShadowViewMutation::Type::Remove &&
+        lhs.type == ShadowViewMutation::Type::Update) {
+      return false;
+    }
+
   } else {
     // Make sure that removes on the same level are sorted - highest indices
     // must come first.