@appsent-co/react-native-watchos 0.1.0

package/build/xcframework/ReactNativeWatchOSCxx.xcframework/watchos-arm64-simulator/Headers/ReactCommon/RCTTurboModule.h

@@ -0,0 +1,187 @@
+// watchOS fork of `<ReactCommon/RCTTurboModule.h>` (the iOS platform layer
+// of RN's TurboModule core). Header layout matches upstream — this file
+// lives at `Headers/ReactCommon/RCTTurboModule.h` inside the xcframework,
+// so a maintainer's `#import <ReactCommon/RCTTurboModule.h>` resolves
+// here on watchOS and to RN's pod on iOS. The two never coexist in the
+// same translation unit (separate Xcode targets per platform), so the
+// shared name is safe.
+//
+// Differences vs upstream:
+//
+//   - `<React/RCTBridge.h>` import dropped — there's no `RCTBridge` on
+//     watchOS. The host plugs the `CallInvoker` /
+//     `NativeMethodCallInvoker` into `ObjCTurboModule::InitParams`
+//     directly via `RNWTurboModuleRegistry`.
+//   - The `RCTBridge (RCTTurboModule)` category at the end of upstream
+//     is dropped (we have no `RCTBridge`).
+//   - The class lives in `facebook::react::ObjCTurboModule` — same
+//     namespace + name as upstream. Codegen-emitted `Native<Foo>SpecJSI`
+//     classes inherit from that exact symbol; keeping the name means
+//     codegen output drops in without rewriting.
+//
+// We do NOT compile upstream's platform/ios sources, so there's no
+// duplicate-symbol risk — only our fork ends up in the static archive.
+
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+#import <React/RCTBridgeModule.h>
+#import <ReactCommon/CallInvoker.h>
+#import <ReactCommon/TurboModule.h>
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace facebook::react {
+
+using EventEmitterCallback = std::function<void(const std::string &, id)>;
+
+namespace TurboModuleConvertUtils {
+
+/// Convert an ObjC value (NSString / NSNumber / NSArray / NSDictionary /
+/// kCFNull) to its JSI equivalent. Unknown classes return `undefined`.
+jsi::Value convertObjCObjectToJSIValue(jsi::Runtime &runtime, id value);
+
+/// Convert a JSI value to its ObjC counterpart. Functions become
+/// `RCTResponseSenderBlock`-style callbacks bound to the JS thread via
+/// `jsInvoker`. If `useNSNull` is YES, JS `null` maps to `kCFNull`;
+/// otherwise `null` becomes `nil`.
+id convertJSIValueToObjCObject(
+    jsi::Runtime &runtime,
+    const jsi::Value &value,
+    const std::shared_ptr<CallInvoker> &jsInvoker,
+    BOOL useNSNull = NO);
+
+}  // namespace TurboModuleConvertUtils
+
+// Bridging<id> specialization so codegen-emitted spec code that reads
+// ObjC return values via the bridging templates compiles unchanged.
+template <>
+struct Bridging<id> {
+    static jsi::Value toJs(jsi::Runtime &rt, const id &value)
+    {
+        return TurboModuleConvertUtils::convertObjCObjectToJSIValue(rt, value);
+    }
+};
+
+/// Base class every codegen-emitted `Native<Foo>SpecJSI` inherits from.
+/// Holds an ObjC instance + invokers, and dispatches JS method calls
+/// through `NSInvocation` into the maintainer's ObjC class.
+class JSI_EXPORT ObjCTurboModule : public TurboModule {
+ public:
+    struct InitParams {
+        std::string moduleName;
+        id<RCTBridgeModule> instance;
+        std::shared_ptr<CallInvoker> jsInvoker;
+        std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker;
+        bool isSyncModule;
+        bool shouldVoidMethodsExecuteSync;
+    };
+
+    ObjCTurboModule(const InitParams &params);
+
+    /// Dispatch a single method call. Called from the generated method
+    /// thunks in `Native<Foo>SpecJSI::methodMap_`. Resolves the selector
+    /// against `instance_`, builds an `NSInvocation`, runs it on the
+    /// native method queue, and converts the return back to JSI.
+    jsi::Value invokeObjCMethod(
+        jsi::Runtime &runtime,
+        TurboModuleMethodValueKind returnType,
+        const std::string &methodName,
+        SEL selector,
+        const jsi::Value *args,
+        size_t count);
+
+    id<RCTBridgeModule> instance_;
+    std::shared_ptr<NativeMethodCallInvoker> nativeMethodCallInvoker_;
+
+ protected:
+    void setEventEmitterCallback(EventEmitterCallback eventEmitterCallback);
+
+    /// Default conversion from ObjC return value → JSI, dispatching on
+    /// the codegen-supplied `TurboModuleMethodValueKind`. Overridable by
+    /// custom subclasses, but the codegen default is fine for v1.
+    virtual jsi::Value convertReturnIdToJSIValue(
+        jsi::Runtime &runtime,
+        const char *methodName,
+        TurboModuleMethodValueKind returnType,
+        id result);
+
+    /// Assigns one converted ObjC arg into the NSInvocation at index
+    /// `i + 2` (the `+2` skips `self` + `_cmd`). v1 supports the
+    /// JSON-mappable subset only: bool, double, NSInteger, NSString,
+    /// NSArray, NSDictionary, RCTResponseSenderBlock. Custom types
+    /// (UIColor/UIImage/structs) need a maintainer-side hop in their
+    /// method body.
+    virtual void setInvocationArg(
+        jsi::Runtime &runtime,
+        const char *methodName,
+        const std::string &objCArgType,
+        const jsi::Value &arg,
+        size_t i,
+        NSInvocation *inv,
+        NSMutableArray *retainedObjectsForInvocation);
+
+ private:
+    const bool isSyncModule_;
+    const bool shouldVoidMethodsExecuteSync_;
+
+    bool isMethodSync(TurboModuleMethodValueKind returnType);
+
+    NSInvocation *createMethodInvocation(
+        jsi::Runtime &runtime,
+        bool isSync,
+        const char *methodName,
+        SEL selector,
+        const jsi::Value *args,
+        size_t count,
+        NSMutableArray *retainedObjectsForInvocation);
+    id performMethodInvocation(
+        jsi::Runtime &runtime,
+        bool isSync,
+        const char *methodName,
+        NSInvocation *inv,
+        NSMutableArray *retainedObjectsForInvocation);
+    void performVoidMethodInvocation(
+        jsi::Runtime &runtime,
+        const char *methodName,
+        NSInvocation *inv,
+        NSMutableArray *retainedObjectsForInvocation);
+
+    using PromiseInvocationBlock = void (^)(
+        RCTPromiseResolveBlock resolveWrapper,
+        RCTPromiseRejectBlock rejectWrapper);
+    jsi::Value createPromise(
+        jsi::Runtime &runtime,
+        const std::string &methodName,
+        PromiseInvocationBlock invoke);
+};
+
+}  // namespace facebook::react
+
+/// Wraps a C++ `EventEmitterCallback` so it can be passed across the ObjC
+/// boundary in `-setEventEmitterCallback:`.
+@interface EventEmitterCallbackWrapper : NSObject {
+ @public
+    facebook::react::EventEmitterCallback _eventEmitterCallback;
+}
+@end
+
+/// Factory protocol every ObjC TurboModule conforms to. The maintainer's
+/// `-getTurboModule:` returns the codegen-emitted SpecJSI subclass.
+@protocol RCTModuleProvider <NSObject>
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+        (const facebook::react::ObjCTurboModule::InitParams &)params;
+@end
+
+/// Marker protocol so the registry can verify a class is actually meant
+/// to be exposed as a TurboModule. Conformance gives access to the
+/// optional event-emitter hookup.
+@protocol RCTTurboModule <RCTModuleProvider>
+@optional
+- (void)setEventEmitterCallback:
+        (EventEmitterCallbackWrapper *)eventEmitterCallbackWrapper;
+@end

package/build/xcframework/ReactNativeWatchOSCxx.xcframework/watchos-arm64-simulator/Headers/ReactCommon/RuntimeExecutor.h

@@ -0,0 +1,25 @@
+/*
+ * 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 <jsi/jsi.h>
+
+namespace facebook::react {
+
+/*
+ * Takes a function and calls it with a reference to a Runtime. The function
+ * will be called when it is safe to do so (i.e. it ensures non-concurrent
+ * access) and may be invoked asynchronously, depending on the implementation.
+ * If you need to access a Runtime, it's encouraged to use a RuntimeExecutor
+ * instead of storing a pointer to the Runtime itself, which makes it more
+ * difficult to ensure that the Runtime is being accessed safely.
+ */
+using RuntimeExecutor =
+    std::function<void(std::function<void(jsi::Runtime& runtime)>&& callback)>;
+
+} // namespace facebook::react

package/build/xcframework/ReactNativeWatchOSCxx.xcframework/watchos-arm64-simulator/Headers/ReactCommon/SchedulerPriority.h

@@ -0,0 +1,20 @@
+/*
+ * 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
+
+namespace facebook::react {
+
+enum class SchedulerPriority : int {
+  ImmediatePriority = 1,
+  UserBlockingPriority = 2,
+  NormalPriority = 3,
+  LowPriority = 4,
+  IdlePriority = 5,
+};
+
+} // namespace facebook::react

package/build/xcframework/ReactNativeWatchOSCxx.xcframework/watchos-arm64-simulator/Headers/ReactCommon/TurboCxxModule.h

@@ -0,0 +1,49 @@
+/*
+ * 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 <vector>
+
+#include <cxxreact/CxxModule.h>
+
+#include "TurboModule.h"
+
+namespace facebook::react {
+
+/**
+ * A helper class to convert the legacy CxxModule instance to a TurboModule
+ * instance. This should be used only for migration purpose (to TurboModule),
+ * since it's not very performant due to a lot of back-and-forth value
+ * conversions between folly::dynamic and jsi::Value.
+ */
+class JSI_EXPORT TurboCxxModule : public TurboModule {
+ public:
+  TurboCxxModule(
+      std::unique_ptr<facebook::xplat::module::CxxModule> cxxModule,
+      std::shared_ptr<CallInvoker> jsInvoker);
+
+  facebook::jsi::Value create(
+      facebook::jsi::Runtime& runtime,
+      const facebook::jsi::PropNameID& propName) override;
+
+  std::vector<facebook::jsi::PropNameID> getPropertyNames(
+      facebook::jsi::Runtime& runtime) override;
+
+  jsi::Value invokeMethod(
+      jsi::Runtime& runtime,
+      const std::string& methodName,
+      const jsi::Value* args,
+      size_t count);
+
+ private:
+  std::vector<facebook::xplat::module::CxxModule::Method> cxxMethods_;
+  std::unique_ptr<facebook::xplat::module::CxxModule> cxxModule_;
+};
+
+} // namespace facebook::react

package/build/xcframework/ReactNativeWatchOSCxx.xcframework/watchos-arm64-simulator/Headers/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 <react/bridging/EventEmitter.h>
+
+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 jsi::HostObject {
+ public:
+  TurboModule(std::string name, std::shared_ptr<CallInvoker> jsInvoker);
+
+  // DO NOT OVERRIDE - it will become final in a future release.
+  // This method provides automatic caching of properties on the TurboModule's
+  // JS representation. To customize lookup of properties, override `create`.
+  // Note: keep this method declared inline to avoid conflicts
+  // between RTTI and non-RTTI compilation units
+  jsi::Value get(jsi::Runtime& runtime, const 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;
+  }
+
+  std::vector<jsi::PropNameID> getPropertyNames(
+      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;
+    jsi::Value (*invoker)(
+        jsi::Runtime& rt,
+        TurboModule& turboModule,
+        const 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_);
+    } else {
+      // Neither Method nor EventEmitter were found, let JS decide what to do
+      return jsi::Value::undefined();
+    }
+  }
+
+ private:
+  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

package/build/xcframework/ReactNativeWatchOSCxx.xcframework/watchos-arm64-simulator/Headers/ReactCommon/TurboModuleBinding.h

@@ -0,0 +1,59 @@
+/*
+ * 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 <string>
+
+#include <jsi/jsi.h>
+#include <react/bridging/LongLivedObject.h>
+
+#include <ReactCommon/TurboModule.h>
+
+namespace facebook::react {
+
+class BridgelessNativeModuleProxy;
+
+/**
+ * Represents the JavaScript binding for the TurboModule system.
+ */
+class TurboModuleBinding {
+ public:
+  /*
+   * Installs TurboModuleBinding into JavaScript runtime.
+   * Thread synchronization must be enforced externally.
+   */
+  static void install(
+      jsi::Runtime& runtime,
+      TurboModuleProviderFunctionType&& moduleProvider,
+      TurboModuleProviderFunctionType&& legacyModuleProvider = nullptr,
+      std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection =
+          nullptr);
+
+  TurboModuleBinding(
+      jsi::Runtime& runtime,
+      TurboModuleProviderFunctionType&& moduleProvider,
+      std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection);
+
+  virtual ~TurboModuleBinding();
+
+ private:
+  friend BridgelessNativeModuleProxy;
+
+  /**
+   * A lookup function exposed to JS to get an instance of a TurboModule
+   * for the given name.
+   */
+  jsi::Value getModule(jsi::Runtime& runtime, const std::string& moduleName)
+      const;
+
+  jsi::Runtime& runtime_;
+  TurboModuleProviderFunctionType moduleProvider_;
+  std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection_;
+};
+
+} // namespace facebook::react

package/build/xcframework/ReactNativeWatchOSCxx.xcframework/watchos-arm64-simulator/Headers/ReactCommon/TurboModulePerfLogger.h

@@ -0,0 +1,108 @@
+/*
+ * 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 <reactperflogger/NativeModulePerfLogger.h>
+#include <memory>
+
+namespace facebook::react::TurboModulePerfLogger {
+void enableLogging(std::unique_ptr<NativeModulePerfLogger>&& logger);
+void disableLogging();
+
+void moduleDataCreateStart(const char* moduleName, int32_t id);
+void moduleDataCreateEnd(const char* moduleName, int32_t id);
+
+/**
+ * Create NativeModule platform object
+ */
+void moduleCreateStart(const char* moduleName, int32_t id);
+void moduleCreateCacheHit(const char* moduleName, int32_t id);
+void moduleCreateConstructStart(const char* moduleName, int32_t id);
+void moduleCreateConstructEnd(const char* moduleName, int32_t id);
+void moduleCreateSetUpStart(const char* moduleName, int32_t id);
+void moduleCreateSetUpEnd(const char* moduleName, int32_t id);
+void moduleCreateEnd(const char* moduleName, int32_t id);
+void moduleCreateFail(const char* moduleName, int32_t id);
+
+/**
+ * JS require beginning
+ */
+void moduleJSRequireBeginningStart(const char* moduleName);
+void moduleJSRequireBeginningCacheHit(const char* moduleName);
+void moduleJSRequireBeginningEnd(const char* moduleName);
+void moduleJSRequireBeginningFail(const char* moduleName);
+
+/**
+ * JS require ending
+ */
+void moduleJSRequireEndingStart(const char* moduleName);
+void moduleJSRequireEndingEnd(const char* moduleName);
+void moduleJSRequireEndingFail(const char* moduleName);
+
+// Sync method calls
+void syncMethodCallStart(const char* moduleName, const char* methodName);
+void syncMethodCallArgConversionStart(
+    const char* moduleName,
+    const char* methodName);
+void syncMethodCallArgConversionEnd(
+    const char* moduleName,
+    const char* methodName);
+void syncMethodCallExecutionStart(
+    const char* moduleName,
+    const char* methodName);
+void syncMethodCallExecutionEnd(const char* moduleName, const char* methodName);
+void syncMethodCallReturnConversionStart(
+    const char* moduleName,
+    const char* methodName);
+void syncMethodCallReturnConversionEnd(
+    const char* moduleName,
+    const char* methodName);
+void syncMethodCallEnd(const char* moduleName, const char* methodName);
+void syncMethodCallFail(const char* moduleName, const char* methodName);
+
+// Async method calls
+void asyncMethodCallStart(const char* moduleName, const char* methodName);
+void asyncMethodCallArgConversionStart(
+    const char* moduleName,
+    const char* methodName);
+void asyncMethodCallArgConversionEnd(
+    const char* moduleName,
+    const char* methodName);
+void asyncMethodCallDispatch(const char* moduleName, const char* methodName);
+void asyncMethodCallEnd(const char* moduleName, const char* methodName);
+void asyncMethodCallFail(const char* moduleName, const char* methodName);
+
+/**
+ * Pre-processing async method call batch
+ */
+void asyncMethodCallBatchPreprocessStart();
+void asyncMethodCallBatchPreprocessEnd(int batchSize);
+
+// Async method call execution
+void asyncMethodCallExecutionStart(
+    const char* moduleName,
+    const char* methodName,
+    int32_t id);
+void asyncMethodCallExecutionArgConversionStart(
+    const char* moduleName,
+    const char* methodName,
+    int32_t id);
+void asyncMethodCallExecutionArgConversionEnd(
+    const char* moduleName,
+    const char* methodName,
+    int32_t id);
+void asyncMethodCallExecutionEnd(
+    const char* moduleName,
+    const char* methodName,
+    int32_t id);
+void asyncMethodCallExecutionFail(
+    const char* moduleName,
+    const char* methodName,
+    int32_t id);
+
+} // namespace facebook::react::TurboModulePerfLogger

package/build/xcframework/ReactNativeWatchOSCxx.xcframework/watchos-arm64-simulator/Headers/ReactCommon/TurboModuleUtils.h

@@ -0,0 +1,38 @@
+/*
+ * 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 <cassert>
+#include <string>
+
+#include <jsi/jsi.h>
+#include <react/bridging/CallbackWrapper.h>
+#include <react/bridging/LongLivedObject.h>
+
+namespace facebook::react {
+
+jsi::Object deepCopyJSIObject(jsi::Runtime& rt, const jsi::Object& obj);
+jsi::Array deepCopyJSIArray(jsi::Runtime& rt, const jsi::Array& arr);
+
+struct Promise : public LongLivedObject {
+  Promise(jsi::Runtime& rt, jsi::Function resolve, jsi::Function reject);
+
+  void resolve(const jsi::Value& result);
+  void reject(const std::string& error);
+
+  jsi::Function resolve_;
+  jsi::Function reject_;
+};
+
+using PromiseSetupFunctionType =
+    std::function<void(jsi::Runtime& rt, std::shared_ptr<Promise>)>;
+jsi::Value createPromiseAsJSIValue(
+    jsi::Runtime& rt,
+    PromiseSetupFunctionType&& func);
+
+} // namespace facebook::react

package/build/xcframework/ReactNativeWatchOSCxx.xcframework/watchos-arm64-simulator/Headers/ReactCommon/TurboModuleWithJSIBindings.h

@@ -0,0 +1,29 @@
+/*
+ * 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 <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+
+namespace facebook::react {
+
+class TurboModule;
+
+class TurboModuleWithJSIBindings {
+ public:
+  virtual ~TurboModuleWithJSIBindings() = default;
+
+  static void installJSIBindings(
+      const std::shared_ptr<TurboModule>& cxxModule,
+      jsi::Runtime& runtime);
+
+ private:
+  virtual void installJSIBindingsWithRuntime(jsi::Runtime& runtime) = 0;
+};
+
+} // namespace facebook::react