react-native 0.0.0-17be3a003 → 0.0.0-18697adec

package/ReactCommon/jsi/Android.mk

@@ -17,7 +17,7 @@ LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)
 LOCAL_CFLAGS := -fexceptions -frtti -O3
 LOCAL_SHARED_LIBRARIES := libfolly_json glog
 
-include $(BUILD_STATIC_LIBRARY)
+include $(BUILD_SHARED_LIBRARY)
 
 
 include $(CLEAR_VARS)

package/ReactCommon/jsi/BUCK

@@ -1,5 +1,3 @@
-# BUILD FILE SYNTAX: SKYLARK
-
 load("//tools/build_defs/oss:rn_defs.bzl", "APPLE", "IOS", "MACOSX", "react_native_xplat_dep", "rn_xplat_cxx_library")
 
 rn_xplat_cxx_library(

package/ReactCommon/jsi/JSCRuntime.cpp

@@ -50,6 +50,9 @@ class JSCRuntime : public jsi::Runtime {
   jsi::Value evaluateJavaScript(
       const std::shared_ptr<const jsi::Buffer> &buffer,
       const std::string &sourceURL) override;
+
+  bool drainMicrotasks(int maxMicrotasksHint = -1) override;
+
   jsi::Object global() override;
 
   std::string description() override;
@@ -432,6 +435,10 @@ jsi::Value JSCRuntime::evaluateJavaScript(
   return createValue(res);
 }
 
+bool JSCRuntime::drainMicrotasks(int maxMicrotasksHint) {
+  return true;
+}
+
 jsi::Object JSCRuntime::global() {
   return createObject(JSContextGetGlobalObject(ctx_));
 }

package/ReactCommon/jsi/React-jsi.podspec

@@ -17,7 +17,7 @@ else
 end
 
 folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
-folly_version = '2020.01.13.00'
+folly_version = '2021.06.28.00-v2'
 boost_compiler_flags = '-Wno-documentation'
 
 Pod::Spec.new do |s|
@@ -33,11 +33,11 @@ Pod::Spec.new do |s|
   s.exclude_files          = "**/test/*"
   s.framework              = "JavaScriptCore"
   s.compiler_flags         = folly_compiler_flags + ' ' + boost_compiler_flags
-  s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost-for-react-native\" \"$(PODS_ROOT)/RCT-Folly\" \"$(PODS_ROOT)/DoubleConversion\"" }
+  s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\" \"$(PODS_ROOT)/RCT-Folly\" \"$(PODS_ROOT)/DoubleConversion\"" }
   s.header_dir             = "jsi"
   s.default_subspec        = "Default"
 
-  s.dependency "boost-for-react-native", "1.63.0"
+  s.dependency "boost", "1.76.0"
   s.dependency "DoubleConversion"
   s.dependency "RCT-Folly", folly_version
   s.dependency "glog"

package/ReactCommon/jsi/jsi/decorator.h

@@ -126,6 +126,9 @@ class RuntimeDecorator : public Base, private jsi::Instrumentation {
       const std::shared_ptr<const PreparedJavaScript>& js) override {
     return plain().evaluatePreparedJavaScript(js);
   }
+  bool drainMicrotasks(int maxMicrotasksHint) override {
+    return plain().drainMicrotasks(maxMicrotasksHint);
+  }
   Object global() override {
     return plain().global();
   }
@@ -491,6 +494,10 @@ class WithRuntimeDecorator : public RuntimeDecorator<Plain, Base> {
     Around around{with_};
     return RD::evaluatePreparedJavaScript(js);
   }
+  bool drainMicrotasks(int maxMicrotasksHint) override {
+    Around around{with_};
+    return RD::drainMicrotasks(maxMicrotasksHint);
+  }
   Object global() override {
     Around around{with_};
     return RD::global();

package/ReactCommon/jsi/jsi/jsi.h

@@ -185,6 +185,35 @@ class JSI_EXPORT Runtime {
   virtual Value evaluatePreparedJavaScript(
       const std::shared_ptr<const PreparedJavaScript>& js) = 0;
 
+  /// Drain the JavaScript VM internal Microtask (a.k.a. Job in ECMA262) queue.
+  ///
+  /// \param maxMicrotasksHint a hint to tell an implementation that it should
+  /// make a best effort not execute more than the given number. It's default
+  /// to -1 for infinity (unbounded execution).
+  /// \return true if the queue is drained or false if there is more work to do.
+  ///
+  /// When there were exceptions thrown from the execution of microtasks,
+  /// implementations shall discard the exceptional jobs. An implementation may
+  /// \throw a \c JSError object to signal the hosts to handle. In that case, an
+  /// implementation may or may not suspend the draining.
+  ///
+  /// Hosts may call this function again to resume the draining if it was
+  /// suspended due to either exceptions or the \p maxMicrotasksHint bound.
+  /// E.g. a host may repetitively invoke this function until the queue is
+  /// drained to implement the "microtask checkpint" defined in WHATWG HTML
+  /// event loop: https://html.spec.whatwg.org/C#perform-a-microtask-checkpoint.
+  ///
+  /// Note that error propagation is only a concern if a host needs to implement
+  /// `queueMicrotask`, a recent API that allows enqueueing aribitary functions
+  /// (hence may throw) as microtasks. Exceptions from ECMA-262 Promise Jobs are
+  /// handled internally to VMs and are never propagrated to hosts.
+  ///
+  /// This API offers some queue management to hosts at its best effort due to
+  /// different behaviors and limitations imposed by different VMs and APIs. By
+  /// the time this is written, An implementation may swallow exceptions (JSC),
+  /// may not pause (V8), and may not support bounded executions.
+  virtual bool drainMicrotasks(int maxMicrotasksHint = -1) = 0;
+
   /// \return the global object
   virtual Object global() = 0;
 

package/ReactCommon/jsi/jsi/jsilib-posix.cpp

@@ -18,15 +18,6 @@
 
 #include <jsi/jsilib.h>
 
-#if __APPLE__
-#include <mach/vm_statistics.h>
-#define MAP_TAG VM_MAKE_TAG(VM_MEMORY_APPLICATION_SPECIFIC_16)
-#endif // __APPLE__
-
-#ifndef MAP_TAG
-#define MAP_TAG 0
-#endif
-
 namespace facebook {
 namespace jsi {
 
@@ -76,8 +67,7 @@ class ScopedFile {
   }
 
   uint8_t* mmap(size_t size) {
-    void* result =
-        ::mmap(nullptr, size, PROT_READ, MAP_PRIVATE | MAP_TAG, fd_, 0);
+    void* result = ::mmap(nullptr, size, PROT_READ, MAP_PRIVATE, fd_, 0);
     if (result == MAP_FAILED) {
       throwFormattedError(
           "Could not mmap %s: %s", path_.c_str(), strerror(errno));

package/ReactCommon/jsiexecutor/Android.mk

@@ -16,7 +16,7 @@ LOCAL_EXPORT_C_INCLUDES := $(LOCAL_C_INCLUDES)
 
 LOCAL_CFLAGS := -fexceptions -frtti -O3
 
-LOCAL_STATIC_LIBRARIES := libjsi reactnative reactperflogger
-LOCAL_SHARED_LIBRARIES := libfolly_json glog
+LOCAL_STATIC_LIBRARIES := reactnative reactperflogger
+LOCAL_SHARED_LIBRARIES := libfolly_json glog libjsi
 
 include $(BUILD_STATIC_LIBRARY)

package/ReactCommon/jsiexecutor/React-jsiexecutor.podspec

@@ -17,7 +17,7 @@ else
 end
 
 folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
-folly_version = '2020.01.13.00'
+folly_version = '2021.06.28.00-v2'
 boost_compiler_flags = '-Wno-documentation'
 
 Pod::Spec.new do |s|
@@ -31,7 +31,7 @@ Pod::Spec.new do |s|
   s.source                 = source
   s.source_files         = "jsireact/*.{cpp,h}"
   s.compiler_flags         = folly_compiler_flags + ' ' + boost_compiler_flags
-  s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost-for-react-native\" \"$(PODS_ROOT)/RCT-Folly\" \"$(PODS_ROOT)/DoubleConversion\"" }
+  s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\" \"$(PODS_ROOT)/RCT-Folly\" \"$(PODS_ROOT)/DoubleConversion\"" }
   s.header_dir             = "jsireact"
 
   s.dependency "React-cxxreact", version

package/ReactCommon/jsiexecutor/jsireact/JSIExecutor.cpp

@@ -7,6 +7,7 @@
 
 #include "jsireact/JSIExecutor.h"
 
+#include <cxxreact/ErrorUtils.h>
 #include <cxxreact/JSBigString.h>
 #include <cxxreact/ModuleRegistry.h>
 #include <cxxreact/ReactMarker.h>
@@ -204,6 +205,30 @@ void JSIExecutor::registerBundle(
       ReactMarker::REGISTER_JS_SEGMENT_STOP, tag.c_str());
 }
 
+// Looping on \c drainMicrotasks until it completes or hits the retries bound.
+static void performMicrotaskCheckpoint(jsi::Runtime &runtime) {
+  uint8_t retries = 0;
+  // A heuristic number to guard inifinite or absurd numbers of retries.
+  const static unsigned int kRetriesBound = 255;
+
+  while (retries < kRetriesBound) {
+    try {
+      // The default behavior of \c drainMicrotasks is unbounded execution.
+      // We may want to make it bounded in the future.
+      if (runtime.drainMicrotasks()) {
+        break;
+      }
+    } catch (jsi::JSError &error) {
+      handleJSError(runtime, error, true);
+    }
+    retries++;
+  }
+
+  if (retries == kRetriesBound) {
+    throw std::runtime_error("Hits microtasks retries bound.");
+  }
+}
+
 void JSIExecutor::callFunction(
     const std::string &moduleId,
     const std::string &methodId,
@@ -240,6 +265,8 @@ void JSIExecutor::callFunction(
         std::runtime_error("Error calling " + moduleId + "." + methodId));
   }
 
+  performMicrotaskCheckpoint(*runtime_);
+
   callNativeModules(ret, true);
 }
 
@@ -259,6 +286,8 @@ void JSIExecutor::invokeCallback(
         folly::to<std::string>("Error invoking callback ", callbackId)));
   }
 
+  performMicrotaskCheckpoint(*runtime_);
+
   callNativeModules(ret, true);
 }
 
@@ -394,7 +423,9 @@ void JSIExecutor::callNativeModules(const Value &queue, bool isEndOfBatch) {
 void JSIExecutor::flush() {
   SystraceSection s("JSIExecutor::flush");
   if (flushedQueue_) {
-    callNativeModules(flushedQueue_->call(*runtime_), true);
+    Value ret = flushedQueue_->call(*runtime_);
+    performMicrotaskCheckpoint(*runtime_);
+    callNativeModules(ret, true);
     return;
   }
 
@@ -410,7 +441,9 @@ void JSIExecutor::flush() {
     // If calls were made, we bind to the JS bridge methods, and use them to
     // get the pending queue of native calls.
     bindBridge();
-    callNativeModules(flushedQueue_->call(*runtime_), true);
+    Value ret = flushedQueue_->call(*runtime_);
+    performMicrotaskCheckpoint(*runtime_);
+    callNativeModules(ret, true);
   } else if (delegate_) {
     // If we have a delegate, we need to call it; we pass a null list to
     // callNativeModules, since we know there are no native calls, without

package/ReactCommon/logger/Android.mk

@@ -0,0 +1,23 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := logger
+
+LOCAL_SRC_FILES := $(wildcard $(LOCAL_PATH)/*.cpp)
+
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/..
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_C_INCLUDES)
+
+LOCAL_CFLAGS += -fexceptions
+
+LOCAL_SHARED_LIBRARIES := glog
+
+include $(BUILD_SHARED_LIBRARY)
+
+$(call import-module,glog)

package/ReactCommon/logger/BUCK

@@ -0,0 +1,43 @@
+load("@fbsource//tools/build_defs:glob_defs.bzl", "subdir_glob")
+load("@fbsource//tools/build_defs:platform_defs.bzl", "ANDROID", "APPLE", "CXX", "FBCODE", "WINDOWS")
+load("//tools/build_defs/oss:rn_defs.bzl", "rn_xplat_cxx_library")
+
+EXPORTED_HEADERS = [
+    "react_native_log.h",
+]
+
+rn_xplat_cxx_library(
+    name = "logger",
+    srcs = glob(
+        ["*.cpp"],
+    ),
+    headers = subdir_glob(
+        [
+            ("", "*.h"),
+        ],
+        exclude = EXPORTED_HEADERS,
+        prefix = "logger",
+    ),
+    header_namespace = "",
+    exported_headers = subdir_glob(
+        [
+            ("", header)
+            for header in EXPORTED_HEADERS
+        ],
+        prefix = "logger",
+    ),
+    compiler_flags = [
+        "-Wall",
+        "-fexceptions",
+        "-std=c++17",
+    ],
+    fbandroid_preferred_linkage = "shared",
+    labels = ["supermodule:xplat/default/public.react_native.infra"],
+    platforms = (ANDROID, APPLE, CXX, FBCODE, WINDOWS),
+    visibility = [
+        "PUBLIC",
+    ],
+    deps = [
+        "//third-party/glog:glog",
+    ],
+)

package/ReactCommon/logger/React-logger.podspec

@@ -0,0 +1,40 @@
+# coding: utf-8
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "..", "..", "package.json")))
+version = package['version']
+
+source = { :git => 'https://github.com/facebook/react-native.git' }
+if version == '1000.0.0'
+  # This is an unpublished version, use the latest commit hash of the react-native repo, which we’re presumably in.
+  source[:commit] = `git rev-parse HEAD`.strip if system("git rev-parse --git-dir > /dev/null 2>&1")
+else
+  source[:tag] = "v#{version}"
+end
+
+folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
+folly_version = '2021.06.28.00-v2'
+boost_compiler_flags = '-Wno-documentation'
+
+Pod::Spec.new do |s|
+  s.name                   = "React-logger"
+  s.version                = version
+  s.summary                = "-"  # TODO
+  s.homepage               = "https://reactnative.dev/"
+  s.license                = package["license"]
+  s.author                 = "Facebook, Inc. and its affiliates"
+  s.platforms              = { :ios => "11.0", :tvos => "11.0" }
+  s.source                 = source
+  s.source_files           = "*.{cpp,h}"
+  s.exclude_files          = "SampleCxxModule.*"
+  s.compiler_flags         = folly_compiler_flags + ' ' + boost_compiler_flags
+  s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => "" }
+  s.header_dir             = "logger"
+
+  s.dependency "glog"
+end

package/ReactCommon/logger/react_native_log.cpp

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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_native_log.h"
+#include <glog/logging.h>
+
+static reactnativelogfunctype _reactnativelogfunc = NULL;
+
+void set_react_native_logfunc(reactnativelogfunctype newlogfunc) {
+  _reactnativelogfunc = newlogfunc;
+}
+void react_native_log_info(const char *message) {
+  _react_native_log(ReactNativeLogLevelInfo, message);
+}
+void react_native_log_warn(const char *message) {
+  _react_native_log(ReactNativeLogLevelWarning, message);
+}
+void react_native_log_error(const char *message) {
+  _react_native_log(ReactNativeLogLevelError, message);
+}
+void react_native_log_fatal(const char *message) {
+  _react_native_log(ReactNativeLogLevelFatal, message);
+}
+
+void _react_native_log(ReactNativeLogLevel level, const char *message) {
+  if (_reactnativelogfunc == NULL) {
+    _react_native_log_default(level, message);
+  } else {
+    _reactnativelogfunc(level, message);
+  }
+}
+
+void _react_native_log_default(ReactNativeLogLevel level, const char *message) {
+  switch (level) {
+    case ReactNativeLogLevelInfo:
+      LOG(INFO) << message;
+      break;
+    case ReactNativeLogLevelWarning:
+      LOG(WARNING) << message;
+      break;
+    case ReactNativeLogLevelError:
+      LOG(ERROR) << message;
+      break;
+    case ReactNativeLogLevelFatal:
+      LOG(FATAL) << message;
+      break;
+  }
+}

package/ReactCommon/logger/react_native_log.h

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+enum ReactNativeLogLevel {
+  ReactNativeLogLevelInfo = 1,
+  ReactNativeLogLevelWarning = 2,
+  ReactNativeLogLevelError = 3,
+  ReactNativeLogLevelFatal = 4
+};
+
+typedef void (*reactnativelogfunctype)(ReactNativeLogLevel, const char *);
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+void set_react_native_logfunc(reactnativelogfunctype newlogfunc);
+
+void react_native_log_info(const char *text);
+void react_native_log_warn(const char *text);
+void react_native_log_error(const char *text);
+void react_native_log_fatal(const char *text);
+
+void _react_native_log(ReactNativeLogLevel level, const char *text);
+void _react_native_log_default(ReactNativeLogLevel level, const char *text);
+#ifdef __cplusplus
+}
+#endif // __cpusplus

package/ReactCommon/react/nativemodule/core/Android.mk

@@ -15,9 +15,9 @@ LOCAL_SRC_FILES := $(wildcard $(LOCAL_PATH)/ReactCommon/*.cpp) $(wildcard $(LOCA
 
 LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH) $(LOCAL_PATH)/platform/android/
 
-LOCAL_SHARED_LIBRARIES := libfbjni libfolly_json libreactnativejni libreact_debug
+LOCAL_SHARED_LIBRARIES := libfbjni libfolly_json libreactnativejni libreact_debug libjsi
 
-LOCAL_STATIC_LIBRARIES := libjsi libreactperflogger
+LOCAL_STATIC_LIBRARIES :=  libreactperflogger
 
 LOCAL_CFLAGS := \
   -DLOG_TAG=\"ReactNative\"

package/ReactCommon/react/nativemodule/core/ReactCommon/LongLivedObject.cpp

@@ -43,6 +43,7 @@ void LongLivedObjectCollection::clear() const {
 
 // LongLivedObject
 LongLivedObject::LongLivedObject() {}
+LongLivedObject::~LongLivedObject() {}
 
 void LongLivedObject::allowRelease() {
   LongLivedObjectCollection::get().remove(this);

package/ReactCommon/react/nativemodule/core/ReactCommon/LongLivedObject.h

@@ -26,10 +26,11 @@ namespace react {
  */
 class LongLivedObject {
  public:
-  void allowRelease();
+  virtual void allowRelease();
 
  protected:
   LongLivedObject();
+  virtual ~LongLivedObject();
 };
 
 /**
@@ -39,6 +40,7 @@ class LongLivedObjectCollection {
  public:
   static LongLivedObjectCollection &get();
 
+  LongLivedObjectCollection();
   LongLivedObjectCollection(LongLivedObjectCollection const &) = delete;
   void operator=(LongLivedObjectCollection const &) = delete;
 
@@ -47,7 +49,6 @@ class LongLivedObjectCollection {
   void clear() const;
 
  private:
-  LongLivedObjectCollection();
   mutable std::unordered_set<std::shared_ptr<LongLivedObject>> collection_;
   mutable std::mutex collectionMutex_;
 };

package/ReactCommon/react/nativemodule/core/ReactCommon/TurboModuleBinding.cpp

@@ -21,9 +21,19 @@ namespace react {
 /**
  * Public API to install the TurboModule system.
  */
+
 TurboModuleBinding::TurboModuleBinding(
     const TurboModuleProviderFunctionType &&moduleProvider)
-    : moduleProvider_(std::move(moduleProvider)) {}
+    : moduleProvider_(std::move(moduleProvider)),
+      longLivedObjectCollection_(nullptr),
+      disableGlobalLongLivedObjectCollection_(false) {}
+
+TurboModuleBinding::TurboModuleBinding(
+    const TurboModuleProviderFunctionType &&moduleProvider,
+    std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection)
+    : moduleProvider_(std::move(moduleProvider)),
+      longLivedObjectCollection_(longLivedObjectCollection),
+      disableGlobalLongLivedObjectCollection_(true) {}
 
 void TurboModuleBinding::install(
     jsi::Runtime &runtime,
@@ -35,6 +45,9 @@ void TurboModuleBinding::install(
           runtime,
           jsi::PropNameID::forAscii(runtime, "__turboModuleProxy"),
           1,
+
+          // Create a TurboModuleBinding that uses the global
+          // LongLivedObjectCollection
           [binding =
                std::make_shared<TurboModuleBinding>(std::move(moduleProvider))](
               jsi::Runtime &rt,
@@ -45,7 +58,39 @@ void TurboModuleBinding::install(
           }));
 }
 
+void TurboModuleBinding::install(
+    jsi::Runtime &runtime,
+    const TurboModuleProviderFunctionType &&moduleProvider,
+    std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection) {
+  runtime.global().setProperty(
+      runtime,
+      "__turboModuleProxy",
+      jsi::Function::createFromHostFunction(
+          runtime,
+          jsi::PropNameID::forAscii(runtime, "__turboModuleProxy"),
+          1,
+          // Create a TurboModuleBinding that doesn't use the global
+          // LongLivedObjectCollection
+          [binding = std::make_shared<TurboModuleBinding>(
+               std::move(moduleProvider), longLivedObjectCollection)](
+              jsi::Runtime &rt,
+              const jsi::Value &thisVal,
+              const jsi::Value *args,
+              size_t count) {
+            return binding->jsProxy(rt, thisVal, args, count);
+          }));
+}
+
 TurboModuleBinding::~TurboModuleBinding() {
+  if (longLivedObjectCollection_ != nullptr) {
+    longLivedObjectCollection_->clear();
+    return;
+  }
+
+  if (disableGlobalLongLivedObjectCollection_) {
+    return;
+  }
+
   LongLivedObjectCollection::get().clear();
 }
 

package/ReactCommon/react/nativemodule/core/ReactCommon/TurboModuleBinding.h

@@ -9,6 +9,7 @@
 
 #include <string>
 
+#include <ReactCommon/LongLivedObject.h>
 #include <ReactCommon/TurboModule.h>
 #include <jsi/jsi.h>
 
@@ -29,8 +30,15 @@ class TurboModuleBinding {
   static void install(
       jsi::Runtime &runtime,
       const TurboModuleProviderFunctionType &&moduleProvider);
+  static void install(
+      jsi::Runtime &runtime,
+      const TurboModuleProviderFunctionType &&moduleProvider,
+      std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection);
 
   TurboModuleBinding(const TurboModuleProviderFunctionType &&moduleProvider);
+  TurboModuleBinding(
+      const TurboModuleProviderFunctionType &&moduleProvider,
+      std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection);
   virtual ~TurboModuleBinding();
 
   /**
@@ -50,6 +58,8 @@ class TurboModuleBinding {
       size_t count);
 
   TurboModuleProviderFunctionType moduleProvider_;
+  std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection_;
+  bool disableGlobalLongLivedObjectCollection_;
 };
 
 } // namespace react

package/ReactCommon/react/nativemodule/core/ReactCommon/TurboModuleUtils.h

@@ -47,10 +47,25 @@ class CallbackWrapper : public LongLivedObject {
       jsi::Function &&callback,
       jsi::Runtime &runtime,
       std::shared_ptr<CallInvoker> jsInvoker)
-      : callback_(std::move(callback)),
+      : longLivedObjectCollection_(),
+        callback_(std::move(callback)),
         runtime_(runtime),
         jsInvoker_(std::move(jsInvoker)) {}
 
+  CallbackWrapper(
+      std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection,
+      jsi::Function &&callback,
+      jsi::Runtime &runtime,
+      std::shared_ptr<CallInvoker> jsInvoker)
+      : longLivedObjectCollection_(longLivedObjectCollection),
+        callback_(std::move(callback)),
+        runtime_(runtime),
+        jsInvoker_(std::move(jsInvoker)) {}
+
+  // Use a weak_ptr to avoid a retain cycle: LongLivedObjectCollection owns all
+  // CallbackWrappers. So, CallbackWrapper cannot own its
+  // LongLivedObjectCollection.
+  std::weak_ptr<LongLivedObjectCollection> longLivedObjectCollection_;
   jsi::Function callback_;
   jsi::Runtime &runtime_;
   std::shared_ptr<CallInvoker> jsInvoker_;
@@ -66,6 +81,17 @@ class CallbackWrapper : public LongLivedObject {
     return wrapper;
   }
 
+  static std::weak_ptr<CallbackWrapper> createWeak(
+      std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection,
+      jsi::Function &&callback,
+      jsi::Runtime &runtime,
+      std::shared_ptr<CallInvoker> jsInvoker) {
+    auto wrapper = std::shared_ptr<CallbackWrapper>(new CallbackWrapper(
+        longLivedObjectCollection, std::move(callback), runtime, jsInvoker));
+    longLivedObjectCollection->add(wrapper);
+    return wrapper;
+  }
+
   // Delete the enclosed jsi::Function
   void destroy() {
     allowRelease();
@@ -82,6 +108,16 @@ class CallbackWrapper : public LongLivedObject {
   CallInvoker &jsInvoker() {
     return *(jsInvoker_);
   }
+
+  void allowRelease() override {
+    if (auto longLivedObjectCollection = longLivedObjectCollection_.lock()) {
+      if (longLivedObjectCollection != nullptr) {
+        longLivedObjectCollection->remove(this);
+        return;
+      }
+    }
+    LongLivedObject::allowRelease();
+  }
 };
 
 class RAIICallbackWrapperDestroyer {