react-native 0.71.6 → 0.72.0-rc.1

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

@@ -15,11 +15,11 @@ TurboModule::TurboModule(
     std::shared_ptr<CallInvoker> jsInvoker)
     : name_(std::move(name)), jsInvoker_(std::move(jsInvoker)) {}
 
-jsi::Value TurboModule::get(
+jsi::Value TurboModule::createHostFunction(
     jsi::Runtime &runtime,
     const jsi::PropNameID &propName,
     const MethodMetadata &meta) {
-  auto result = jsi::Function::createFromHostFunction(
+  return jsi::Function::createFromHostFunction(
       runtime,
       propName,
       static_cast<unsigned int>(meta.argCount),
@@ -28,12 +28,30 @@ jsi::Value TurboModule::get(
           const jsi::Value &thisVal,
           const jsi::Value *args,
           size_t count) { return meta.invoker(rt, *this, args, count); });
-  // If we have a JS wrapper, cache the result of this lookup
-  // We don't cache misses, to allow for methodMap_ to dynamically be extended
-  if (jsRepresentation_) {
-    jsRepresentation_->setProperty(runtime, propName, result);
-  }
-  return result;
+}
+
+void TurboModule::emitDeviceEvent(
+    jsi::Runtime &runtime,
+    const std::string &eventName,
+    ArgFactory argFactory) {
+  jsInvoker_->invokeAsync([&runtime, eventName, argFactory]() {
+    jsi::Value emitter =
+        runtime.global().getProperty(runtime, "__rctDeviceEventEmitter");
+    if (!emitter.isUndefined()) {
+      jsi::Object emitterObject = emitter.asObject(runtime);
+      // TODO: consider caching these
+      jsi::Function emitFunction =
+          emitterObject.getPropertyAsFunction(runtime, "emit");
+      std::vector<jsi::Value> args;
+      args.emplace_back(
+          jsi::String::createFromAscii(runtime, eventName.c_str()));
+      if (argFactory) {
+        argFactory(runtime, args);
+      }
+      emitFunction.callWithThis(
+          runtime, emitterObject, (const jsi::Value *)args.data(), args.size());
+    }
+  });
 }
 
 } // namespace react

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

@@ -54,7 +54,15 @@ class JSI_EXPORT TurboModule : public facebook::jsi::HostObject {
         // Method was not found, let JS decide what to do.
         return facebook::jsi::Value::undefined();
       } else {
-        return get(runtime, propName, p->second);
+        auto moduleMethod = createHostFunction(runtime, propName, p->second);
+        // If we have a JS wrapper, cache the result of this lookup
+        // We don't cache misses, to allow for methodMap_ to dynamically be
+        // extended
+        if (jsRepresentation_) {
+          jsRepresentation_->lock(runtime).asObject(runtime).setProperty(
+              runtime, propName, moduleMethod);
+        }
+        return moduleMethod;
       }
     }
   }
@@ -83,12 +91,32 @@ class JSI_EXPORT TurboModule : public facebook::jsi::HostObject {
   };
   std::unordered_map<std::string, MethodMetadata> methodMap_;
 
+  using ArgFactory =
+      std::function<void(jsi::Runtime &runtime, std::vector<jsi::Value> &args)>;
+
+  /**
+   * Calls RCTDeviceEventEmitter.emit to JavaScript, with given event name and
+   * an optional list of arguments.
+   * If present, argFactory is a callback used to construct extra arguments,
+   * e.g.
+   *
+   *  emitDeviceEvent(rt, "myCustomEvent",
+   *    [](jsi::Runtime& rt, std::vector<jsi::Value>& args) {
+   *      args.emplace_back(jsi::Value(true));
+   *      args.emplace_back(jsi::Value(42));
+   *  });
+   */
+  void emitDeviceEvent(
+      jsi::Runtime &runtime,
+      const std::string &eventName,
+      ArgFactory argFactory = nullptr);
+
  private:
   friend class TurboCxxModule;
   friend class TurboModuleBinding;
-  std::unique_ptr<jsi::Object> jsRepresentation_;
+  std::unique_ptr<jsi::WeakObject> jsRepresentation_;
 
-  facebook::jsi::Value get(
+  facebook::jsi::Value createHostFunction(
       facebook::jsi::Runtime &runtime,
       const facebook::jsi::PropNameID &propName,
       const MethodMetadata &meta);

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

@@ -23,18 +23,14 @@ namespace react {
  */
 
 TurboModuleBinding::TurboModuleBinding(
-    const TurboModuleProviderFunctionType &&moduleProvider,
     TurboModuleBindingMode bindingMode,
-    std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection)
-    : moduleProvider_(std::move(moduleProvider)),
-      longLivedObjectCollection_(std::move(longLivedObjectCollection)),
-      bindingMode_(bindingMode) {}
+    TurboModuleProviderFunctionType &&moduleProvider)
+    : bindingMode_(bindingMode), moduleProvider_(std::move(moduleProvider)) {}
 
 void TurboModuleBinding::install(
     jsi::Runtime &runtime,
-    const TurboModuleProviderFunctionType &&moduleProvider,
     TurboModuleBindingMode bindingMode,
-    std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection) {
+    TurboModuleProviderFunctionType &&moduleProvider) {
   runtime.global().setProperty(
       runtime,
       "__turboModuleProxy",
@@ -42,37 +38,28 @@ void TurboModuleBinding::install(
           runtime,
           jsi::PropNameID::forAscii(runtime, "__turboModuleProxy"),
           1,
-          [binding = TurboModuleBinding(
-               std::move(moduleProvider),
-               bindingMode,
-               std::move(longLivedObjectCollection))](
+          [binding =
+               TurboModuleBinding(bindingMode, std::move(moduleProvider))](
               jsi::Runtime &rt,
               const jsi::Value &thisVal,
               const jsi::Value *args,
-              size_t count) mutable {
-            return binding.getModule(rt, thisVal, args, count);
+              size_t count) {
+            if (count < 1) {
+              throw std::invalid_argument(
+                  "__turboModuleProxy must be called with at least 1 argument");
+            }
+            std::string moduleName = args[0].getString(rt).utf8(rt);
+            return binding.getModule(rt, moduleName);
           }));
 }
 
 TurboModuleBinding::~TurboModuleBinding() {
-  if (longLivedObjectCollection_) {
-    longLivedObjectCollection_->clear();
-  } else {
-    LongLivedObjectCollection::get().clear();
-  }
+  LongLivedObjectCollection::get().clear();
 }
 
 jsi::Value TurboModuleBinding::getModule(
     jsi::Runtime &runtime,
-    const jsi::Value &thisVal,
-    const jsi::Value *args,
-    size_t count) {
-  if (count < 1) {
-    throw std::invalid_argument(
-        "__turboModuleProxy must be called with at least 1 argument");
-  }
-  std::string moduleName = args[0].getString(runtime).utf8(runtime);
-
+    const std::string &moduleName) const {
   std::shared_ptr<TurboModule> module;
   {
     SystraceSection s(
@@ -85,25 +72,33 @@ jsi::Value TurboModuleBinding::getModule(
       return jsi::Object::createFromHostObject(runtime, std::move(module));
     }
 
-    auto &jsRepresentation = module->jsRepresentation_;
-    if (!jsRepresentation) {
-      jsRepresentation = std::make_unique<jsi::Object>(runtime);
-      if (bindingMode_ == TurboModuleBindingMode::Prototype) {
-        // Option 1: create plain object, with it's prototype mapped back to the
-        // hostobject. Any properties accessed are stored on the plain object
-        auto hostObject =
-            jsi::Object::createFromHostObject(runtime, std::move(module));
-        jsRepresentation->setProperty(
-            runtime, "__proto__", std::move(hostObject));
-      } else {
-        // Option 2: eagerly install all hostfunctions at this point, avoids
-        // prototype
-        for (auto &propName : module->getPropertyNames(runtime)) {
-          module->get(runtime, propName);
-        }
+    auto &weakJsRepresentation = module->jsRepresentation_;
+    if (weakJsRepresentation) {
+      auto jsRepresentation = weakJsRepresentation->lock(runtime);
+      if (!jsRepresentation.isUndefined()) {
+        return jsRepresentation;
+      }
+    }
+
+    // No JS representation found, or object has been collected
+    jsi::Object jsRepresentation(runtime);
+    weakJsRepresentation =
+        std::make_unique<jsi::WeakObject>(runtime, jsRepresentation);
+
+    if (bindingMode_ == TurboModuleBindingMode::Prototype) {
+      // Option 1: create plain object, with it's prototype mapped back to the
+      // hostobject. Any properties accessed are stored on the plain object
+      auto hostObject =
+          jsi::Object::createFromHostObject(runtime, std::move(module));
+      jsRepresentation.setProperty(runtime, "__proto__", std::move(hostObject));
+    } else {
+      // Option 2: eagerly install all hostfunctions at this point, avoids
+      // prototype
+      for (auto &propName : module->getPropertyNames(runtime)) {
+        module->get(runtime, propName);
       }
     }
-    return jsi::Value(runtime, *jsRepresentation);
+    return jsRepresentation;
   } else {
     return jsi::Value::null();
   }

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

@@ -9,15 +9,12 @@
 
 #include <string>
 
-#include <ReactCommon/LongLivedObject.h>
 #include <ReactCommon/TurboModule.h>
 #include <jsi/jsi.h>
 
 namespace facebook {
 namespace react {
 
-class JSCallInvoker;
-
 enum class TurboModuleBindingMode : uint8_t {
   HostObject = 0,
   Prototype = 1,
@@ -35,30 +32,24 @@ class TurboModuleBinding {
    */
   static void install(
       jsi::Runtime &runtime,
-      const TurboModuleProviderFunctionType &&moduleProvider,
       TurboModuleBindingMode bindingMode,
-      std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection);
+      TurboModuleProviderFunctionType &&moduleProvider);
 
  private:
   TurboModuleBinding(
-      const TurboModuleProviderFunctionType &&moduleProvider,
       TurboModuleBindingMode bindingMode,
-      std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection);
+      TurboModuleProviderFunctionType &&moduleProvider);
   virtual ~TurboModuleBinding();
 
   /**
    * A lookup function exposed to JS to get an instance of a TurboModule
    * for the given name.
    */
-  jsi::Value getModule(
-      jsi::Runtime &runtime,
-      const jsi::Value &thisVal,
-      const jsi::Value *args,
-      size_t count);
+  jsi::Value getModule(jsi::Runtime &runtime, const std::string &moduleName)
+      const;
 
-  TurboModuleProviderFunctionType moduleProvider_;
-  std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection_;
   TurboModuleBindingMode bindingMode_;
+  TurboModuleProviderFunctionType moduleProvider_;
 };
 
 } // namespace react

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

@@ -79,13 +79,13 @@ void Promise::reject(const std::string &message) {
 
 jsi::Value createPromiseAsJSIValue(
     jsi::Runtime &rt,
-    const PromiseSetupFunctionType func) {
+    PromiseSetupFunctionType &&func) {
   jsi::Function JSPromise = rt.global().getPropertyAsFunction(rt, "Promise");
   jsi::Function fn = jsi::Function::createFromHostFunction(
       rt,
       jsi::PropNameID::forAscii(rt, "fn"),
       2,
-      [func](
+      [func = std::move(func)](
           jsi::Runtime &rt2,
           const jsi::Value &thisVal,
           const jsi::Value *args,

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

@@ -36,7 +36,7 @@ using PromiseSetupFunctionType =
     std::function<void(jsi::Runtime &rt, std::shared_ptr<Promise>)>;
 jsi::Value createPromiseAsJSIValue(
     jsi::Runtime &rt,
-    const PromiseSetupFunctionType func);
+    PromiseSetupFunctionType &&func);
 
 class RAIICallbackWrapperDestroyer {
  public:

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

@@ -15,6 +15,7 @@
 #include <ReactCommon/TurboModule.h>
 #include <ReactCommon/TurboModulePerfLogger.h>
 #include <ReactCommon/TurboModuleUtils.h>
+#include <butter/function.h>
 #include <jsi/JSIDynamic.h>
 #include <react/debug/react_native_assert.h>
 #include <react/jni/NativeMap.h>
@@ -31,8 +32,7 @@ namespace TMPL = TurboModulePerfLogger;
 JavaTurboModule::JavaTurboModule(const InitParams &params)
     : TurboModule(params.moduleName, params.jsInvoker),
       instance_(jni::make_global(params.instance)),
-      nativeInvoker_(params.nativeInvoker),
-      retainJSCallback_(params.retainJSCallback) {}
+      nativeInvoker_(params.nativeInvoker) {}
 
 JavaTurboModule::~JavaTurboModule() {
   /**
@@ -63,13 +63,11 @@ struct JNIArgs {
 };
 
 jni::local_ref<JCxxCallbackImpl::JavaPart> createJavaCallbackFromJSIFunction(
-    const JSCallbackRetainer &retainJSCallback,
     jsi::Function &&function,
     jsi::Runtime &rt,
     const std::shared_ptr<CallInvoker> &jsInvoker) {
-  auto weakWrapper = retainJSCallback != nullptr
-      ? retainJSCallback(std::move(function), rt, jsInvoker)
-      : react::CallbackWrapper::createWeak(std::move(function), rt, jsInvoker);
+  auto weakWrapper =
+      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
@@ -80,12 +78,13 @@ jni::local_ref<JCxxCallbackImpl::JavaPart> createJavaCallbackFromJSIFunction(
   auto callbackWrapperOwner =
       std::make_shared<RAIICallbackWrapperDestroyer>(weakWrapper);
 
-  std::function<void(folly::dynamic)> fn =
-      [weakWrapper, callbackWrapperOwner, wrapperWasCalled = false](
-          folly::dynamic responses) mutable {
+  return JCxxCallbackImpl::newObjectCxxArgs(
+      [weakWrapper = std::move(weakWrapper),
+       callbackWrapperOwner = std::move(callbackWrapperOwner),
+       wrapperWasCalled = false](folly::dynamic responses) mutable {
         if (wrapperWasCalled) {
           throw std::runtime_error(
-              "callback 2 arg cannot be called more than once");
+              "Callback arg cannot be called more than once");
         }
 
         auto strongWrapper = weakWrapper.lock();
@@ -94,37 +93,29 @@ jni::local_ref<JCxxCallbackImpl::JavaPart> createJavaCallbackFromJSIFunction(
         }
 
         strongWrapper->jsInvoker().invokeAsync(
-            [weakWrapper, callbackWrapperOwner, responses]() mutable {
+            [weakWrapper = std::move(weakWrapper),
+             callbackWrapperOwner = std::move(callbackWrapperOwner),
+             responses = std::move(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));
+              std::vector<jsi::Value> args;
+              args.reserve(responses.size());
+              for (const auto &val : responses) {
+                args.emplace_back(
+                    jsi::valueFromDynamic(strongWrapper2->runtime(), val));
               }
+
               strongWrapper2->callback().call(
                   strongWrapper2->runtime(),
-                  (const jsi::Value *)result.data(),
-                  result.size());
-
-              callbackWrapperOwner.reset();
+                  (const jsi::Value *)args.data(),
+                  args.size());
             });
 
         wrapperWasCalled = true;
-      };
-
-  return JCxxCallbackImpl::newObjectCxxArgs(fn);
+      });
 }
 
 // This is used for generating short exception strings.
@@ -253,8 +244,7 @@ JNIArgs convertJSIArgsToJNIArgs(
     const jsi::Value *args,
     size_t count,
     const std::shared_ptr<CallInvoker> &jsInvoker,
-    TurboModuleMethodValueKind valueKind,
-    const JSCallbackRetainer &retainJSCallback) {
+    TurboModuleMethodValueKind valueKind) {
   unsigned int expectedArgumentCount = valueKind == PromiseKind
       ? methodArgTypes.size() - 1
       : methodArgTypes.size();
@@ -334,8 +324,7 @@ JNIArgs convertJSIArgsToJNIArgs(
       }
       jsi::Function fn = arg->getObject(rt).getFunction(rt);
       jarg->l = makeGlobalIfNecessary(
-          createJavaCallbackFromJSIFunction(
-              retainJSCallback, std::move(fn), rt, jsInvoker)
+          createJavaCallbackFromJSIFunction(std::move(fn), rt, jsInvoker)
               .release());
     } else if (type == "Lcom/facebook/react/bridge/ReadableArray;") {
       if (!(arg->isObject() && arg->getObject(rt).isArray(rt))) {
@@ -374,8 +363,7 @@ jsi::Value convertFromJMapToValue(JNIEnv *env, jsi::Runtime &rt, jobject arg) {
       jArguments,
       "makeNativeMap",
       "(Ljava/util/Map;)Lcom/facebook/react/bridge/WritableNativeMap;");
-  auto constants =
-      (jobject)env->CallStaticObjectMethod(jArguments, jMakeNativeMap, arg);
+  auto constants = env->CallStaticObjectMethod(jArguments, jMakeNativeMap, arg);
   auto jResult = jni::adopt_local(constants);
   auto result = jni::static_ref_cast<NativeMap::jhybridobject>(jResult);
   return jsi::valueFromDynamic(rt, result->cthis()->consume());
@@ -492,8 +480,7 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
       args,
       argCount,
       jsInvoker_,
-      valueKind,
-      retainJSCallback_);
+      valueKind);
 
   if (isMethodSync && valueKind != PromiseKind) {
     TMPL::syncMethodCallArgConversionEnd(moduleName, methodName);
@@ -696,8 +683,7 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
            methodID,
            moduleNameStr = name_,
            methodNameStr,
-           env,
-           retainJSCallback = retainJSCallback_](
+           env](
               jsi::Runtime &runtime,
               const jsi::Value &thisVal,
               const jsi::Value *promiseConstructorArgs,
@@ -714,16 +700,10 @@ jsi::Value JavaTurboModule::invokeJavaMethod(
                     runtime);
 
             auto resolve = createJavaCallbackFromJSIFunction(
-                               retainJSCallback,
-                               std::move(resolveJSIFn),
-                               runtime,
-                               jsInvoker_)
+                               std::move(resolveJSIFn), runtime, jsInvoker_)
                                .release();
             auto reject = createJavaCallbackFromJSIFunction(
-                              retainJSCallback,
-                              std::move(rejectJSIFn),
-                              runtime,
-                              jsInvoker_)
+                              std::move(rejectJSIFn), runtime, jsInvoker_)
                               .release();
 
             jclass jPromiseImpl =

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

@@ -25,20 +25,14 @@ 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,
-    const std::shared_ptr<CallInvoker> &jsInvoker)>;
-
 class JSI_EXPORT JavaTurboModule : public TurboModule {
  public:
   // TODO(T65603471): Should we unify this with a Fabric abstraction?
   struct InitParams {
     std::string moduleName;
-    jni::alias_ref<JTurboModule> instance;
+    jni::alias_ref<jobject> instance;
     std::shared_ptr<CallInvoker> jsInvoker;
     std::shared_ptr<CallInvoker> nativeInvoker;
-    JSCallbackRetainer retainJSCallback;
   };
 
   JavaTurboModule(const InitParams &params);
@@ -54,9 +48,9 @@ class JSI_EXPORT JavaTurboModule : public TurboModule {
       jmethodID &cachedMethodID);
 
  private:
-  jni::global_ref<JTurboModule> instance_;
+  // instance_ can be of type JTurboModule, or JNativeModule
+  jni::global_ref<jobject> instance_;
   std::shared_ptr<CallInvoker> nativeInvoker_;
-  JSCallbackRetainer retainJSCallback_;
 };
 
 } // namespace react

package/ReactCommon/react/nativemodule/core/platform/ios/React-NativeModulesApple.podspec

@@ -0,0 +1,56 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+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 -Wno-gnu-zero-variadic-macro-arguments'
+folly_version = '2021.07.22.00'
+boost_compiler_flags = '-Wno-documentation'
+using_hermes = ENV['USE_HERMES'] == nil || ENV['USE_HERMES'] == "1"
+Pod::Spec.new do |s|
+    s.name                   = "React-NativeModulesApple"
+    s.module_name            = "React_NativeModulesApple"
+    s.header_dir             = "ReactCommon" # Use global header_dir for all subspecs for use_frameworks! compatibility
+    s.version                = version
+    s.summary                = "-"
+    s.homepage               = "https://reactnative.dev/"
+    s.license                = package["license"]
+    s.author                 = "Meta Platforms, Inc. and its affiliates"
+    s.platforms              = { :ios => "12.4" }
+    s.source                 = source
+    s.compiler_flags         = folly_compiler_flags + ' ' + boost_compiler_flags
+    s.pod_target_xcconfig    = { "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\" \"$(PODS_ROOT)/RCT-Folly\" \"$(PODS_ROOT)/DoubleConversion\" \"$(PODS_ROOT)/Headers/Private/React-Core\"",
+                                "USE_HEADERMAP" => "YES",
+                                "CLANG_CXX_LANGUAGE_STANDARD" => "c++17",
+                                "GCC_WARN_PEDANTIC" => "YES" }
+    if ENV['USE_FRAMEWORKS']
+        s.header_mappings_dir     = './'
+    end
+
+    s.source_files = "ReactCommon/**/*.{mm,cpp,h}"
+
+    s.dependency "ReactCommon/turbomodule/core"
+    s.dependency "ReactCommon/turbomodule/bridging"
+    s.dependency "React-callinvoker"
+    s.dependency "React-Core"
+    s.dependency "React-cxxreact"
+    s.dependency "React-runtimeexecutor"
+    s.dependency "React-jsi"
+
+    if using_hermes
+      s.dependency "hermes-engine"
+    end
+end

package/ReactCommon/react/nativemodule/core/platform/ios/{RCTBlockGuard.h → ReactCommon/RCTBlockGuard.h}

@@ -12,7 +12,7 @@ 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
+ * is deallocated, place the clean up code inside constructor and make sure the instance of the class is references in
  * the block.
  */
 @interface RCTBlockGuard : NSObject

package/ReactCommon/react/nativemodule/core/platform/ios/{RCTTurboModule.h → ReactCommon/RCTTurboModule.h}

@@ -29,9 +29,6 @@ namespace react {
 class CallbackWrapper;
 class Instance;
 
-typedef std::weak_ptr<CallbackWrapper> (
-    ^RCTRetainJSCallback)(jsi::Function &&callback, jsi::Runtime &runtime, std::shared_ptr<CallInvoker> jsInvoker);
-
 /**
  * ObjC++ specific TurboModule base class.
  */
@@ -44,7 +41,6 @@ class JSI_EXPORT ObjCTurboModule : public TurboModule {
     std::shared_ptr<CallInvoker> jsInvoker;
     std::shared_ptr<CallInvoker> nativeInvoker;
     bool isSyncModule;
-    RCTRetainJSCallback retainJSCallback;
   };
 
   ObjCTurboModule(const InitParams &params);
@@ -67,8 +63,6 @@ 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.