react-native-windows 0.74.12 → 0.75.0-preview.2

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/bridging/Bridging.h

@@ -13,8 +13,9 @@
 #include <react/bridging/Class.h>
 // #include <react/bridging/Dynamic.h> // Line causes Error C1083 Cannot open include file: 'double-conversion/double-conversion.h' #11644
 #include <react/bridging/Error.h>
+#include <react/bridging/EventEmitter.h>
 #include <react/bridging/Function.h>
 #include <react/bridging/Number.h>
 #include <react/bridging/Object.h>
 #include <react/bridging/Promise.h>
-#include <react/bridging/Value.h>
+#include <react/bridging/Value.h>

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/bridging/CallbackWrapper.h

@@ -8,23 +8,24 @@
 #pragma once
 
 #include <jsi/jsi.h>
-#include <LongLivedObject.h>
 
 #include <memory>
 
-namespace facebook {
-namespace react {
+#include <LongLivedObject.h> // [Windows]
+
+namespace facebook::react {
+
+class CallInvoker;
 
 // Helper for passing jsi::Function arg to other methods.
 class CallbackWrapper : public LongLivedObject {
  private:
   CallbackWrapper(
-      jsi::Function &&callback,
-      jsi::Runtime &runtime,
+      jsi::Function&& callback,
+      jsi::Runtime& runtime,
       std::shared_ptr<CallInvoker> jsInvoker)
-      : longLivedObjectCollection_(),
+      : LongLivedObject(runtime),
         callback_(std::move(callback)),
-        runtime_(runtime),
         jsInvoker_(std::move(jsInvoker)) {}
 
   CallbackWrapper(
@@ -32,9 +33,8 @@ class CallbackWrapper : public LongLivedObject {
       jsi::Function &&callback,
       jsi::Runtime &runtime,
       std::shared_ptr<CallInvoker> jsInvoker)
-      : longLivedObjectCollection_(longLivedObjectCollection),
+      : LongLivedObject(runtime),
         callback_(std::move(callback)),
-        runtime_(runtime),
         jsInvoker_(std::move(jsInvoker)) {}
 
   // Use a weak_ptr to avoid a retain cycle: LongLivedObjectCollection owns all
@@ -42,7 +42,6 @@ class CallbackWrapper : public LongLivedObject {
   // LongLivedObjectCollection.
   std::weak_ptr<LongLivedObjectCollection> longLivedObjectCollection_;
   jsi::Function callback_;
-  jsi::Runtime &runtime_;
   std::shared_ptr<CallInvoker> jsInvoker_;
 
  public:
@@ -50,9 +49,9 @@ class CallbackWrapper : public LongLivedObject {
       jsi::Function &&callback,
       jsi::Runtime &runtime,
       std::shared_ptr<CallInvoker> jsInvoker) {
-    auto wrapper = std::shared_ptr<CallbackWrapper>(
-        new CallbackWrapper(std::move(callback), runtime, jsInvoker));
-    LongLivedObjectCollection::get().add(wrapper);
+    auto wrapper = std::shared_ptr<CallbackWrapper>(new CallbackWrapper(
+        std::move(callback), runtime, std::move(jsInvoker)));
+    LongLivedObjectCollection::get(runtime).add(wrapper);
     return wrapper;
   }
 
@@ -99,5 +98,4 @@ class CallbackWrapper : public LongLivedObject {
   }
 };
 
-} // namespace react
-} // namespace facebook
+} // namespace facebook::react

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/bridging/EventEmitter.h

@@ -0,0 +1,137 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <Function.h> // [Windows]
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <unordered_map>
+
+#define FRIEND_TEST(test_case_name, test_name) \
+  friend class test_case_name##_##test_name##_Test
+
+namespace facebook::react {
+
+class EventSubscription {
+ public:
+  explicit EventSubscription(std::function<void()> remove)
+      : remove_(std::move(remove)) {}
+  ~EventSubscription() = default;
+  EventSubscription(EventSubscription&&) noexcept = default;
+  EventSubscription& operator=(EventSubscription&&) noexcept = default;
+  EventSubscription(const EventSubscription&) = delete;
+  EventSubscription& operator=(const EventSubscription&) = delete;
+
+ private:
+  friend Bridging<EventSubscription>;
+
+  std::function<void()> remove_;
+};
+
+template <>
+struct Bridging<EventSubscription> {
+  static jsi::Object toJs(
+      jsi::Runtime& rt,
+      const EventSubscription& eventSubscription,
+      const std::shared_ptr<CallInvoker>& jsInvoker) {
+    auto result = jsi::Object(rt);
+    result.setProperty(
+        rt, "remove", bridging::toJs(rt, eventSubscription.remove_, jsInvoker));
+    return result;
+  }
+};
+
+class IAsyncEventEmitter {
+ public:
+  IAsyncEventEmitter() noexcept = default;
+  virtual ~IAsyncEventEmitter() noexcept = default;
+  IAsyncEventEmitter(IAsyncEventEmitter&&) noexcept = default;
+  IAsyncEventEmitter& operator=(IAsyncEventEmitter&&) noexcept = default;
+  IAsyncEventEmitter(const IAsyncEventEmitter&) = delete;
+  IAsyncEventEmitter& operator=(const IAsyncEventEmitter&) = delete;
+
+  virtual jsi::Object get(
+      jsi::Runtime& rt,
+      const std::shared_ptr<CallInvoker>& jsInvoker) const = 0;
+};
+
+template <typename... Args>
+class AsyncEventEmitter : public IAsyncEventEmitter {
+  static_assert(
+      sizeof...(Args) <= 1,
+      "AsyncEventEmitter must have at most one argument");
+
+ public:
+  AsyncEventEmitter() : state_(std::make_shared<SharedState>()) {
+    listen_ = [state = state_](AsyncCallback<Args...> listener) {
+      std::lock_guard<std::mutex> lock(state->mutex);
+      auto listenerId = state->listenerId++;
+      state->listeners.emplace(listenerId, std::move(listener));
+      return EventSubscription([state, listenerId]() {
+        std::lock_guard<std::mutex> innerLock(state->mutex);
+        state->listeners.erase(listenerId);
+      });
+    };
+  }
+  ~AsyncEventEmitter() override = default;
+  AsyncEventEmitter(AsyncEventEmitter&&) noexcept = default;
+  AsyncEventEmitter& operator=(AsyncEventEmitter&&) noexcept = default;
+  AsyncEventEmitter(const AsyncEventEmitter&) = delete;
+  AsyncEventEmitter& operator=(const AsyncEventEmitter&) = delete;
+
+  void emit(std::function<jsi::Value(jsi::Runtime&)>&& converter) {
+    std::lock_guard<std::mutex> lock(state_->mutex);
+    for (auto& [_, listener] : state_->listeners) {
+      listener.call([converter](jsi::Runtime& rt, jsi::Function& jsFunction) {
+        jsFunction.call(rt, converter(rt));
+      });
+    }
+  }
+
+  void emit(Args... value) {
+    std::lock_guard<std::mutex> lock(state_->mutex);
+    for (const auto& [_, listener] : state_->listeners) {
+      listener.call(static_cast<Args>(value)...);
+    }
+  }
+
+  jsi::Object get(
+      jsi::Runtime& rt,
+      const std::shared_ptr<CallInvoker>& jsInvoker) const override {
+    auto result = jsi::Object(rt);
+    result.setProperty(
+        rt, "addListener", bridging::toJs(rt, listen_, jsInvoker));
+    return result;
+  }
+
+ private:
+  friend Bridging<AsyncEventEmitter>;
+  FRIEND_TEST(BridgingTest, eventEmitterTest);
+
+  struct SharedState {
+    std::mutex mutex;
+    std::unordered_map<size_t, AsyncCallback<Args...>> listeners;
+    size_t listenerId{};
+  };
+
+  std::function<EventSubscription(AsyncCallback<Args...>)> listen_;
+  std::shared_ptr<SharedState> state_;
+};
+
+template <typename... Args>
+struct Bridging<AsyncEventEmitter<Args...>> {
+  static jsi::Object toJs(
+      jsi::Runtime& rt,
+      const AsyncEventEmitter<Args...>& eventEmitter,
+      const std::shared_ptr<CallInvoker>& jsInvoker) {
+    return eventEmitter.get(rt, jsInvoker);
+  }
+};
+
+} // namespace facebook::react

package/ReactCommon/TEMP_UntilReactCommonUpdate/react/bridging/Function.h

@@ -0,0 +1,283 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <Base.h> // [Windows]
+#include <CallbackWrapper.h> // [Windows]
+
+#include <ReactCommon/CallInvoker.h>
+#include <ReactCommon/SchedulerPriority.h>
+
+namespace facebook::react {
+
+template <typename F>
+class SyncCallback;
+
+template <typename... Args>
+class AsyncCallback {
+ public:
+  AsyncCallback(
+      jsi::Runtime& runtime,
+      jsi::Function function,
+      std::shared_ptr<CallInvoker> jsInvoker)
+      : callback_(std::make_shared<SyncCallback<void(Args...)>>(
+            runtime,
+            std::move(function),
+            std::move(jsInvoker))) {}
+
+  void operator()(Args... args) const noexcept {
+    call(std::forward<Args>(args)...);
+  }
+
+  void call(Args... args) const noexcept {
+    callWithArgs(std::nullopt, std::forward<Args>(args)...);
+  }
+
+  void callWithPriority(SchedulerPriority priority, Args... args)
+      const noexcept {
+    callWithArgs(priority, std::forward<Args>(args)...);
+  }
+
+  void call(std::function<void(jsi::Runtime&, jsi::Function&)>&& callImpl)
+      const noexcept {
+    callWithFunction(std::nullopt, std::move(callImpl));
+  }
+
+  void callWithPriority(
+      SchedulerPriority priority,
+      std::function<void(jsi::Runtime&, jsi::Function&)>&& callImpl)
+      const noexcept {
+    callWithFunction(priority, std::move(callImpl));
+  }
+
+ private:
+  friend Bridging<AsyncCallback>;
+
+  std::shared_ptr<SyncCallback<void(Args...)>> callback_;
+
+  void callWithArgs(std::optional<SchedulerPriority> priority, Args... args)
+      const noexcept {
+    if (auto wrapper = callback_->wrapper_.lock()) {
+      auto fn = [callback = callback_,
+                 argsPtr = std::make_shared<std::tuple<Args...>>(
+                     std::make_tuple(std::forward<Args>(args)...))](
+                    jsi::Runtime&) { callback->apply(std::move(*argsPtr)); };
+
+      auto& jsInvoker = wrapper->jsInvoker();
+      if (priority) {
+        jsInvoker.invokeAsync(*priority, std::move(fn));
+      } else {
+        jsInvoker.invokeAsync(std::move(fn));
+      }
+    }
+  }
+
+  void callWithFunction(
+      std::optional<SchedulerPriority> priority,
+      std::function<void(jsi::Runtime&, jsi::Function&)>&& callImpl)
+      const noexcept {
+    if (auto wrapper = callback_->wrapper_.lock()) {
+      // Capture callback_ and not wrapper_. If callback_ is deallocated or the
+      // JSVM is shutdown before the async task is scheduled, the underlying
+      // function will have been deallocated.
+      auto fn = [callback = callback_,
+                 callImpl = std::move(callImpl)](jsi::Runtime& rt) {
+        if (auto wrapper2 = callback->wrapper_.lock()) {
+          callImpl(rt, wrapper2->callback());
+        }
+      };
+
+      auto& jsInvoker = wrapper->jsInvoker();
+      if (priority) {
+        jsInvoker.invokeAsync(*priority, std::move(fn));
+      } else {
+        jsInvoker.invokeAsync(std::move(fn));
+      }
+    }
+  }
+};
+
+// You must ensure that when invoking this you're located on the JS thread, or
+// have exclusive control of the JS VM context. If you cannot ensure this, use
+// AsyncCallback instead.
+template <typename R, typename... Args>
+class SyncCallback<R(Args...)> {
+ public:
+  SyncCallback(
+      jsi::Runtime& rt,
+      jsi::Function function,
+      std::shared_ptr<CallInvoker> jsInvoker)
+      : wrapper_(CallbackWrapper::createWeak(
+            std::move(function),
+            rt,
+            std::move(jsInvoker))) {}
+
+  // Disallow copying, as we can no longer safely destroy the callback
+  // from the destructor if there's multiple copies
+  SyncCallback(const SyncCallback&) = delete;
+  SyncCallback& operator=(const SyncCallback&) = delete;
+
+  // Allow move
+  SyncCallback(SyncCallback&& other) noexcept
+      : wrapper_(std::move(other.wrapper_)) {}
+
+  SyncCallback& operator=(SyncCallback&& other) noexcept {
+    wrapper_ = std::move(other.wrapper_);
+    return *this;
+  }
+
+  ~SyncCallback() {
+    if (auto wrapper = wrapper_.lock()) {
+      wrapper->destroy();
+    }
+  }
+
+  R operator()(Args... args) const {
+    return call(std::forward<Args>(args)...);
+  }
+
+  R call(Args... args) const {
+    auto wrapper = wrapper_.lock();
+
+    // If the wrapper has been deallocated, we can no longer provide a return
+    // value consistently, so our only option is to throw
+    if (!wrapper) {
+      if constexpr (std::is_void_v<R>) {
+        return;
+      } else {
+        throw std::runtime_error("Failed to call invalidated sync callback");
+      }
+    }
+
+    auto& callback = wrapper->callback();
+    auto& rt = wrapper->runtime();
+    auto jsInvoker = wrapper->jsInvokerPtr();
+
+    if constexpr (std::is_void_v<R>) {
+      callback.call(
+          rt, bridging::toJs(rt, std::forward<Args>(args), jsInvoker)...);
+    } else {
+      return bridging::fromJs<R>(
+          rt,
+          callback.call(
+              rt, bridging::toJs(rt, std::forward<Args>(args), jsInvoker)...),
+          jsInvoker);
+    }
+  }
+
+ private:
+  friend AsyncCallback<Args...>;
+  friend Bridging<SyncCallback>;
+
+  R apply(std::tuple<Args...>&& args) const {
+    return apply(std::move(args), std::index_sequence_for<Args...>{});
+  }
+
+  template <size_t... Index>
+  R apply(std::tuple<Args...>&& args, std::index_sequence<Index...>) const {
+    return call(std::move(std::get<Index>(args))...);
+  }
+
+  // Held weakly so lifetime is managed by LongLivedObjectCollection.
+  std::weak_ptr<CallbackWrapper> wrapper_;
+};
+
+template <typename... Args>
+struct Bridging<AsyncCallback<Args...>> {
+  static AsyncCallback<Args...> fromJs(
+      jsi::Runtime& rt,
+      jsi::Function&& value,
+      const std::shared_ptr<CallInvoker>& jsInvoker) {
+    return AsyncCallback<Args...>(rt, std::move(value), jsInvoker);
+  }
+
+  static jsi::Function toJs(
+      jsi::Runtime& rt,
+      const AsyncCallback<Args...>& value) {
+    return value.callback_->function_.getFunction(rt);
+  }
+};
+
+template <typename R, typename... Args>
+struct Bridging<SyncCallback<R(Args...)>> {
+  static SyncCallback<R(Args...)> fromJs(
+      jsi::Runtime& rt,
+      jsi::Function&& value,
+      const std::shared_ptr<CallInvoker>& jsInvoker) {
+    return SyncCallback<R(Args...)>(rt, std::move(value), jsInvoker);
+  }
+
+  static jsi::Function toJs(
+      jsi::Runtime& rt,
+      const SyncCallback<R(Args...)>& value) {
+    return value.function_.getFunction(rt);
+  }
+};
+
+template <typename R, typename... Args>
+struct Bridging<std::function<R(Args...)>> {
+  using Func = std::function<R(Args...)>;
+  using IndexSequence = std::index_sequence_for<Args...>;
+
+  static constexpr size_t kArgumentCount = sizeof...(Args);
+
+  static jsi::Function toJs(
+      jsi::Runtime& rt,
+      Func fn,
+      const std::shared_ptr<CallInvoker>& jsInvoker) {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forAscii(rt, "BridgedFunction"),
+        kArgumentCount,
+        [fn = std::make_shared<Func>(std::move(fn)), jsInvoker](
+            jsi::Runtime& rt,
+            const jsi::Value&,
+            const jsi::Value* args,
+            size_t count) -> jsi::Value {
+          if (count < kArgumentCount) {
+            throw jsi::JSError(rt, "Incorrect number of arguments");
+          }
+
+          if constexpr (std::is_void_v<R>) {
+            callFromJs(*fn, rt, args, jsInvoker, IndexSequence{});
+            return jsi::Value();
+          } else {
+            return bridging::toJs(
+                rt,
+                callFromJs(*fn, rt, args, jsInvoker, IndexSequence{}),
+                jsInvoker);
+          }
+        });
+  }
+
+ private:
+  template <size_t... Index>
+  static R callFromJs(
+      Func& fn,
+      jsi::Runtime& rt,
+      const jsi::Value* args,
+      const std::shared_ptr<CallInvoker>& jsInvoker,
+      std::index_sequence<Index...>) {
+    return fn(bridging::fromJs<Args>(rt, args[Index], jsInvoker)...);
+  }
+};
+
+template <typename R, typename... Args>
+struct Bridging<
+    std::function<R(Args...)>,
+    std::enable_if_t<
+        !std::is_same_v<std::function<R(Args...)>, std::function<R(Args...)>>>>
+    : Bridging<std::function<R(Args...)>> {};
+
+template <typename R, typename... Args>
+struct Bridging<R(Args...)> : Bridging<std::function<R(Args...)>> {};
+
+template <typename R, typename... Args>
+struct Bridging<R (*)(Args...)> : Bridging<std::function<R(Args...)>> {};
+
+} // namespace facebook::react

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

@@ -40,25 +40,22 @@ TurboModule::TurboModule(
     : name_(std::move(name)), jsInvoker_(std::move(jsInvoker)) {}
 
 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");
+  jsInvoker_->invokeAsync([eventName, argFactory](jsi::Runtime& rt) {
+    jsi::Value emitter = rt.global().getProperty(rt, "__rctDeviceEventEmitter");
     if (!emitter.isUndefined()) {
-      jsi::Object emitterObject = emitter.asObject(runtime);
+      jsi::Object emitterObject = emitter.asObject(rt);
       // TODO: consider caching these
       jsi::Function emitFunction =
-          emitterObject.getPropertyAsFunction(runtime, "emit");
+          emitterObject.getPropertyAsFunction(rt, "emit");
       std::vector<jsi::Value> args;
-      args.emplace_back(
-          jsi::String::createFromAscii(runtime, eventName.c_str()));
+      args.emplace_back(jsi::String::createFromAscii(rt, eventName.c_str()));
       if (argFactory) {
-        argFactory(runtime, args);
+        argFactory(rt, args);
       }
       emitFunction.callWithThis(
-          runtime, emitterObject, (const jsi::Value*)args.data(), args.size());
+          rt, emitterObject, (const jsi::Value*)args.data(), args.size());
     }
   });
 }

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

@@ -0,0 +1,162 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+#include <jsi/jsi.h>
+
+#include <ReactCommon/CallInvoker.h>
+#include <EventEmitter.h> // [Windows]
+
+namespace facebook::react {
+
+/**
+ * For now, support the same set of return types as existing impl.
+ * This can be improved to support richer typed objects.
+ */
+enum TurboModuleMethodValueKind {
+  VoidKind,
+  BooleanKind,
+  NumberKind,
+  StringKind,
+  ObjectKind,
+  ArrayKind,
+  FunctionKind,
+  PromiseKind,
+};
+
+/**
+ * Determines TurboModuleMethodValueKind based on the jsi::Value type.
+ */
+TurboModuleMethodValueKind getTurboModuleMethodValueKind(
+    jsi::Runtime& rt,
+    const jsi::Value* value);
+
+class TurboCxxModule;
+class TurboModuleBinding;
+
+/**
+ * Base HostObject class for every module to be exposed to JS
+ */
+class JSI_EXPORT TurboModule : public facebook::jsi::HostObject {
+ public:
+  TurboModule(std::string name, std::shared_ptr<CallInvoker> jsInvoker);
+
+  // Note: keep this method declared inline to avoid conflicts
+  // between RTTI and non-RTTI compilation units
+  facebook::jsi::Value get(
+      facebook::jsi::Runtime& runtime,
+      const facebook::jsi::PropNameID& propName) override {
+    {
+      auto prop = create(runtime, propName);
+      // 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_ && !prop.isUndefined()) {
+        jsRepresentation_->lock(runtime).asObject(runtime).setProperty(
+            runtime, propName, prop);
+      }
+      return prop;
+    }
+  }
+
+  virtual std::vector<facebook::jsi::PropNameID> getPropertyNames(
+      facebook::jsi::Runtime& runtime) override {
+    std::vector<jsi::PropNameID> result;
+    result.reserve(methodMap_.size());
+    for (auto it = methodMap_.cbegin(); it != methodMap_.cend(); ++it) {
+      result.push_back(jsi::PropNameID::forUtf8(runtime, it->first));
+    }
+    return result;
+  }
+
+ protected:
+  const std::string name_;
+  std::shared_ptr<CallInvoker> jsInvoker_;
+
+  struct MethodMetadata {
+    size_t argCount;
+    facebook::jsi::Value (*invoker)(
+        facebook::jsi::Runtime& rt,
+        TurboModule& turboModule,
+        const facebook::jsi::Value* args,
+        size_t count);
+  };
+  std::unordered_map<std::string, MethodMetadata> methodMap_;
+  std::unordered_map<std::string, std::shared_ptr<IAsyncEventEmitter>>
+      eventEmitterMap_;
+
+  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(
+      const std::string& eventName,
+      ArgFactory argFactory = nullptr);
+
+  // Backwards compatibility version
+  void emitDeviceEvent(
+      jsi::Runtime& /*runtime*/,
+
+      const std::string& eventName,
+      ArgFactory argFactory = nullptr) {
+    emitDeviceEvent(eventName, std::move(argFactory));
+  }
+
+  virtual jsi::Value create(
+      jsi::Runtime& runtime,
+      const jsi::PropNameID& propName) {
+    std::string propNameUtf8 = propName.utf8(runtime);
+    if (auto methodIter = methodMap_.find(propNameUtf8);
+        methodIter != methodMap_.end()) {
+      const MethodMetadata& meta = methodIter->second;
+      return jsi::Function::createFromHostFunction(
+          runtime,
+          propName,
+          static_cast<unsigned int>(meta.argCount),
+          [this, meta](
+              jsi::Runtime& rt,
+              [[maybe_unused]] const jsi::Value& thisVal,
+              const jsi::Value* args,
+              size_t count) { return meta.invoker(rt, *this, args, count); });
+    } else if (auto eventEmitterIter = eventEmitterMap_.find(propNameUtf8);
+               eventEmitterIter != eventEmitterMap_.end()) {
+      return eventEmitterIter->second->get(runtime, jsInvoker_);
+    }
+    // Neither Method nor EventEmitter were not found, let JS decide what to do.
+    return facebook::jsi::Value::undefined();
+  }
+
+ private:
+  friend class TurboCxxModule;
+  friend class TurboModuleBinding;
+  std::unique_ptr<jsi::WeakObject> jsRepresentation_;
+};
+
+/**
+ * An app/platform-specific provider function to get an instance of a module
+ * given a name.
+ */
+using TurboModuleProviderFunctionType =
+    std::function<std::shared_ptr<TurboModule>(const std::string& name)>;
+
+} // namespace facebook::react