react-native 0.0.0-201c10733 → 0.0.0-268efb102

package/ReactCommon/react/nativemodule/core/platform/android/ReactCommon/JavaTurboModule.cpp

@@ -15,6 +15,7 @@
 #include <ReactCommon/TurboModule.h>
 #include <ReactCommon/TurboModulePerfLogger.h>
 #include <jsi/JSIDynamic.h>
+#include <react/debug/react_native_assert.h>
 #include <react/jni/NativeMap.h>
 #include <react/jni/ReadableNativeMap.h>
 #include <react/jni/WritableNativeMap.h>
@@ -29,7 +30,8 @@ namespace react {
 JavaTurboModule::JavaTurboModule(const InitParams &params)
     : TurboModule(params.moduleName, params.jsInvoker),
       instance_(jni::make_global(params.instance)),
-      nativeInvoker_(params.nativeInvoker) {}
+      nativeInvoker_(params.nativeInvoker),
+      retainJSCallback_(params.retainJSCallback) {}
 
 JavaTurboModule::~JavaTurboModule() {
   /**
@@ -53,15 +55,26 @@ JavaTurboModule::~JavaTurboModule() {
 
 namespace {
 jni::local_ref<JCxxCallbackImpl::JavaPart> createJavaCallbackFromJSIFunction(
+    JSCallbackRetainer retainJSCallback,
     jsi::Function &&function,
     jsi::Runtime &rt,
     std::shared_ptr<CallInvoker> jsInvoker) {
-  auto weakWrapper =
-      react::CallbackWrapper::createWeak(std::move(function), rt, jsInvoker);
+  auto weakWrapper = retainJSCallback != nullptr
+      ? retainJSCallback(std::move(function), rt, jsInvoker)
+      : react::CallbackWrapper::createWeak(std::move(function), rt, jsInvoker);
+
+  // This needs to be a shared_ptr because:
+  // 1. It cannot be unique_ptr. std::function is copyable but unique_ptr is
+  // not.
+  // 2. It cannot be weak_ptr since we need this object to live on.
+  // 3. It cannot be a value, because that would be deleted as soon as this
+  // function returns.
+  auto callbackWrapperOwner =
+      std::make_shared<RAIICallbackWrapperDestroyer>(weakWrapper);
 
   std::function<void(folly::dynamic)> fn =
-      [weakWrapper,
-       wrapperWasCalled = false](folly::dynamic responses) mutable {
+      [weakWrapper, callbackWrapperOwner, wrapperWasCalled = false](
+          folly::dynamic responses) mutable {
         if (wrapperWasCalled) {
           throw std::runtime_error(
               "callback 2 arg cannot be called more than once");
@@ -72,35 +85,37 @@ jni::local_ref<JCxxCallbackImpl::JavaPart> createJavaCallbackFromJSIFunction(
           return;
         }
 
-        strongWrapper->jsInvoker().invokeAsync([weakWrapper, responses]() {
-          auto strongWrapper2 = weakWrapper.lock();
-          if (!strongWrapper2) {
-            return;
-          }
-
-          // TODO (T43155926) valueFromDynamic already returns a Value array.
-          // Don't iterate again
-          jsi::Value args =
-              jsi::valueFromDynamic(strongWrapper2->runtime(), responses);
-          auto argsArray = args.getObject(strongWrapper2->runtime())
-                               .asArray(strongWrapper2->runtime());
-          std::vector<jsi::Value> result;
-          for (size_t i = 0; i < argsArray.size(strongWrapper2->runtime());
-               i++) {
-            result.emplace_back(
-                strongWrapper2->runtime(),
-                argsArray.getValueAtIndex(strongWrapper2->runtime(), i));
-          }
-          strongWrapper2->callback().call(
-              strongWrapper2->runtime(),
-              (const jsi::Value *)result.data(),
-              result.size());
-
-          strongWrapper2->destroy();
-        });
+        strongWrapper->jsInvoker().invokeAsync(
+            [weakWrapper, callbackWrapperOwner, responses]() mutable {
+              auto strongWrapper2 = weakWrapper.lock();
+              if (!strongWrapper2) {
+                return;
+              }
+
+              // TODO (T43155926) valueFromDynamic already returns a Value
+              // array. Don't iterate again
+              jsi::Value args =
+                  jsi::valueFromDynamic(strongWrapper2->runtime(), responses);
+              auto argsArray = args.getObject(strongWrapper2->runtime())
+                                   .asArray(strongWrapper2->runtime());
+              std::vector<jsi::Value> result;
+              for (size_t i = 0; i < argsArray.size(strongWrapper2->runtime());
+                   i++) {
+                result.emplace_back(
+                    strongWrapper2->runtime(),
+                    argsArray.getValueAtIndex(strongWrapper2->runtime(), i));
+              }
+              strongWrapper2->callback().call(
+                  strongWrapper2->runtime(),
+                  (const jsi::Value *)result.data(),
+                  result.size());
+
+              callbackWrapperOwner.reset();
+            });
 
         wrapperWasCalled = true;
       };
+
   return JCxxCallbackImpl::newObjectCxxArgs(fn);
 }
 
@@ -133,7 +148,7 @@ std::string stringifyJSIValue(const jsi::Value &v, jsi::Runtime *rt = nullptr) {
     return "a string (\"" + v.getString(*rt).utf8(*rt) + "\")";
   }
 
-  assert(v.isObject() && "Expecting object.");
+  react_native_assert(v.isObject() && "Expecting object.");
   return rt != nullptr && v.getObject(*rt).isFunction(*rt) ? "a function"
                                                            : "an object";
 }
@@ -239,7 +254,8 @@ JNIArgs JavaTurboModule::convertJSIArgsToJNIArgs(
     const jsi::Value *args,
     size_t count,
     std::shared_ptr<CallInvoker> jsInvoker,
-    TurboModuleMethodValueKind valueKind) {
+    TurboModuleMethodValueKind valueKind,
+    JSCallbackRetainer retainJSCallback) {
   unsigned int expectedArgumentCount = valueKind == PromiseKind
       ? methodArgTypes.size() - 1
       : methodArgTypes.size();
@@ -374,7 +390,8 @@ JNIArgs JavaTurboModule::convertJSIArgsToJNIArgs(
 
       jsi::Function fn = arg->getObject(rt).getFunction(rt);
       jarg->l = makeGlobalIfNecessary(
-          createJavaCallbackFromJSIFunction(std::move(fn), rt, jsInvoker)
+          createJavaCallbackFromJSIFunction(
+              retainJSCallback, std::move(fn), rt, jsInvoker)
               .release());
       continue;
     }
@@ -521,7 +538,8 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
       args,
       argCount,
       jsInvoker_,
-      valueKind);
+      valueKind,
+      retainJSCallback_);
 
   if (isMethodSync && valueKind != PromiseKind) {
     TMPL::syncMethodCallArgConversionEnd(moduleName, methodName);
@@ -682,10 +700,14 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
           [jargs,
            globalRefs,
            methodID,
-           instance_ = instance_,
+           instance_ = jni::make_weak(instance_),
            moduleNameStr = name_,
            methodNameStr,
            id = getUniqueId()]() mutable -> void {
+            auto instance = instance_.lockLocal();
+            if (!instance) {
+              return;
+            }
             /**
              * TODO(ramanpreet): Why do we have to require the environment
              * again? Why does JNI crash when we use the env from the upper
@@ -696,7 +718,7 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
             const char *methodName = methodNameStr.c_str();
 
             TMPL::asyncMethodCallExecutionStart(moduleName, methodName, id);
-            env->CallVoidMethodA(instance_.get(), methodID, jargs.data());
+            env->CallVoidMethodA(instance.get(), methodID, jargs.data());
             try {
               FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
             } catch (...) {
@@ -728,7 +750,8 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
            methodID,
            moduleNameStr = name_,
            methodNameStr,
-           env](
+           env,
+           retainJSCallback = retainJSCallback_](
               jsi::Runtime &runtime,
               const jsi::Value &thisVal,
               const jsi::Value *promiseConstructorArgs,
@@ -745,10 +768,16 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
                     runtime);
 
             auto resolve = createJavaCallbackFromJSIFunction(
-                               std::move(resolveJSIFn), runtime, jsInvoker_)
+                               retainJSCallback,
+                               std::move(resolveJSIFn),
+                               runtime,
+                               jsInvoker_)
                                .release();
             auto reject = createJavaCallbackFromJSIFunction(
-                              std::move(rejectJSIFn), runtime, jsInvoker_)
+                              retainJSCallback,
+                              std::move(rejectJSIFn),
+                              runtime,
+                              jsInvoker_)
                               .release();
 
             jclass jPromiseImpl =
@@ -777,10 +806,15 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
                 [jargs,
                  globalRefs,
                  methodID,
-                 instance_ = instance_,
+                 instance_ = jni::make_weak(instance_),
                  moduleNameStr,
                  methodNameStr,
                  id = getUniqueId()]() mutable -> void {
+                  auto instance = instance_.lockLocal();
+
+                  if (!instance) {
+                    return;
+                  }
                   /**
                    * TODO(ramanpreet): Why do we have to require the
                    * environment again? Why does JNI crash when we use the env
@@ -792,7 +826,7 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
 
                   TMPL::asyncMethodCallExecutionStart(
                       moduleName, methodName, id);
-                  env->CallVoidMethodA(instance_.get(), methodID, jargs.data());
+                  env->CallVoidMethodA(instance.get(), methodID, jargs.data());
                   try {
                     FACEBOOK_JNI_THROW_PENDING_EXCEPTION();
                   } catch (...) {

package/ReactCommon/react/nativemodule/core/platform/android/ReactCommon/JavaTurboModule.h

@@ -7,9 +7,11 @@
 
 #pragma once
 
+#include <functional>
 #include <string>
 #include <unordered_set>
 
+#include <ReactCommon/LongLivedObject.h>
 #include <ReactCommon/TurboModule.h>
 #include <ReactCommon/TurboModuleUtils.h>
 #include <fbjni/fbjni.h>
@@ -30,6 +32,11 @@ struct JTurboModule : jni::JavaClass<JTurboModule> {
       "Lcom/facebook/react/turbomodule/core/interfaces/TurboModule;";
 };
 
+using JSCallbackRetainer = std::function<std::weak_ptr<CallbackWrapper>(
+    jsi::Function &&callback,
+    jsi::Runtime &runtime,
+    std::shared_ptr<CallInvoker> jsInvoker)>;
+
 class JSI_EXPORT JavaTurboModule : public TurboModule {
  public:
   // TODO(T65603471): Should we unify this with a Fabric abstraction?
@@ -38,6 +45,7 @@ class JSI_EXPORT JavaTurboModule : public TurboModule {
     jni::alias_ref<JTurboModule> instance;
     std::shared_ptr<CallInvoker> jsInvoker;
     std::shared_ptr<CallInvoker> nativeInvoker;
+    JSCallbackRetainer retainJSCallback;
   };
 
   JavaTurboModule(const InitParams &params);
@@ -54,6 +62,7 @@ class JSI_EXPORT JavaTurboModule : public TurboModule {
  private:
   jni::global_ref<JTurboModule> instance_;
   std::shared_ptr<CallInvoker> nativeInvoker_;
+  JSCallbackRetainer retainJSCallback_;
 
   JNIArgs convertJSIArgsToJNIArgs(
       JNIEnv *env,
@@ -63,7 +72,8 @@ class JSI_EXPORT JavaTurboModule : public TurboModule {
       const jsi::Value *args,
       size_t count,
       std::shared_ptr<CallInvoker> jsInvoker,
-      TurboModuleMethodValueKind valueKind);
+      TurboModuleMethodValueKind valueKind,
+      JSCallbackRetainer retainJSCallbacks);
 };
 
 } // namespace react

package/ReactCommon/react/nativemodule/core/platform/ios/RCTBlockGuard.h

@@ -0,0 +1,24 @@
+/*
+ * 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.
+ */
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/**
+ * RCTBlockGuard is designed to be used with obj-c blocks to assist with manual deallocation of C++ resources
+ * tied to lifetime of a block. If C++ resources needs to be manually released at the end of block or when the block
+ * is deallocated, place the clean up code inside constructor and make sure the instace of the class is references in
+ * the block.
+ */
+@interface RCTBlockGuard : NSObject
+
+- (instancetype)initWithCleanup:(void (^)(void))cleanup;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ReactCommon/react/nativemodule/core/platform/ios/RCTBlockGuard.mm

@@ -0,0 +1,28 @@
+/*
+ * 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.
+ */
+
+#import "RCTBlockGuard.h"
+
+@implementation RCTBlockGuard {
+  void (^_cleanup)(void);
+}
+
+- (instancetype)initWithCleanup:(void (^)(void))cleanup
+{
+  if (self = [super init]) {
+    _cleanup = cleanup;
+  }
+
+  return self;
+}
+
+- (void)dealloc
+{
+  _cleanup();
+}
+
+@end

package/ReactCommon/react/nativemodule/core/platform/ios/RCTTurboModule.h

@@ -29,6 +29,9 @@ namespace react {
 
 class Instance;
 
+typedef std::weak_ptr<CallbackWrapper> (
+    ^RCTRetainJSCallback)(jsi::Function &&callback, jsi::Runtime &runtime, std::shared_ptr<CallInvoker> jsInvoker);
+
 /**
  * ObjC++ specific TurboModule base class.
  */
@@ -41,6 +44,7 @@ class JSI_EXPORT ObjCTurboModule : public TurboModule {
     std::shared_ptr<CallInvoker> jsInvoker;
     std::shared_ptr<CallInvoker> nativeInvoker;
     bool isSyncModule;
+    RCTRetainJSCallback retainJSCallback;
   };
 
   ObjCTurboModule(const InitParams &params);
@@ -63,6 +67,8 @@ class JSI_EXPORT ObjCTurboModule : public TurboModule {
   // Does the NativeModule dispatch async methods to the JS thread?
   const bool isSyncModule_;
 
+  RCTRetainJSCallback retainJSCallback_;
+
   /**
    * TODO(ramanpreet):
    * Investigate an optimization that'll let us get rid of this NSMutableDictionary.
@@ -90,30 +96,15 @@ class JSI_EXPORT ObjCTurboModule : public TurboModule {
       NSMutableArray *retainedObjectsForInvocation);
 
   using PromiseInvocationBlock = void (^)(RCTPromiseResolveBlock resolveWrapper, RCTPromiseRejectBlock rejectWrapper);
-  jsi::Value createPromise(
-      jsi::Runtime &runtime,
-      std::shared_ptr<react::CallInvoker> jsInvoker,
-      std::string methodName,
-      PromiseInvocationBlock invoke);
+  jsi::Value createPromise(jsi::Runtime &runtime, std::string methodName, PromiseInvocationBlock invoke);
 };
 
 } // namespace react
 } // namespace facebook
 
 @protocol RCTTurboModule <NSObject>
-@optional
-/**
- * Used by TurboModules to get access to other TurboModules.
- *
- * Usage:
- * Place `@synthesize turboModuleRegistry = _turboModuleRegistry`
- * in the @implementation section of your TurboModule.
- */
-@property (nonatomic, weak) id<RCTTurboModuleRegistry> turboModuleRegistry;
-
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
     (const facebook::react::ObjCTurboModule::InitParams &)params;
-
 @end
 
 /**

package/ReactCommon/react/nativemodule/core/platform/ios/RCTTurboModule.mm

@@ -6,10 +6,12 @@
  */
 
 #import "RCTTurboModule.h"
+#import "RCTBlockGuard.h"
 
 #import <objc/message.h>
 #import <objc/runtime.h>
 #import <atomic>
+#import <iostream>
 #import <sstream>
 #import <vector>
 
@@ -98,28 +100,38 @@ static jsi::Value convertObjCObjectToJSIValue(jsi::Runtime &runtime, id value)
   return jsi::Value::undefined();
 }
 
-static id
-convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, std::shared_ptr<CallInvoker> jsInvoker);
+static id convertJSIValueToObjCObject(
+    jsi::Runtime &runtime,
+    const jsi::Value &value,
+    std::shared_ptr<CallInvoker> jsInvoker,
+    RCTRetainJSCallback retainJSCallback);
 static NSString *convertJSIStringToNSString(jsi::Runtime &runtime, const jsi::String &value)
 {
   return [NSString stringWithUTF8String:value.utf8(runtime).c_str()];
 }
 
-static NSArray *
-convertJSIArrayToNSArray(jsi::Runtime &runtime, const jsi::Array &value, std::shared_ptr<CallInvoker> jsInvoker)
+static NSArray *convertJSIArrayToNSArray(
+    jsi::Runtime &runtime,
+    const jsi::Array &value,
+    std::shared_ptr<CallInvoker> jsInvoker,
+    RCTRetainJSCallback retainJSCallback)
 {
   size_t size = value.size(runtime);
   NSMutableArray *result = [NSMutableArray new];
   for (size_t i = 0; i < size; i++) {
     // Insert kCFNull when it's `undefined` value to preserve the indices.
     [result
-        addObject:convertJSIValueToObjCObject(runtime, value.getValueAtIndex(runtime, i), jsInvoker) ?: (id)kCFNull];
+        addObject:convertJSIValueToObjCObject(runtime, value.getValueAtIndex(runtime, i), jsInvoker, retainJSCallback)
+            ?: (id)kCFNull];
   }
   return [result copy];
 }
 
-static NSDictionary *
-convertJSIObjectToNSDictionary(jsi::Runtime &runtime, const jsi::Object &value, std::shared_ptr<CallInvoker> jsInvoker)
+static NSDictionary *convertJSIObjectToNSDictionary(
+    jsi::Runtime &runtime,
+    const jsi::Object &value,
+    std::shared_ptr<CallInvoker> jsInvoker,
+    RCTRetainJSCallback retainJSCallback)
 {
   jsi::Array propertyNames = value.getPropertyNames(runtime);
   size_t size = propertyNames.size(runtime);
@@ -127,7 +139,7 @@ convertJSIObjectToNSDictionary(jsi::Runtime &runtime, const jsi::Object &value,
   for (size_t i = 0; i < size; i++) {
     jsi::String name = propertyNames.getValueAtIndex(runtime, i).getString(runtime);
     NSString *k = convertJSIStringToNSString(runtime, name);
-    id v = convertJSIValueToObjCObject(runtime, value.getProperty(runtime, name), jsInvoker);
+    id v = convertJSIValueToObjCObject(runtime, value.getProperty(runtime, name), jsInvoker, retainJSCallback);
     if (v) {
       result[k] = v;
     }
@@ -135,10 +147,16 @@ convertJSIObjectToNSDictionary(jsi::Runtime &runtime, const jsi::Object &value,
   return [result copy];
 }
 
-static RCTResponseSenderBlock
-convertJSIFunctionToCallback(jsi::Runtime &runtime, const jsi::Function &value, std::shared_ptr<CallInvoker> jsInvoker);
-static id
-convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, std::shared_ptr<CallInvoker> jsInvoker)
+static RCTResponseSenderBlock convertJSIFunctionToCallback(
+    jsi::Runtime &runtime,
+    const jsi::Function &value,
+    std::shared_ptr<CallInvoker> jsInvoker,
+    RCTRetainJSCallback retainJSCallback);
+static id convertJSIValueToObjCObject(
+    jsi::Runtime &runtime,
+    const jsi::Value &value,
+    std::shared_ptr<CallInvoker> jsInvoker,
+    RCTRetainJSCallback retainJSCallback)
 {
   if (value.isUndefined() || value.isNull()) {
     return nil;
@@ -155,21 +173,33 @@ convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value, std:
   if (value.isObject()) {
     jsi::Object o = value.getObject(runtime);
     if (o.isArray(runtime)) {
-      return convertJSIArrayToNSArray(runtime, o.getArray(runtime), jsInvoker);
+      return convertJSIArrayToNSArray(runtime, o.getArray(runtime), jsInvoker, retainJSCallback);
     }
     if (o.isFunction(runtime)) {
-      return convertJSIFunctionToCallback(runtime, std::move(o.getFunction(runtime)), jsInvoker);
+      return convertJSIFunctionToCallback(runtime, std::move(o.getFunction(runtime)), jsInvoker, retainJSCallback);
     }
-    return convertJSIObjectToNSDictionary(runtime, o, jsInvoker);
+    return convertJSIObjectToNSDictionary(runtime, o, jsInvoker, retainJSCallback);
   }
 
   throw std::runtime_error("Unsupported jsi::jsi::Value kind");
 }
 
-static RCTResponseSenderBlock
-convertJSIFunctionToCallback(jsi::Runtime &runtime, const jsi::Function &value, std::shared_ptr<CallInvoker> jsInvoker)
+static RCTResponseSenderBlock convertJSIFunctionToCallback(
+    jsi::Runtime &runtime,
+    const jsi::Function &value,
+    std::shared_ptr<CallInvoker> jsInvoker,
+    RCTRetainJSCallback retainJSCallback)
 {
-  auto weakWrapper = CallbackWrapper::createWeak(value.getFunction(runtime), runtime, jsInvoker);
+  auto weakWrapper = retainJSCallback != nil
+      ? retainJSCallback(value.getFunction(runtime), runtime, jsInvoker)
+      : CallbackWrapper::createWeak(value.getFunction(runtime), runtime, jsInvoker);
+  RCTBlockGuard *blockGuard = [[RCTBlockGuard alloc] initWithCleanup:^() {
+    auto strongWrapper = weakWrapper.lock();
+    if (strongWrapper) {
+      strongWrapper->destroy();
+    }
+  }];
+
   BOOL __block wrapperWasCalled = NO;
   RCTResponseSenderBlock callback = ^(NSArray *responses) {
     if (wrapperWasCalled) {
@@ -181,7 +211,7 @@ convertJSIFunctionToCallback(jsi::Runtime &runtime, const jsi::Function &value,
       return;
     }
 
-    strongWrapper->jsInvoker().invokeAsync([weakWrapper, responses]() {
+    strongWrapper->jsInvoker().invokeAsync([weakWrapper, responses, blockGuard]() {
       auto strongWrapper2 = weakWrapper.lock();
       if (!strongWrapper2) {
         return;
@@ -190,6 +220,9 @@ convertJSIFunctionToCallback(jsi::Runtime &runtime, const jsi::Function &value,
       std::vector<jsi::Value> args = convertNSArrayToStdVector(strongWrapper2->runtime(), responses);
       strongWrapper2->callback().call(strongWrapper2->runtime(), (const jsi::Value *)args.data(), args.size());
       strongWrapper2->destroy();
+
+      // Delete the CallbackWrapper when the block gets dealloced without being invoked.
+      (void)blockGuard;
     });
 
     wrapperWasCalled = YES;
@@ -201,11 +234,7 @@ convertJSIFunctionToCallback(jsi::Runtime &runtime, const jsi::Function &value,
 namespace facebook {
 namespace react {
 
-jsi::Value ObjCTurboModule::createPromise(
-    jsi::Runtime &runtime,
-    std::shared_ptr<CallInvoker> jsInvoker,
-    std::string methodName,
-    PromiseInvocationBlock invoke)
+jsi::Value ObjCTurboModule::createPromise(jsi::Runtime &runtime, std::string methodName, PromiseInvocationBlock invoke)
 {
   if (!invoke) {
     return jsi::Value::undefined();
@@ -221,7 +250,7 @@ jsi::Value ObjCTurboModule::createPromise(
       runtime,
       jsi::PropNameID::forAscii(runtime, "fn"),
       2,
-      [invokeCopy, jsInvoker, moduleName, methodName](
+      [invokeCopy, jsInvoker = jsInvoker_, moduleName, methodName, retainJSCallback = retainJSCallback_](
           jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args, size_t count) {
         std::string moduleMethod = moduleName + "." + methodName + "()";
 
@@ -234,12 +263,28 @@ jsi::Value ObjCTurboModule::createPromise(
           return jsi::Value::undefined();
         }
 
-        auto weakResolveWrapper = CallbackWrapper::createWeak(args[0].getObject(rt).getFunction(rt), rt, jsInvoker);
-        auto weakRejectWrapper = CallbackWrapper::createWeak(args[1].getObject(rt).getFunction(rt), rt, jsInvoker);
+        auto weakResolveWrapper = retainJSCallback != nil
+            ? retainJSCallback(args[0].getObject(rt).getFunction(rt), rt, jsInvoker)
+            : CallbackWrapper::createWeak(args[0].getObject(rt).getFunction(rt), rt, jsInvoker);
+        auto weakRejectWrapper = retainJSCallback != nil
+            ? retainJSCallback(args[1].getObject(rt).getFunction(rt), rt, jsInvoker)
+            : CallbackWrapper::createWeak(args[1].getObject(rt).getFunction(rt), rt, jsInvoker);
 
         __block BOOL resolveWasCalled = NO;
         __block BOOL rejectWasCalled = NO;
 
+        RCTBlockGuard *blockGuard = [[RCTBlockGuard alloc] initWithCleanup:^() {
+          auto strongResolveWrapper = weakResolveWrapper.lock();
+          if (strongResolveWrapper) {
+            strongResolveWrapper->destroy();
+          }
+
+          auto strongRejectWrapper = weakRejectWrapper.lock();
+          if (strongRejectWrapper) {
+            strongRejectWrapper->destroy();
+          }
+        }];
+
         RCTPromiseResolveBlock resolveBlock = ^(id result) {
           if (rejectWasCalled) {
             RCTLogError(@"%s: Tried to resolve a promise after it's already been rejected.", moduleMethod.c_str());
@@ -257,7 +302,7 @@ jsi::Value ObjCTurboModule::createPromise(
             return;
           }
 
-          strongResolveWrapper->jsInvoker().invokeAsync([weakResolveWrapper, weakRejectWrapper, result]() {
+          strongResolveWrapper->jsInvoker().invokeAsync([weakResolveWrapper, weakRejectWrapper, result, blockGuard]() {
             auto strongResolveWrapper2 = weakResolveWrapper.lock();
             auto strongRejectWrapper2 = weakRejectWrapper.lock();
             if (!strongResolveWrapper2 || !strongRejectWrapper2) {
@@ -270,6 +315,7 @@ jsi::Value ObjCTurboModule::createPromise(
 
             strongResolveWrapper2->destroy();
             strongRejectWrapper2->destroy();
+            (void)blockGuard;
           });
 
           resolveWasCalled = YES;
@@ -293,7 +339,7 @@ jsi::Value ObjCTurboModule::createPromise(
           }
 
           NSDictionary *jsError = RCTJSErrorFromCodeMessageAndNSError(code, message, error);
-          strongRejectWrapper->jsInvoker().invokeAsync([weakResolveWrapper, weakRejectWrapper, jsError]() {
+          strongRejectWrapper->jsInvoker().invokeAsync([weakResolveWrapper, weakRejectWrapper, jsError, blockGuard]() {
             auto strongResolveWrapper2 = weakResolveWrapper.lock();
             auto strongRejectWrapper2 = weakRejectWrapper.lock();
             if (!strongResolveWrapper2 || !strongRejectWrapper2) {
@@ -306,6 +352,7 @@ jsi::Value ObjCTurboModule::createPromise(
 
             strongResolveWrapper2->destroy();
             strongRejectWrapper2->destroy();
+            (void)blockGuard;
           });
 
           rejectWasCalled = YES;
@@ -544,7 +591,7 @@ NSInvocation *ObjCTurboModule::getMethodInvocation(
     /**
      * Convert arg to ObjC objects.
      */
-    id objCArg = convertJSIValueToObjCObject(runtime, *arg, jsInvoker_);
+    id objCArg = convertJSIValueToObjCObject(runtime, *arg, jsInvoker_, retainJSCallback_);
 
     if (objCArg) {
       NSString *methodNameNSString = @(methodName);
@@ -616,7 +663,8 @@ ObjCTurboModule::ObjCTurboModule(const InitParams &params)
     : TurboModule(params.moduleName, params.jsInvoker),
       instance_(params.instance),
       nativeInvoker_(params.nativeInvoker),
-      isSyncModule_(params.isSyncModule)
+      isSyncModule_(params.isSyncModule),
+      retainJSCallback_(params.retainJSCallback)
 {
 }
 
@@ -644,7 +692,6 @@ jsi::Value ObjCTurboModule::invokeObjCMethod(
   jsi::Value returnValue = returnType == PromiseKind
       ? createPromise(
             runtime,
-            jsInvoker_,
             methodNameStr,
             ^(RCTPromiseResolveBlock resolveBlock, RCTPromiseRejectBlock rejectBlock) {
               RCTPromiseResolveBlock resolveCopy = [resolveBlock copy];

package/ReactCommon/react/nativemodule/core/platform/ios/RCTTurboModuleManager.h

@@ -15,16 +15,10 @@
 
 @protocol RCTTurboModuleManagerDelegate <NSObject>
 
-// TODO: Move to xplat codegen.
-- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const std::string &)name
-                                                     initParams:
-                                                         (const facebook::react::ObjCTurboModule::InitParams &)params;
 @optional
 - (NSArray<NSString *> *)getEagerInitModuleNames;
 - (NSArray<NSString *> *)getEagerInitMainQueueModuleNames;
 
-@optional
-
 /**
  * Given a module name, return its actual class. If not provided, basic ObjC class lookup is performed.
  */
@@ -51,7 +45,6 @@
                      jsInvoker:(std::shared_ptr<facebook::react::CallInvoker>)jsInvoker;
 
 - (void)installJSBindingWithRuntimeExecutor:(facebook::react::RuntimeExecutor)runtimeExecutor;
-- (void)setBridgelessComponentViewProvider:(RCTBridgelessComponentViewProvider)bridgelessComponentViewProvider;
 
 - (void)invalidate;