@appsent-co/react-native-watchos 0.1.0

package/build/xcframework/simulator/Headers/ReactNativeWatchOSCxx/RNWHermesHost.h

@@ -0,0 +1,58 @@
+#import <Foundation/Foundation.h>
+#import <ReactNativeWatchOSCxx/RNWShadowNode.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef NS_ENUM(NSInteger, RNWLogLevel) {
+    RNWLogLevelLog,
+    RNWLogLevelWarn,
+    RNWLogLevelError,
+    RNWLogLevelInfo,
+};
+
+/// Owns a Hermes JS runtime via JSI. The runtime lives on a private serial
+/// dispatch queue (the "JS queue") so main-thread SwiftUI work isn't blocked.
+/// All public methods are thread-safe — they hop to the JS queue internally.
+///
+/// Installs `globalThis.__RNW_log(level, message)` and a minimal one-arg
+/// `console` bootstrap. The rich multi-arg shim lives in
+/// `src/setupConsole.ts` and routes through `__RNW_log` to `onConsoleLog`.
+@interface RNWHermesHost : NSObject
+
+- (instancetype)init NS_DESIGNATED_INITIALIZER;
+
+/// Evaluate a JS source string on the JS queue. `url` is the source URL
+/// for stack traces. `completion` fires on the main queue with nil on
+/// success.
+- (void)evaluate:(NSString *)source
+             url:(NSString *)url
+      completion:(void (^)(NSError * _Nullable error))completion;
+
+/// Called on the main queue for every `console.<level>(...)`.
+@property (nonatomic, copy, nullable) void (^onConsoleLog)(RNWLogLevel level,
+                                                           NSString *message);
+
+/// Called on the main queue after every JS-side `completeRoot()`. Empty
+/// roots send `@[]`; never nil.
+@property (nonatomic, copy, nullable) void (^onCommit)(NSArray<RNWShadowNodeSnapshot *> *root);
+
+/// Called on the main queue when JS invokes `globalThis.__RNW_RELOAD()`
+/// (Fast Refresh full-reload path). Dispatched async off the current JS
+/// callstack so the runtime can safely re-evaluate.
+@property (nonatomic, copy, nullable) void (^onReloadRequest)(void);
+
+/// Bridge from SwiftUI action closures into `globalThis.__RNW_EVENTS.dispatch`.
+/// Fire-and-forget; no-op if the JS bridge isn't installed or the id is
+/// unknown.
+- (void)fireEventWithHandlerId:(NSInteger)handlerId
+                       payload:(nullable id)payload;
+
+/// Bridge from native `RCTEventEmitter sendEventWithName:body:` into
+/// `globalThis.__RNW_EVENTS.dispatchEvent`. Fire-and-forget; no-op if the
+/// bridge isn't installed or no listener is registered for the name.
+- (void)fireEventByName:(NSString *)eventName
+                payload:(nullable id)payload;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/build/xcframework/simulator/Headers/ReactNativeWatchOSCxx/RNWShadowNode.h

@@ -0,0 +1,49 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Node kind in the snapshot tree. `view` covers every SwiftUI view, keyed
+/// by `viewName`. `rawText` is the inert string child of a Text-like node.
+typedef NS_ENUM(NSInteger, RNWNodeKind) {
+    RNWNodeKindView,
+    RNWNodeKindRawText,
+};
+
+/// Immutable snapshot of a shadow node. SwiftUI renders directly off this.
+@interface RNWShadowNodeSnapshot : NSObject
+@property (nonatomic, readonly) NSInteger tag;
+@property (nonatomic, readonly) RNWNodeKind kind;
+
+/// JS-side view type ("Text", "Button", "VStack", ...). nil for rawText.
+@property (nonatomic, readonly, nullable) NSString *viewName;
+
+/// Values are NSString | NSNumber | NSArray | NSDictionary; per-view-type
+/// interpretation happens on the Swift side. nil for rawText.
+@property (nonatomic, readonly, nullable) NSDictionary<NSString *, id> *props;
+
+/// Modifiers in source order — SwiftUI modifiers are non-commutative.
+/// Each entry has a "$type" key plus modifier-specific params.
+@property (nonatomic, readonly) NSArray<NSDictionary<NSString *, id> *> *modifiers;
+
+/// Event-name → JS handler id. Native dispatches via
+/// `__RNW_EVENTS.dispatch(id, payload)`.
+@property (nonatomic, readonly) NSDictionary<NSString *, NSNumber *> *eventHandlers;
+
+/// rawText only.
+@property (nonatomic, readonly, nullable) NSString *text;
+
+@property (nonatomic, readonly) NSArray<RNWShadowNodeSnapshot *> *children;
+
+- (instancetype)initWithTag:(NSInteger)tag
+                       kind:(RNWNodeKind)kind
+                   viewName:(nullable NSString *)viewName
+                      props:(nullable NSDictionary<NSString *, id> *)props
+                  modifiers:(NSArray<NSDictionary<NSString *, id> *> *)modifiers
+              eventHandlers:(NSDictionary<NSString *, NSNumber *> *)eventHandlers
+                       text:(nullable NSString *)text
+                   children:(NSArray<RNWShadowNodeSnapshot *> *)children
+    NS_DESIGNATED_INITIALIZER;
+- (instancetype)init NS_UNAVAILABLE;
+@end
+
+NS_ASSUME_NONNULL_END

package/build/xcframework/simulator/Headers/ReactNativeWatchOSCxx/RNWTurboModuleRegistry+Cxx.h

@@ -0,0 +1,64 @@
+// Internal ObjC++ header — Swift can't see the C++ types, so this lives
+// outside the umbrella header and module authors include it from `.mm`.
+
+#pragma once
+
+#import <ReactNativeWatchOSCxx/RNWTurboModuleRegistry.h>
+
+#include <ReactCommon/CallInvoker.h>
+#include <ReactCommon/TurboModule.h>
+
+#include <functional>
+#include <memory>
+#include <string>
+
+namespace facebook::react {
+class TurboModule;
+class CallInvoker;
+}  // namespace facebook::react
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Invoked lazily on the JS thread the first time JS calls
+/// `__turboModuleProxy('<name>')`. Result is cached for the registry's life.
+using RNWTurboModuleCxxFactory = std::function<
+    std::shared_ptr<facebook::react::TurboModule>(
+        std::shared_ptr<facebook::react::CallInvoker> jsInvoker)>;
+
+/// Invoked from `+load` synthesized by `RNW_EXPORT_CXX_MODULE`.
+FOUNDATION_EXTERN void RNWRegisterCxxTurboModule(NSString *name,
+                                                 RNWTurboModuleCxxFactory factory);
+
+/// Place at file scope in an `.mm` to auto-register a C++ TurboModule on
+/// image load. Requires the consumer to link with `-ObjC` (the Expo plugin
+/// sets this).
+///
+/// Example:
+///
+///   RNW_EXPORT_CXX_MODULE(Math, [](std::shared_ptr<facebook::react::CallInvoker> jsInvoker) {
+///       return std::make_shared<NativeMathModule>(std::move(jsInvoker));
+///   });
+#define RNW_EXPORT_CXX_MODULE(js_name, factory_expr)                    \
+  @interface RNWCxxAutoload_##js_name : NSObject                        \
+  @end                                                                  \
+  @implementation RNWCxxAutoload_##js_name                              \
+  +(void)load { RNWRegisterCxxTurboModule(@ #js_name, factory_expr); }  \
+  @end
+
+@interface RNWTurboModuleRegistry (Cxx)
+
+/// Prefer `RNW_EXPORT_CXX_MODULE`; this is for dynamic registration only.
+- (void)registerCxxModuleNamed:(NSString *)name
+                       factory:(RNWTurboModuleCxxFactory)factory;
+
+/// Internal — resolves cached → C++ factory → ObjC factory, building the
+/// `ObjCTurboModule` wrapper for the ObjC path. Returns `nullptr` if
+/// nothing matches.
+- (std::shared_ptr<facebook::react::TurboModule>)
+        lookupModuleNamed:(NSString *)name
+                jsInvoker:(std::shared_ptr<facebook::react::CallInvoker>)jsInvoker
+            nativeInvoker:(std::shared_ptr<facebook::react::NativeMethodCallInvoker>)nativeInvoker;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/build/xcframework/simulator/Headers/ReactNativeWatchOSCxx/RNWTurboModuleRegistry.h

@@ -0,0 +1,24 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Per-host registry of TurboModule factories, looked up by
+/// `__turboModuleProxy('<name>')`. Modules normally self-register on image
+/// load via `RCT_EXPORT_MODULE` (ObjC) or `RNW_EXPORT_CXX_MODULE` (C++);
+/// direct calls here are for dynamic registration only.
+///
+/// ObjC modules: use `registerModuleName:factory:` (this header).
+/// C++ modules: use `RNWTurboModuleRegistry+Cxx.h` from a `.mm` file.
+@interface RNWTurboModuleRegistry : NSObject
+
+@property (class, readonly) RNWTurboModuleRegistry *shared;
+
+/// Factory is invoked lazily on first JS access and must return an
+/// instance conforming to `<RCTBridgeModule, RCTTurboModule>`. The
+/// instance's `-getTurboModule:` constructs the C++ wrapper.
+- (void)registerModuleName:(NSString *)name
+                   factory:(id _Nonnull (^)(void))factory;
+
+@end
+
+NS_ASSUME_NONNULL_END