react-native-tvos 0.83.1-1 → 0.84.0-0

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

@@ -7,6 +7,30 @@
 
 #import "RCTNativeSampleTurboModuleSpec.h"
 
+@implementation NativeSampleTurboModuleSpecBase
+- (void)emitOnPress
+{
+  _eventEmitterCallback("onPress", nil);
+}
+- (void)emitOnClick:(NSString *_Nonnull)value
+{
+  _eventEmitterCallback("onClick", value);
+}
+- (void)emitOnChange:(NSDictionary *)value
+{
+  _eventEmitterCallback("onChange", value);
+}
+- (void)emitOnSubmit:(NSArray<id<NSObject>> *)value
+{
+  _eventEmitterCallback("onSubmit", value);
+}
+
+- (void)setEventEmitterCallback:(EventEmitterCallbackWrapper *)eventEmitterCallbackWrapper
+{
+  _eventEmitterCallback = std::move(eventEmitterCallbackWrapper->_eventEmitterCallback);
+}
+@end
+
 namespace facebook::react {
 
 static facebook::jsi::Value __hostFunction_NativeSampleTurboModuleSpecJSI_voidFunc(
@@ -190,6 +214,16 @@ static facebook::jsi::Value __hostFunction_NativeSampleTurboModuleSpecJSI_promis
       .invokeObjCMethod(rt, PromiseKind, "promiseAssert", @selector(promiseAssert:reject:), args, count);
 }
 
+static facebook::jsi::Value __hostFunction_NativeSampleTurboModuleSpecJSI_getImageUrl(
+    facebook::jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const facebook::jsi::Value *args,
+    size_t count)
+{
+  return static_cast<ObjCTurboModule &>(turboModule)
+      .invokeObjCMethod(rt, PromiseKind, "getImageUrl", @selector(getImageUrl:reject:), args, count);
+}
+
 static facebook::jsi::Value __hostFunction_NativeSampleTurboModuleSpecJSI_getConstants(
     facebook::jsi::Runtime &rt,
     TurboModule &turboModule,
@@ -203,44 +237,48 @@ static facebook::jsi::Value __hostFunction_NativeSampleTurboModuleSpecJSI_getCon
 NativeSampleTurboModuleSpecJSI::NativeSampleTurboModuleSpecJSI(const ObjCTurboModule::InitParams &params)
     : ObjCTurboModule(params)
 {
-  methodMap_["voidFunc"] =
-      MethodMetadata{.argCount = 0, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_voidFunc};
-  methodMap_["getBool"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getBool};
-  methodMap_["getEnum"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getEnum};
-  methodMap_["getNumber"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getNumber};
-  methodMap_["getString"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getString};
-  methodMap_["getArray"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getArray};
-  methodMap_["getObject"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getObject};
-  methodMap_["getUnsafeObject"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getUnsafeObject};
-  methodMap_["getRootTag"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getRootTag};
-  methodMap_["getValue"] =
-      MethodMetadata{.argCount = 3, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getValue};
+  methodMap_["voidFunc"] = MethodMetadata{0, __hostFunction_NativeSampleTurboModuleSpecJSI_voidFunc};
+
+  methodMap_["getBool"] = MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getBool};
+
+  methodMap_["getEnum"] = MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getEnum};
+
+  methodMap_["getNumber"] = MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getNumber};
+
+  methodMap_["getString"] = MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getString};
+
+  methodMap_["getArray"] = MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getArray};
+
+  methodMap_["getObject"] = MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getObject};
+
+  methodMap_["getUnsafeObject"] = MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getUnsafeObject};
+
+  methodMap_["getRootTag"] = MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getRootTag};
+
+  methodMap_["getValue"] = MethodMetadata{3, __hostFunction_NativeSampleTurboModuleSpecJSI_getValue};
+
   methodMap_["getValueWithCallback"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getValueWithCallback};
+      MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getValueWithCallback};
+
   methodMap_["getValueWithPromise"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getValueWithPromise};
-  methodMap_["voidFuncThrows"] =
-      MethodMetadata{.argCount = 0, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_voidFuncThrows};
-  methodMap_["getObjectThrows"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getObjectThrows};
-  methodMap_["promiseThrows"] =
-      MethodMetadata{.argCount = 0, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_promiseThrows};
-  methodMap_["voidFuncAssert"] =
-      MethodMetadata{.argCount = 0, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_voidFuncAssert};
-  methodMap_["getObjectAssert"] =
-      MethodMetadata{.argCount = 1, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getObjectAssert};
-  methodMap_["promiseAssert"] =
-      MethodMetadata{.argCount = 0, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_promiseAssert};
-  methodMap_["getConstants"] =
-      MethodMetadata{.argCount = 0, .invoker = __hostFunction_NativeSampleTurboModuleSpecJSI_getConstants};
+      MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getValueWithPromise};
+
+  methodMap_["voidFuncThrows"] = MethodMetadata{0, __hostFunction_NativeSampleTurboModuleSpecJSI_voidFuncThrows};
+
+  methodMap_["getObjectThrows"] = MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getObjectThrows};
+
+  methodMap_["promiseThrows"] = MethodMetadata{0, __hostFunction_NativeSampleTurboModuleSpecJSI_promiseThrows};
+
+  methodMap_["voidFuncAssert"] = MethodMetadata{0, __hostFunction_NativeSampleTurboModuleSpecJSI_voidFuncAssert};
+
+  methodMap_["getObjectAssert"] = MethodMetadata{1, __hostFunction_NativeSampleTurboModuleSpecJSI_getObjectAssert};
+
+  methodMap_["promiseAssert"] = MethodMetadata{0, __hostFunction_NativeSampleTurboModuleSpecJSI_promiseAssert};
+
+  methodMap_["getImageUrl"] = MethodMetadata{0, __hostFunction_NativeSampleTurboModuleSpecJSI_getImageUrl};
+
+  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>>();
@@ -249,32 +287,4 @@ NativeSampleTurboModuleSpecJSI::NativeSampleTurboModuleSpecJSI(const ObjCTurboMo
     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.mm

@@ -20,7 +20,7 @@ using namespace facebook::react;
 @end
 
 @implementation RCTSampleTurboModule {
-  NSDictionary *_constants;
+  facebook::react::ModuleConstants<JS::NativeSampleTurboModule::Constants> _constants;
 }
 
 // Backward-compatible export
@@ -37,11 +37,11 @@ RCT_EXPORT_MODULE()
   UIScreen *mainScreen = UIScreen.mainScreen;
   CGSize screenSize = mainScreen.bounds.size;
 
-  _constants = @{
-    @"const1" : @YES,
-    @"const2" : @(screenSize.width),
-    @"const3" : @"something",
-  };
+  _constants = facebook::react::typedConstants<JS::NativeSampleTurboModule::Constants>({
+      .const1 = YES,
+      .const2 = screenSize.width,
+      .const3 = @"something",
+  });
 }
 
 - (dispatch_queue_t)methodQueue
@@ -62,15 +62,19 @@ RCT_EXPORT_MODULE()
   NSLog(@"Invalidating RCTSampleTurboModule...");
 }
 
-- (NSDictionary *)getConstants
+- (facebook::react::ModuleConstants<JS::NativeSampleTurboModule::Constants>)constantsToExport
+{
+  return _constants;
+}
+
+- (facebook::react::ModuleConstants<JS::NativeSampleTurboModule::Constants>)getConstants
 {
   return _constants;
 }
 
-// TODO: Remove once fully migrated to TurboModule.
-- (NSDictionary *)constantsToExport
+- (void)getImageUrl:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
 {
-  return [self getConstants];
+  reject(@"Exception", @"Not implemented", nil);
 }
 
 #pragma mark - RCTTurboModuleWithJSIBindings
@@ -168,7 +172,7 @@ RCT_EXPORT_METHOD(
 
 RCT_EXPORT_METHOD(voidFuncThrows)
 {
-  NSException *myException = [NSException exceptionWithName:@"Excepption"
+  NSException *myException = [NSException exceptionWithName:@"Exception"
                                                      reason:@"Intentional exception from ObjC voidFuncThrows"
                                                    userInfo:nil];
   @throw myException;
@@ -176,7 +180,7 @@ RCT_EXPORT_METHOD(voidFuncThrows)
 
 RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(NSDictionary *, getObjectThrows : (NSDictionary *)arg)
 {
-  NSException *myException = [NSException exceptionWithName:@"Excepption"
+  NSException *myException = [NSException exceptionWithName:@"Exception"
                                                      reason:@"Intentional exception from ObjC getObjectThrows"
                                                    userInfo:nil];
   @throw myException;
@@ -184,7 +188,7 @@ RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(NSDictionary *, getObjectThrows : (NSDiction
 
 RCT_EXPORT_METHOD(promiseThrows : (RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject)
 {
-  NSException *myException = [NSException exceptionWithName:@"Excepption"
+  NSException *myException = [NSException exceptionWithName:@"Exception"
                                                      reason:@"Intentional exception from ObjC promiseThrows"
                                                    userInfo:nil];
   @throw myException;

package/ReactCommon/react/networking/NetworkReporter.cpp

@@ -13,7 +13,6 @@
 #include <jsinspector-modern/tracing/PerformanceTracer.h>
 #endif
 #include <jsinspector-modern/network/HttpUtils.h>
-#include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/performance/timeline/PerformanceEntryReporter.h>
 
 namespace facebook::react {
@@ -169,9 +168,16 @@ void NetworkReporter::reportDataReceived(
     int dataLength,
     const std::optional<int>& encodedDataLength) {
 #ifdef REACT_NATIVE_DEBUGGER_ENABLED
+  auto now = HighResTimeStamp::now();
+
   // Debugger enabled: CDP event handling
   jsinspector_modern::NetworkHandler::getInstance().onDataReceived(
       requestId, dataLength, encodedDataLength.value_or(dataLength));
+
+  // Debugger enabled: Add trace event to Performance timeline
+  jsinspector_modern::tracing::PerformanceTracer::getInstance()
+      .reportResourceReceivedData(
+          requestId, now, encodedDataLength.value_or(dataLength));
 #endif
 }
 
@@ -180,27 +186,25 @@ void NetworkReporter::reportResponseEnd(
     int encodedDataLength) {
   auto now = HighResTimeStamp::now();
 
-  if (ReactNativeFeatureFlags::enableResourceTimingAPI()) {
-    // All builds: Report PerformanceResourceTiming event
-    {
-      std::lock_guard<std::mutex> lock(perfTimingsMutex_);
-      auto it = perfTimingsBuffer_.find(requestId);
-      if (it != perfTimingsBuffer_.end()) {
-        auto& eventData = it->second;
-        PerformanceEntryReporter::getInstance()->reportResourceTiming(
-            eventData.url,
-            eventData.fetchStart,
-            eventData.requestStart,
-            eventData.connectStart.value_or(now),
-            eventData.connectEnd.value_or(now),
-            eventData.responseStart.value_or(now),
-            now,
-            eventData.responseStatus,
-            eventData.contentType,
-            eventData.encodedBodySize,
-            eventData.decodedBodySize);
-        perfTimingsBuffer_.erase(requestId);
-      }
+  // All builds: Report PerformanceResourceTiming event
+  {
+    std::lock_guard<std::mutex> lock(perfTimingsMutex_);
+    auto it = perfTimingsBuffer_.find(requestId);
+    if (it != perfTimingsBuffer_.end()) {
+      auto& eventData = it->second;
+      PerformanceEntryReporter::getInstance()->reportResourceTiming(
+          eventData.url,
+          eventData.fetchStart,
+          eventData.requestStart,
+          eventData.connectStart.value_or(now),
+          eventData.connectEnd.value_or(now),
+          eventData.responseStart.value_or(now),
+          now,
+          eventData.responseStatus,
+          eventData.contentType,
+          eventData.encodedBodySize,
+          eventData.decodedBodySize);
+      perfTimingsBuffer_.erase(requestId);
     }
   }
 

package/ReactCommon/react/networking/React-networking.podspec

@@ -41,7 +41,6 @@ Pod::Spec.new do |s|
     s.module_name            = "React_networking"
     s.header_mappings_dir  = "../.."
   end
-  add_dependency(s, "React-featureflags")
   add_dependency(s, "React-jsinspectornetwork", :framework_name => 'jsinspector_modernnetwork')
   add_dependency(s, "React-jsinspectortracing", :framework_name => 'jsinspector_moderntracing')
   s.dependency "React-performancetimeline"

package/ReactCommon/react/performance/cdpmetrics/CdpPerfIssuesReporter.cpp

@@ -42,8 +42,10 @@ void CdpPerfIssuesReporter::onMeasureEntry(
       return;
     }
 
-    if (detail.count("rnPerfIssue") != 0 && detail["rnPerfIssue"].isObject()) {
-      auto& perfIssue = detail["rnPerfIssue"];
+    if (detail.count("devtools") != 0 && detail["devtools"].isObject() &&
+        detail["devtools"].count("performanceIssue") != 0 &&
+        detail["devtools"]["performanceIssue"].isObject()) {
+      auto& perfIssue = detail["devtools"]["performanceIssue"];
 
       if (perfIssue.count("name") != 0 && perfIssue.count("severity") != 0 &&
           perfIssue.count("description") != 0) {

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

@@ -16,6 +16,7 @@ target_compile_options(react_performance_timeline PRIVATE -Wpedantic)
 
 target_include_directories(react_performance_timeline PUBLIC ${REACT_COMMON_DIR})
 target_link_libraries(react_performance_timeline
+        jsinspector
         jsinspector_tracing
         reactperflogger
         react_featureflags

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

@@ -7,6 +7,7 @@
 
 #include "PerformanceEntryReporter.h"
 
+#include <jsinspector-modern/ConsoleTaskOrchestrator.h>
 #include <jsinspector-modern/tracing/PerformanceTracer.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <react/timing/primitives.h>
@@ -30,7 +31,7 @@ std::vector<PerformanceEntryType> getSupportedEntryTypesInternal() {
       PerformanceEntryType::LONGTASK,
   };
 
-  if (ReactNativeFeatureFlags::enableResourceTimingAPI()) {
+  if (ReactNativeFeatureFlags::enableNetworkEventReporting()) {
     supportedEntryTypes.emplace_back(PerformanceEntryType::RESOURCE);
   }
 
@@ -381,8 +382,15 @@ void PerformanceEntryReporter::traceMeasure(
     }
 
     if (performanceTracer.isTracing()) {
+      auto taskContext =
+          jsinspector_modern::ConsoleTaskOrchestrator::getInstance().top();
+
       performanceTracer.reportMeasure(
-          entry.name, entry.startTime, entry.duration, std::move(detail));
+          entry.name,
+          entry.startTime,
+          entry.duration,
+          std::move(detail),
+          taskContext ? taskContext->getSerializedStackTrace() : nullptr);
     }
   }
 }

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

@@ -41,6 +41,7 @@ Pod::Spec.new do |s|
   resolve_use_frameworks(s, header_mappings_dir: "../../..", module_name: "React_performancetimeline")
 
   s.dependency "React-featureflags"
+  add_dependency(s, "React-jsinspector", :framework_name => 'jsinspector_modern')
   add_dependency(s, "React-jsinspectortracing", :framework_name => 'jsinspector_moderntracing')
   s.dependency "React-timing"
   s.dependency "React-perflogger"

package/ReactCommon/react/renderer/animated/AnimatedModule.cpp

@@ -9,9 +9,9 @@
 
 #include <glog/logging.h>
 #include <jsi/JSIDynamic.h>
+#include <react/renderer/bridging/bridging.h>
 
 namespace facebook::react {
-
 AnimatedModule::AnimatedModule(
     std::shared_ptr<CallInvoker> jsInvoker,
     std::shared_ptr<NativeAnimatedNodesManagerProvider> nodesManagerProvider)
@@ -27,17 +27,18 @@ void AnimatedModule::finishOperationBatch(jsi::Runtime& /*rt*/) {
   std::swap(preOperations_, preOperations);
   std::swap(operations_, operations);
 
-  if (nodesManager_) {
+  if (auto nodesManager = nodesManager_.lock()) {
     // TODO: nodesManager_ must exist at all times. But without this check
     // AnimatedProps-itest.js fails.
-    nodesManager_->scheduleOnUI([this,
-                                 preOperations = std::move(preOperations),
-                                 operations = std::move(operations)]() {
+    nodesManager->scheduleOnUI([this,
+                                preOperations = std::move(preOperations),
+                                operations = std::move(operations),
+                                nodesManager = nodesManager_]() {
       for (auto& preOperation : preOperations) {
-        executeOperation(preOperation);
+        executeOperation(preOperation, nodesManager);
       }
       for (auto& operation : operations) {
-        executeOperation(operation);
+        executeOperation(operation, nodesManager);
       }
     });
   }
@@ -50,8 +51,8 @@ void AnimatedModule::createAnimatedNode(
   auto configDynamic = dynamicFromValue(rt, jsi::Value(rt, config));
   if (auto it = configDynamic.find("disableBatchingForNativeCreate");
       it != configDynamic.items().end() && it->second == true) {
-    if (nodesManager_) {
-      nodesManager_->createAnimatedNodeAsync(tag, configDynamic);
+    if (auto nodesManager = nodesManager_.lock()) {
+      nodesManager->createAnimatedNodeAsync(tag, configDynamic);
     }
   } else {
     operations_.emplace_back(
@@ -159,6 +160,19 @@ void AnimatedModule::connectAnimatedNodeToView(
       ConnectAnimatedNodeToViewOp{.nodeTag = nodeTag, .viewTag = viewTag});
 }
 
+void AnimatedModule::connectAnimatedNodeToShadowNodeFamily(
+    jsi::Runtime& rt,
+    Tag nodeTag,
+    jsi::Object shadowNodeObj) {
+  const auto& shadowNode = Bridging<std::shared_ptr<const ShadowNode>>::fromJs(
+      rt, jsi::Value(rt, shadowNodeObj));
+
+  operations_.emplace_back(
+      ConnectAnimatedNodeToShadowNodeFamilyOp{
+          .nodeTag = nodeTag,
+          .shadowNodeFamily = shadowNode->getFamilyShared()});
+}
+
 void AnimatedModule::disconnectAnimatedNodeFromView(
     jsi::Runtime& /*rt*/,
     Tag nodeTag,
@@ -220,76 +234,88 @@ void AnimatedModule::queueAndExecuteBatchedOperations(
   // TODO(T225953475): missing implementation
 }
 
-void AnimatedModule::executeOperation(const Operation& operation) {
-  std::visit(
-      [&](const auto& op) {
-        using T = std::decay_t<decltype(op)>;
-
-        if constexpr (std::is_same_v<T, CreateAnimatedNodeOp>) {
-          nodesManager_->createAnimatedNode(op.tag, op.config);
-        } else if constexpr (std::is_same_v<T, GetValueOp>) {
-          auto animValue = nodesManager_->getValue(op.tag);
-          if (animValue) {
-            op.callback.call(animValue.value());
+void AnimatedModule::executeOperation(
+    const Operation& operation,
+    std::weak_ptr<NativeAnimatedNodesManager> nodesManagerWeak) {
+  if (auto nodesManager = nodesManagerWeak.lock()) {
+    std::visit(
+        [&](const auto& op) {
+          using T = std::decay_t<decltype(op)>;
+
+          if constexpr (std::is_same_v<T, CreateAnimatedNodeOp>) {
+            nodesManager->createAnimatedNode(op.tag, op.config);
+          } else if constexpr (std::is_same_v<T, GetValueOp>) {
+            auto animValue = nodesManager->getValue(op.tag);
+            if (animValue) {
+              op.callback.call(animValue.value());
+            }
+          } else if constexpr (std::is_same_v<
+                                   T,
+                                   StartListeningToAnimatedNodeValueOp>) {
+            nodesManager->startListeningToAnimatedNodeValue(
+                op.tag, [this, tag = op.tag](double value) {
+                  emitDeviceEvent(
+                      "onAnimatedValueUpdate",
+                      [tag, value](
+                          jsi::Runtime& rt, std::vector<jsi::Value>& args) {
+                        auto arg = jsi::Object(rt);
+                        arg.setProperty(rt, "tag", jsi::Value(tag));
+                        arg.setProperty(rt, "value", jsi::Value(value));
+                        args.emplace_back(rt, arg);
+                      });
+                });
+          } else if constexpr (std::is_same_v<
+                                   T,
+                                   StopListeningToAnimatedNodeValueOp>) {
+            nodesManager->stopListeningToAnimatedNodeValue(op.tag);
+          } else if constexpr (std::is_same_v<T, ConnectAnimatedNodesOp>) {
+            nodesManager->connectAnimatedNodes(op.parentTag, op.childTag);
+          } else if constexpr (std::is_same_v<T, DisconnectAnimatedNodesOp>) {
+            nodesManager->disconnectAnimatedNodes(op.parentTag, op.childTag);
+          } else if constexpr (std::is_same_v<T, StartAnimatingNodeOp>) {
+            nodesManager->startAnimatingNode(
+                op.animationId,
+                op.nodeTag,
+                std::move(op.config),
+                std::move(op.endCallback));
+          } else if constexpr (std::is_same_v<T, StopAnimationOp>) {
+            nodesManager->stopAnimation(op.animationId, false);
+          } else if constexpr (std::is_same_v<T, SetAnimatedNodeValueOp>) {
+            nodesManager->setAnimatedNodeValue(op.nodeTag, op.value);
+          } else if constexpr (std::is_same_v<T, SetAnimatedNodeOffsetOp>) {
+            nodesManager->setAnimatedNodeOffset(op.nodeTag, op.offset);
+          } else if constexpr (std::is_same_v<T, FlattenAnimatedNodeOffsetOp>) {
+            nodesManager->flattenAnimatedNodeOffset(op.nodeTag);
+          } else if constexpr (std::is_same_v<T, ExtractAnimatedNodeOffsetOp>) {
+            nodesManager->extractAnimatedNodeOffsetOp(op.nodeTag);
+          } else if constexpr (std::is_same_v<T, ConnectAnimatedNodeToViewOp>) {
+            nodesManager->connectAnimatedNodeToView(op.nodeTag, op.viewTag);
+          } else if constexpr (std::is_same_v<
+                                   T,
+                                   DisconnectAnimatedNodeFromViewOp>) {
+            nodesManager->disconnectAnimatedNodeFromView(
+                op.nodeTag, op.viewTag);
+          } else if constexpr (std::is_same_v<
+                                   T,
+                                   ConnectAnimatedNodeToShadowNodeFamilyOp>) {
+            nodesManager->connectAnimatedNodeToShadowNodeFamily(
+                op.nodeTag, op.shadowNodeFamily);
+          } else if constexpr (std::is_same_v<T, RestoreDefaultValuesOp>) {
+            nodesManager->restoreDefaultValues(op.nodeTag);
+          } else if constexpr (std::is_same_v<T, DropAnimatedNodeOp>) {
+            nodesManager->dropAnimatedNode(op.tag);
+          } else if constexpr (std::is_same_v<T, AddAnimatedEventToViewOp>) {
+            nodesManager->addAnimatedEventToView(
+                op.viewTag, op.eventName, op.eventMapping);
+          } else if constexpr (std::is_same_v<
+                                   T,
+                                   RemoveAnimatedEventFromViewOp>) {
+            nodesManager->removeAnimatedEventFromView(
+                op.viewTag, op.eventName, op.animatedNodeTag);
           }
-        } else if constexpr (std::is_same_v<
-                                 T,
-                                 StartListeningToAnimatedNodeValueOp>) {
-          nodesManager_->startListeningToAnimatedNodeValue(
-              op.tag, [this, tag = op.tag](double value) {
-                emitDeviceEvent(
-                    "onAnimatedValueUpdate",
-                    [tag, value](
-                        jsi::Runtime& rt, std::vector<jsi::Value>& args) {
-                      auto arg = jsi::Object(rt);
-                      arg.setProperty(rt, "tag", jsi::Value(tag));
-                      arg.setProperty(rt, "value", jsi::Value(value));
-                      args.emplace_back(rt, arg);
-                    });
-              });
-        } else if constexpr (std::is_same_v<
-                                 T,
-                                 StopListeningToAnimatedNodeValueOp>) {
-          nodesManager_->stopListeningToAnimatedNodeValue(op.tag);
-        } else if constexpr (std::is_same_v<T, ConnectAnimatedNodesOp>) {
-          nodesManager_->connectAnimatedNodes(op.parentTag, op.childTag);
-        } else if constexpr (std::is_same_v<T, DisconnectAnimatedNodesOp>) {
-          nodesManager_->disconnectAnimatedNodes(op.parentTag, op.childTag);
-        } else if constexpr (std::is_same_v<T, StartAnimatingNodeOp>) {
-          nodesManager_->startAnimatingNode(
-              op.animationId,
-              op.nodeTag,
-              std::move(op.config),
-              std::move(op.endCallback));
-        } else if constexpr (std::is_same_v<T, StopAnimationOp>) {
-          nodesManager_->stopAnimation(op.animationId, false);
-        } else if constexpr (std::is_same_v<T, SetAnimatedNodeValueOp>) {
-          nodesManager_->setAnimatedNodeValue(op.nodeTag, op.value);
-        } else if constexpr (std::is_same_v<T, SetAnimatedNodeOffsetOp>) {
-          nodesManager_->setAnimatedNodeOffset(op.nodeTag, op.offset);
-        } else if constexpr (std::is_same_v<T, FlattenAnimatedNodeOffsetOp>) {
-          nodesManager_->flattenAnimatedNodeOffset(op.nodeTag);
-        } else if constexpr (std::is_same_v<T, ExtractAnimatedNodeOffsetOp>) {
-          nodesManager_->extractAnimatedNodeOffsetOp(op.nodeTag);
-        } else if constexpr (std::is_same_v<T, ConnectAnimatedNodeToViewOp>) {
-          nodesManager_->connectAnimatedNodeToView(op.nodeTag, op.viewTag);
-        } else if constexpr (std::is_same_v<
-                                 T,
-                                 DisconnectAnimatedNodeFromViewOp>) {
-          nodesManager_->disconnectAnimatedNodeFromView(op.nodeTag, op.viewTag);
-        } else if constexpr (std::is_same_v<T, RestoreDefaultValuesOp>) {
-          nodesManager_->restoreDefaultValues(op.nodeTag);
-        } else if constexpr (std::is_same_v<T, DropAnimatedNodeOp>) {
-          nodesManager_->dropAnimatedNode(op.tag);
-        } else if constexpr (std::is_same_v<T, AddAnimatedEventToViewOp>) {
-          nodesManager_->addAnimatedEventToView(
-              op.viewTag, op.eventName, op.eventMapping);
-        } else if constexpr (std::is_same_v<T, RemoveAnimatedEventFromViewOp>) {
-          nodesManager_->removeAnimatedEventFromView(
-              op.viewTag, op.eventName, op.animatedNodeTag);
-        }
-      },
-      operation);
+        },
+        operation);
+  }
 }
 
 void AnimatedModule::installJSIBindingsWithRuntime(jsi::Runtime& runtime) {

package/ReactCommon/react/renderer/animated/AnimatedModule.h

@@ -87,6 +87,11 @@ class AnimatedModule : public NativeAnimatedModuleCxxSpec<AnimatedModule>, publi
     Tag viewTag{};
   };
 
+  struct ConnectAnimatedNodeToShadowNodeFamilyOp {
+    Tag nodeTag{};
+    std::shared_ptr<const ShadowNodeFamily> shadowNodeFamily{};
+  };
+
   struct DisconnectAnimatedNodeFromViewOp {
     Tag nodeTag{};
     Tag viewTag{};
@@ -124,6 +129,7 @@ class AnimatedModule : public NativeAnimatedModuleCxxSpec<AnimatedModule>, publi
       SetAnimatedNodeOffsetOp,
       SetAnimatedNodeValueOp,
       ConnectAnimatedNodeToViewOp,
+      ConnectAnimatedNodeToShadowNodeFamilyOp,
       DisconnectAnimatedNodeFromViewOp,
       RestoreDefaultValuesOp,
       FlattenAnimatedNodeOffsetOp,
@@ -176,6 +182,8 @@ class AnimatedModule : public NativeAnimatedModuleCxxSpec<AnimatedModule>, publi
 
   void connectAnimatedNodeToView(jsi::Runtime &rt, Tag nodeTag, Tag viewTag);
 
+  void connectAnimatedNodeToShadowNodeFamily(jsi::Runtime &rt, Tag nodeTag, jsi::Object shadowNode);
+
   void disconnectAnimatedNodeFromView(jsi::Runtime &rt, Tag nodeTag, Tag viewTag);
 
   void restoreDefaultValues(jsi::Runtime &rt, Tag nodeTag);
@@ -194,11 +202,11 @@ class AnimatedModule : public NativeAnimatedModuleCxxSpec<AnimatedModule>, publi
 
  private:
   std::shared_ptr<NativeAnimatedNodesManagerProvider> nodesManagerProvider_;
-  std::shared_ptr<NativeAnimatedNodesManager> nodesManager_;
+  std::weak_ptr<NativeAnimatedNodesManager> nodesManager_;
   std::vector<Operation> preOperations_;
   std::vector<Operation> operations_;
 
-  void executeOperation(const Operation &operation);
+  void executeOperation(const Operation &operation, std::weak_ptr<NativeAnimatedNodesManager> nodesManagerWeak);
   void installJSIBindingsWithRuntime(jsi::Runtime &runtime) override;
 };