@appsent-co/react-native-watchos 0.1.0

package/build/xcframework/device/Headers/jsi/jsilib.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 <jsi/jsi.h>
+
+namespace facebook {
+namespace jsi {
+
+class FileBuffer : public Buffer {
+ public:
+  FileBuffer(const std::string& path);
+  ~FileBuffer() override;
+
+  size_t size() const override {
+    return size_;
+  }
+
+  const uint8_t* data() const override {
+    return data_;
+  }
+
+ private:
+  size_t size_;
+  uint8_t* data_;
+};
+
+// A trivial implementation of PreparedJavaScript that simply stores the source
+// buffer and URL.
+class SourceJavaScriptPreparation final : public jsi::PreparedJavaScript,
+                                          public jsi::Buffer {
+  std::shared_ptr<const jsi::Buffer> buf_;
+  std::string sourceURL_;
+
+ public:
+  SourceJavaScriptPreparation(
+      std::shared_ptr<const jsi::Buffer> buf,
+      std::string sourceURL)
+      : buf_(std::move(buf)), sourceURL_(std::move(sourceURL)) {}
+
+  const std::string& sourceURL() const {
+    return sourceURL_;
+  }
+
+  size_t size() const override {
+    return buf_->size();
+  }
+  const uint8_t* data() const override {
+    return buf_->data();
+  }
+};
+
+} // namespace jsi
+} // namespace facebook

package/build/xcframework/device/Headers/jsi/test/testlib.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 <functional>
+#include <memory>
+#include <vector>
+
+#include <gtest/gtest.h>
+#include <jsi/jsi.h>
+
+namespace facebook {
+namespace jsi {
+
+class Runtime;
+
+using RuntimeFactory = std::function<std::shared_ptr<Runtime>()>;
+
+std::vector<RuntimeFactory> runtimeGenerators();
+
+class JSITestBase : public ::testing::TestWithParam<RuntimeFactory> {
+ public:
+  JSITestBase() : factory(GetParam()), runtime(factory()), rt(*runtime) {}
+
+  Value eval(const char* code) {
+    return rt.global().getPropertyAsFunction(rt, "eval").call(rt, code);
+  }
+
+  Function function(const std::string& code) {
+    return eval(("(" + code + ")").c_str()).getObject(rt).getFunction(rt);
+  }
+
+  bool checkValue(const Value& value, const std::string& jsValue) {
+    return function("function(value) { return value == " + jsValue + "; }")
+        .call(rt, std::move(value))
+        .getBool();
+  }
+
+  RuntimeFactory factory;
+  std::shared_ptr<Runtime> runtime;
+  Runtime& rt;
+};
+} // namespace jsi
+} // namespace facebook

package/build/xcframework/device/Headers/jsi/threadsafe.h

@@ -0,0 +1,79 @@
+/*
+ * 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 <mutex>
+
+#include <jsi/decorator.h>
+#include <jsi/jsi.h>
+
+namespace facebook {
+namespace jsi {
+
+class ThreadSafeRuntime : public Runtime {
+ public:
+  virtual void lock() const = 0;
+  virtual void unlock() const = 0;
+  virtual Runtime& getUnsafeRuntime() = 0;
+};
+
+namespace detail {
+
+template <typename R, typename L>
+struct WithLock {
+  L lock;
+  WithLock(R& r) : lock(r) {}
+  void before() {
+    lock.lock();
+  }
+  void after() {
+    lock.unlock();
+  }
+};
+
+// The actual implementation of a given ThreadSafeRuntime. It's parameterized
+// by:
+//
+// - R: The actual Runtime type that this wraps
+// - L: A lock type that has three members:
+//   - L(R& r)       // ctor
+//   - void lock()
+//   - void unlock()
+template <typename R, typename L>
+class ThreadSafeRuntimeImpl final
+    : public WithRuntimeDecorator<WithLock<R, L>, R, ThreadSafeRuntime> {
+ public:
+  template <typename... Args>
+  ThreadSafeRuntimeImpl(Args&&... args)
+      : WithRuntimeDecorator<WithLock<R, L>, R, ThreadSafeRuntime>(
+            unsafe_,
+            lock_),
+        unsafe_(std::forward<Args>(args)...),
+        lock_(unsafe_) {}
+
+  R& getUnsafeRuntime() override {
+    return WithRuntimeDecorator<WithLock<R, L>, R, ThreadSafeRuntime>::plain();
+  }
+
+  void lock() const override {
+    lock_.before();
+  }
+
+  void unlock() const override {
+    lock_.after();
+  }
+
+ private:
+  R unsafe_;
+  mutable WithLock<R, L> lock_;
+};
+
+} // namespace detail
+
+} // namespace jsi
+} // namespace facebook

package/build/xcframework/device/Headers/module.modulemap

@@ -0,0 +1,25 @@
+module ReactNativeWatchOSCxx {
+    header "ReactNativeWatchOSCxx/RNWShadowNode.h"
+    header "ReactNativeWatchOSCxx/RNWHermesHost.h"
+    header "ReactNativeWatchOSCxx/RNWTurboModuleRegistry.h"
+
+    // Cxx category — declares C++ types (`facebook::react::TurboModule`,
+    // `std::function`, `std::shared_ptr`) that Swift can't see. Marked
+    // `textual` so the Swift module compiler treats it as a plain
+    // `#include` rather than modularizing it. ObjC++ module authors
+    // include from `.mm` files only.
+    textual header "ReactNativeWatchOSCxx/RNWTurboModuleRegistry+Cxx.h"
+
+    export *
+}
+
+// Note: `<React/RCTBridgeModule.h>` and `<ReactCommon/RCTTurboModule.h>`
+// (the watchOS-safe forks of RN's TurboModule headers) ship at
+// `Headers/React/...` and `Headers/ReactCommon/...` inside the xcframework
+// — they're not part of THIS module. Module authors include them via
+// the standard `#import <React/...>` / `#import <ReactCommon/...>` paths
+// from their own `.mm` files. The xcframework's Headers/ root is on the
+// header search path; the forks are found there. The two ObjC headers
+// would otherwise collide with React Native's pod on cross-platform
+// builds — keeping them outside this module avoids any `import
+// ReactNativeWatchOSCxx` from Swift dragging in `RCTBridgeModule`.

package/build/xcframework/device/Headers/react/RCTBridgeModule.h

@@ -0,0 +1,88 @@
+// watchOS fork of `<React/RCTBridgeModule.h>`. Upstream pulls UIKit (UIView,
+// UIDevice), RCTDefines, RCTJSThread, RCTBundleManager — none of which exist
+// on watchOS. We re-declare the slim subset that codegen-emitted spec
+// classes + maintainer module bodies actually depend on, **using the
+// upstream names** so cross-platform TurboModule sources compile against
+// either fork unchanged:
+//
+//   - `RCTBridgeModule` protocol: the `+moduleName` class method that
+//     identifies the module to JS.
+//   - `RCTPromiseResolveBlock` / `RCTPromiseRejectBlock` /
+//     `RCTResponseSenderBlock` / `RCTResponseErrorBlock` typedefs.
+//   - `RCT_EXPORT_MODULE` macro: synthesizes `+moduleName` AND a `+load`
+//     that registers the class with `RNWTurboModuleRegistry.shared`,
+//     mirroring upstream RN's auto-registration behavior. Maintainers
+//     write a single line and the module shows up in JS.
+//
+// Header layout matches upstream — this file lives at
+// `Headers/React/RCTBridgeModule.h` inside the xcframework, so a
+// maintainer's `#import <React/RCTBridgeModule.h>` resolves here on
+// watchOS and to RN's pod on iOS. The two never coexist in the same
+// translation unit (iOS host + watch extension are separate Xcode
+// targets), so the shared name causes no collision and the same `.mm`
+// gets the right auto-registration path on each platform.
+//
+// We do NOT ship the legacy `RCT_EXPORT_METHOD` / `RCT_REMAP_METHOD` /
+// `RCT_EXPORT_SYNCHRONOUS_METHOD` macros. Those exist only to feed
+// `RCTInteropTurboModule` (the runtime-parsing legacy bridge path),
+// which is not ported. Codegen-emitted modules don't use them — they
+// declare regular ObjC instance methods, and codegen wires the C++
+// `methodMap_` directly.
+
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Sends an array response back to a JS callback.
+typedef void (^RCTResponseSenderBlock)(NSArray *response);
+
+/// Sends an error response back to a JS callback.
+typedef void (^RCTResponseErrorBlock)(NSError *error);
+
+/// Resolves the JS promise waiting for this method's result. Nil resolves
+/// to `undefined`.
+typedef void (^RCTPromiseResolveBlock)(id _Nullable result);
+
+/// Rejects the JS promise. `error` may be nil but supplying an NSError
+/// yields better stack traces on the JS side.
+typedef void (^RCTPromiseRejectBlock)(
+    NSString *code,
+    NSString * _Nullable message,
+    NSError * _Nullable error);
+
+/// Marker protocol for TurboModule-providing classes. The codegen-emitted
+/// `Native<Foo>Spec` protocol conforms to this + `RCTTurboModule`, and
+/// the maintainer's class conforms to that combined protocol. Mirrors
+/// `RCTBridgeModule` upstream, minus the bridge/registry/queue properties
+/// that don't exist on watchOS.
+@protocol RCTBridgeModule <NSObject>
+
+/// Returns the JS-facing name of this module. Synthesized by
+/// `RCT_EXPORT_MODULE(name)`. JS calls
+/// `globalThis.__turboModuleProxy('<moduleName>')` to obtain the proxy.
++ (NSString *)moduleName;
+
+@end
+
+/// C entrypoint invoked from the `+load` synthesized by `RCT_EXPORT_MODULE`.
+/// Bridges into `RNWTurboModuleRegistry.shared` without forcing every
+/// module's translation unit to import the registry header.
+///
+/// Defined in `RNWTurboModuleRegistry.mm`.
+FOUNDATION_EXTERN void RNWRegisterTurboModuleClass(NSString *name, Class moduleClass);
+
+/// Place inside an `@implementation` block to synthesize `+moduleName`
+/// AND auto-register the class with the local TurboModule registry on
+/// image load (mirrors upstream RN's iOS behavior).
+///
+/// Requires the consumer target to link with `-ObjC` so the ObjC runtime
+/// loads our class (and fires `+load`) from the static library. The
+/// `@appsent-co/react-native-watchos` Expo plugin sets this automatically via
+/// `withSPMPackage`.
+#define RCT_EXPORT_MODULE(js_name)                                      \
+  +(NSString *)moduleName { return @ #js_name; }                        \
+  +(void)load { RNWRegisterTurboModuleClass(@ #js_name, self); }
+
+NS_ASSUME_NONNULL_END

package/build/xcframework/device/Headers/react/RCTCxxConvert.h

@@ -0,0 +1,7 @@
+// Stub of `<React/RCTCxxConvert.h>` for watchOS. Codegen `#import`s this
+// in every `Native<Foo>Spec.h`; the `RCTCxxConvert` ObjC class it
+// declares is only referenced by specs with struct args (it's the
+// codegen-extensible registry of JS-object → C++-struct converters).
+// v1 doesn't support struct args, so an empty header is sufficient.
+
+#pragma once

package/build/xcframework/device/Headers/react/RCTEventEmitter.h

@@ -0,0 +1,71 @@
+// watchOS fork of `<React/RCTEventEmitter.h>`. Mirrors upstream RN's
+// shape so a maintainer writes
+//
+//   @interface MyModule : RCTEventEmitter <NativeMySpec>
+//
+// unconditionally and the same source compiles on both slices. The
+// implementation differs under the hood:
+//
+//   - iOS:   RN's real RCTEventEmitter (bridge → RCTDeviceEventEmitter
+//            → NativeEventEmitter on the JS side).
+//   - watch: this stub. There's no bridge, so `sendEventWithName:body:`
+//            just posts `RNWEventEmitterFireEventNotification` carrying
+//            the event name + payload. The Swift `ReactNativeWatchOSHost`
+//            observes the notification and dispatches into JS via
+//            `__RNW_EVENTS.dispatchEvent(name, payload)`, where the
+//            JS-side `NativeEventEmitter` shim's name-keyed listener
+//            map fans out to subscribers.
+//
+// Header layout matches upstream — this file lives at
+// `Headers/React/RCTEventEmitter.h` inside the xcframework, so a
+// maintainer's `#import <React/RCTEventEmitter.h>` resolves here on
+// watchOS and to RN's pod on iOS. The two never coexist in the same
+// translation unit (iOS host + watch extension are separate Xcode
+// targets), so the shared name causes no collision.
+//
+// Methods that depend on RN's bridge (`startObserving`, `stopObserving`,
+// `invalidate`, `bridge`/`moduleRegistry`/`viewRegistry_DEPRECATED`
+// properties) are intentionally omitted — they'd need RN infrastructure
+// that doesn't exist on watchOS. Cross-platform module bodies that don't
+// touch them work identically; modules that do touch them would have
+// platform-specific code anyway.
+
+#pragma once
+
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Posted by `RCTEventEmitter sendEventWithName:body:` on watchOS.
+/// `ReactNativeWatchOSHost` observes this and forwards into JS via
+/// `fireEventByName:payload:`.
+///
+/// userInfo keys:
+///   "eventName" -> NSString (the name passed to `sendEventWithName:body:`)
+///   "payload"   -> id (JSON-encodable) or NSNull
+FOUNDATION_EXTERN NSNotificationName const RNWEventEmitterFireEventNotification;
+
+/// Abstract base class for TurboModules that emit events to JS.
+/// Subclass it, conform to your codegen-emitted `Native<Foo>Spec`, and
+/// call `[self sendEventWithName:body:]` to fire events. The JS-side
+/// `NativeEventEmitter` (shimmed on watchOS) takes care of subscription.
+@interface RCTEventEmitter : NSObject <RCTBridgeModule>
+
+/// Override in your subclass to advertise the events you emit. Optional
+/// on watchOS — the watch stub doesn't validate against this list. On
+/// iOS, attempting to send an unlisted event logs a warning.
+- (NSArray<NSString *> *)supportedEvents;
+
+/// Send an event to JS.
+- (void)sendEventWithName:(NSString *)name body:(nullable id)body;
+
+/// Lifecycle hooks the JS-side `NativeEventEmitter` calls when listeners
+/// are added/removed. No-ops in the watch stub — the notification bridge
+/// is always wired regardless of listener count.
+- (void)addListener:(NSString *)eventName;
+- (void)removeListeners:(double)count;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/build/xcframework/device/Headers/react/RCTManagedPointer.h

@@ -0,0 +1,7 @@
+// Stub of `<React/RCTManagedPointer.h>` for watchOS. Codegen `#import`s
+// this in every `Native<Foo>Spec.h`; the `RCTManagedPointer` ObjC class
+// it declares wraps `std::shared_ptr<void>` so struct converters can
+// return C++ structs across the ObjC boundary. v1 doesn't support
+// struct args, so an empty header is sufficient.
+
+#pragma once

package/build/xcframework/device/Headers/react/bridging/AString.h

@@ -0,0 +1,42 @@
+/*
+ * 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 <react/bridging/Base.h>
+
+#include <string>
+#include <string_view>
+
+namespace facebook::react {
+
+template <>
+struct Bridging<std::string> {
+  static std::string fromJs(jsi::Runtime& rt, const jsi::String& value) {
+    return value.utf8(rt);
+  }
+
+  static jsi::String toJs(jsi::Runtime& rt, const std::string& value) {
+    return jsi::String::createFromUtf8(rt, value);
+  }
+};
+
+template <>
+struct Bridging<std::string_view> {
+  static jsi::String toJs(jsi::Runtime& rt, std::string_view value) {
+    return jsi::String::createFromUtf8(
+        rt, reinterpret_cast<const uint8_t*>(value.data()), value.length());
+  }
+};
+
+template <>
+struct Bridging<const char*> : Bridging<std::string_view> {};
+
+template <size_t N>
+struct Bridging<char[N]> : Bridging<std::string_view> {};
+
+} // namespace facebook::react

package/build/xcframework/device/Headers/react/bridging/Array.h

@@ -0,0 +1,151 @@
+/*
+ * 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 <react/bridging/Base.h>
+
+#include <array>
+#include <deque>
+#include <initializer_list>
+#include <list>
+#include <set>
+#include <tuple>
+#include <utility>
+#include <vector>
+
+namespace facebook::react {
+
+namespace array_detail {
+
+template <typename T, size_t N>
+struct BridgingStatic {
+  static jsi::Array toJs(
+      jsi::Runtime& rt,
+      const T& array,
+      const std::shared_ptr<CallInvoker>& jsInvoker) {
+    return toJs(rt, array, jsInvoker, std::make_index_sequence<N>{});
+  }
+
+ private:
+  template <size_t... Index>
+  static jsi::Array toJs(
+      facebook::jsi::Runtime& rt,
+      const T& array,
+      const std::shared_ptr<CallInvoker>& jsInvoker,
+      std::index_sequence<Index...>) {
+    return jsi::Array::createWithElements(
+        rt, bridging::toJs(rt, std::get<Index>(array), jsInvoker)...);
+  }
+};
+
+template <typename T>
+struct BridgingDynamic {
+  static jsi::Array toJs(
+      jsi::Runtime& rt,
+      const T& list,
+      const std::shared_ptr<CallInvoker>& jsInvoker) {
+    jsi::Array result(rt, list.size());
+    size_t index = 0;
+
+    for (const auto& item : list) {
+      result.setValueAtIndex(rt, index++, bridging::toJs(rt, item, jsInvoker));
+    }
+
+    return result;
+  }
+};
+
+} // namespace array_detail
+
+template <typename T, size_t N>
+struct Bridging<std::array<T, N>>
+    : array_detail::BridgingStatic<std::array<T, N>, N> {
+  static std::array<T, N> fromJs(
+      facebook::jsi::Runtime& rt,
+      const jsi::Array& array,
+      const std::shared_ptr<CallInvoker>& jsInvoker) {
+    size_t length = array.length(rt);
+
+    std::array<T, N> result;
+    for (size_t i = 0; i < length; i++) {
+      result[i] =
+          bridging::fromJs<T>(rt, array.getValueAtIndex(rt, i), jsInvoker);
+    }
+
+    return result;
+  }
+};
+
+template <typename T1, typename T2>
+struct Bridging<std::pair<T1, T2>>
+    : array_detail::BridgingStatic<std::pair<T1, T2>, 2> {
+  static std::pair<T1, T1> fromJs(
+      facebook::jsi::Runtime& rt,
+      const jsi::Array& array,
+      const std::shared_ptr<CallInvoker>& jsInvoker) {
+    return std::make_pair(
+        bridging::fromJs<T1>(rt, array.getValueAtIndex(rt, 0), jsInvoker),
+        bridging::fromJs<T2>(rt, array.getValueAtIndex(rt, 1), jsInvoker));
+  }
+};
+
+template <typename... Types>
+struct Bridging<std::tuple<Types...>>
+    : array_detail::BridgingStatic<std::tuple<Types...>, sizeof...(Types)> {};
+
+template <typename T>
+struct Bridging<std::deque<T>> : array_detail::BridgingDynamic<std::deque<T>> {
+};
+
+template <typename T>
+struct Bridging<std::initializer_list<T>>
+    : array_detail::BridgingDynamic<std::initializer_list<T>> {};
+
+template <typename T>
+struct Bridging<std::list<T>> : array_detail::BridgingDynamic<std::list<T>> {};
+
+template <typename T>
+struct Bridging<std::vector<T>>
+    : array_detail::BridgingDynamic<std::vector<T>> {
+  static std::vector<T> fromJs(
+      facebook::jsi::Runtime& rt,
+      const jsi::Array& array,
+      const std::shared_ptr<CallInvoker>& jsInvoker) {
+    size_t length = array.length(rt);
+
+    std::vector<T> vector;
+    vector.reserve(length);
+
+    for (size_t i = 0; i < length; i++) {
+      vector.push_back(
+          bridging::fromJs<T>(rt, array.getValueAtIndex(rt, i), jsInvoker));
+    }
+
+    return vector;
+  }
+};
+
+template <typename T>
+struct Bridging<std::set<T>> : array_detail::BridgingDynamic<std::set<T>> {
+  static std::set<T> fromJs(
+      facebook::jsi::Runtime& rt,
+      const jsi::Array& array,
+      const std::shared_ptr<CallInvoker>& jsInvoker) {
+    size_t length = array.length(rt);
+
+    std::set<T> set;
+    for (size_t i = 0; i < length; i++) {
+      set.insert(
+          bridging::fromJs<T>(rt, array.getValueAtIndex(rt, i), jsInvoker));
+    }
+
+    return set;
+  }
+};
+
+} // namespace facebook::react