@appsent-co/react-native-watchos 0.1.0

package/apple/Sources/ReactNativeWatchOSCxx/RNWTurboModuleRegistry.mm

@@ -0,0 +1,137 @@
+#import "ReactNativeWatchOSCxx/RNWTurboModuleRegistry.h"
+#import "ReactNativeWatchOSCxx/RNWTurboModuleRegistry+Cxx.h"
+#import <ReactCommon/RCTTurboModule.h>
+#import <React/RCTBridgeModule.h>
+
+#include <ReactCommon/CallInvoker.h>
+#include <ReactCommon/TurboModule.h>
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+@implementation RNWTurboModuleRegistry {
+    std::unordered_map<std::string, RNWTurboModuleCxxFactory> _cxxFactories;
+    // Cached so one module name → one instance per host lifetime
+    // (TurboModuleBinding caches the JS side but not the C++ side).
+    std::unordered_map<std::string,
+                       std::shared_ptr<facebook::react::TurboModule>>
+        _instances;
+    NSMutableDictionary<NSString *, id _Nonnull (^)(void)> *_objcFactories;
+}
+
++ (instancetype)shared {
+    static RNWTurboModuleRegistry *instance;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        instance = [[self alloc] init];
+    });
+    return instance;
+}
+
+- (instancetype)init {
+    if ((self = [super init])) {
+        _objcFactories = [NSMutableDictionary dictionary];
+    }
+    return self;
+}
+
+#pragma mark - ObjC registration
+
+- (void)registerModuleName:(NSString *)name
+                   factory:(id _Nonnull (^)(void))factory {
+    if (name == nil || factory == nil) {
+        return;
+    }
+    _objcFactories[name] = [factory copy];
+}
+
+#pragma mark - C++ registration
+
+- (void)registerCxxModuleNamed:(NSString *)name
+                       factory:(RNWTurboModuleCxxFactory)factory {
+    if (name == nil || !factory) {
+        return;
+    }
+    _cxxFactories[std::string([name UTF8String])] = std::move(factory);
+}
+
+#pragma mark - Lookup
+
+- (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 {
+    if (name == nil) {
+        return nullptr;
+    }
+    std::string key([name UTF8String]);
+
+    auto cached = _instances.find(key);
+    if (cached != _instances.end()) {
+        return cached->second;
+    }
+
+    // C++ factories take precedence.
+    auto cxxFactory = _cxxFactories.find(key);
+    if (cxxFactory != _cxxFactories.end()) {
+        auto instance = cxxFactory->second(jsInvoker);
+        if (instance) {
+            _instances[key] = instance;
+        }
+        return instance;
+    }
+
+    id _Nonnull (^objcFactory)(void) = _objcFactories[name];
+    if (objcFactory == nil) {
+        return nullptr;
+    }
+    id instance = objcFactory();
+    if (instance == nil) {
+        return nullptr;
+    }
+    if (![instance conformsToProtocol:@protocol(RCTModuleProvider)]) {
+        NSLog(@"[RNWTurboModuleRegistry] factory for '%@' returned an instance "
+              @"that does not conform to <RCTModuleProvider> — cannot build "
+              @"a TurboModule wrapper.", name);
+        return nullptr;
+    }
+    facebook::react::ObjCTurboModule::InitParams params = {
+        .moduleName = key,
+        .instance = (id<RCTBridgeModule>)instance,
+        .jsInvoker = std::move(jsInvoker),
+        .nativeMethodCallInvoker = std::move(nativeInvoker),
+        .isSyncModule = false,
+        .shouldVoidMethodsExecuteSync = false,
+    };
+    auto module = [(id<RCTModuleProvider>)instance getTurboModule:params];
+    if (module) {
+        _instances[key] = module;
+    }
+    return module;
+}
+
+@end
+
+#pragma mark - C entrypoints for RCT_EXPORT_MODULE / RNW_EXPORT_CXX_MODULE
+
+// Invoked from `+load` synthesized by `RCT_EXPORT_MODULE`.
+extern "C" void RNWRegisterTurboModuleClass(NSString *name, Class moduleClass) {
+    if (name == nil || moduleClass == Nil) {
+        return;
+    }
+    [RNWTurboModuleRegistry.shared registerModuleName:name
+                                              factory:^id {
+        return [[moduleClass alloc] init];
+    }];
+}
+
+// Invoked from `+load` synthesized by `RNW_EXPORT_CXX_MODULE`.
+extern "C" void RNWRegisterCxxTurboModule(NSString *name,
+                                          RNWTurboModuleCxxFactory factory) {
+    if (name == nil || !factory) {
+        return;
+    }
+    [RNWTurboModuleRegistry.shared registerCxxModuleNamed:name
+                                                  factory:std::move(factory)];
+}

package/apple/Sources/ReactNativeWatchOSCxx/RNWUIManager.h

@@ -0,0 +1,19 @@
+#import <Foundation/Foundation.h>
+#import "ReactNativeWatchOSCxx/RNWShadowNode.h"
+
+#import <ReactCommon/CallInvoker.h>
+#import <jsi/jsi.h>
+
+#include <memory>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Install `__RNW_UI` on `globalThis`. Owns the C++ shadow-tree registry
+/// driven by the JS reconciler. On `completeRoot`, deep-copies the mutable
+/// tree into immutable snapshots and invokes `onCommit` on the main queue.
+void rnwInstallUIManager(
+    facebook::jsi::Runtime &rt,
+    std::shared_ptr<facebook::react::CallInvoker> jsInvoker,
+    void (^onCommit)(NSArray<RNWShadowNodeSnapshot *> *root));
+
+NS_ASSUME_NONNULL_END

package/apple/Sources/ReactNativeWatchOSCxx/RNWUIManager.mm

@@ -0,0 +1,383 @@
+#import "RNWUIManager.h"
+
+#import <ReactCommon/RCTTurboModule.h>
+
+#include <algorithm>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace jsi = facebook::jsi;
+using facebook::react::CallInvoker;
+using facebook::react::TurboModuleConvertUtils::convertJSIValueToObjCObject;
+
+namespace {
+
+using Tag = uint32_t;
+
+struct MutableNode {
+    Tag tag = 0;
+    RNWNodeKind kind = RNWNodeKindView;
+    NSString *viewName = nil;
+    NSDictionary<NSString *, id> *props = nil;
+    NSArray<NSDictionary<NSString *, id> *> *modifiers = nil;
+    NSDictionary<NSString *, NSNumber *> *eventHandlers = nil;
+    std::string text;
+    std::vector<Tag> children;
+};
+
+struct Registry {
+    std::unordered_map<Tag, std::shared_ptr<MutableNode>> nodes;
+    std::vector<Tag> rootChildren;
+    Tag nextTag = 1;
+};
+
+bool isEventHandlerKey(NSString *key) {
+    if (key.length < 3) return false;
+    if ([key characterAtIndex:0] != 'o') return false;
+    if ([key characterAtIndex:1] != 'n') return false;
+    unichar c = [key characterAtIndex:2];
+    return c >= 'A' && c <= 'Z';
+}
+
+struct ParsedProps {
+    NSDictionary<NSString *, id> *props;
+    NSArray<NSDictionary<NSString *, id> *> *modifiers;
+    NSDictionary<NSString *, NSNumber *> *eventHandlers;
+};
+
+// `children` and `$$typeof`-carrying values are dropped: React Fibers carry
+// parent pointers that form cycles, so recursing into them via
+// `convertJSIValueToObjCObject` blows the stack. Siblings already reach the
+// tree through `appendChild`.
+ParsedProps parseProps(jsi::Runtime &rt,
+                       const jsi::Value &value,
+                       const std::shared_ptr<CallInvoker> &jsInvoker) {
+    ParsedProps out = { @{}, @[], @{} };
+    if (!value.isObject()) return out;
+    jsi::Object obj = value.getObject(rt);
+    if (obj.isFunction(rt) || obj.isArray(rt)) return out;
+
+    NSMutableDictionary<NSString *, id> *props = [NSMutableDictionary dictionary];
+    NSMutableDictionary<NSString *, NSNumber *> *events =
+        [NSMutableDictionary dictionary];
+    NSArray *modifiers = @[];
+
+    jsi::Array names = obj.getPropertyNames(rt);
+    size_t n = names.size(rt);
+    for (size_t i = 0; i < n; ++i) {
+        std::string keyStr =
+            names.getValueAtIndex(rt, i).getString(rt).utf8(rt);
+
+        if (keyStr == "children") continue;
+
+        NSString *key = [NSString stringWithUTF8String:keyStr.c_str()];
+        jsi::Value v = obj.getProperty(rt, keyStr.c_str());
+
+        if (keyStr == "modifiers") {
+            id arr = convertJSIValueToObjCObject(rt, v, jsInvoker, NO);
+            if ([arr isKindOfClass:[NSArray class]]) {
+                modifiers = (NSArray *)arr;
+            }
+            continue;
+        }
+        if (isEventHandlerKey(key) && v.isNumber()) {
+            events[key] = @(v.getNumber());
+            continue;
+        }
+        if (v.isObject() && v.getObject(rt).hasProperty(rt, "$$typeof")) {
+            continue;
+        }
+
+        id converted = convertJSIValueToObjCObject(rt, v, jsInvoker, NO);
+        if (converted != nil) {
+            props[key] = converted;
+        }
+    }
+
+    out.props = props;
+    out.modifiers = modifiers;
+    out.eventHandlers = events;
+    return out;
+}
+
+RNWShadowNodeSnapshot *snapshotNode(const Registry &reg, Tag tag) {
+    auto it = reg.nodes.find(tag);
+    if (it == reg.nodes.end()) return nil;
+    const MutableNode &n = *it->second;
+
+    NSMutableArray<RNWShadowNodeSnapshot *> *children =
+        [NSMutableArray arrayWithCapacity:n.children.size()];
+    for (Tag childTag : n.children) {
+        RNWShadowNodeSnapshot *child = snapshotNode(reg, childTag);
+        if (child != nil) {
+            [children addObject:child];
+        }
+    }
+
+    NSString *text = nil;
+    if (n.kind == RNWNodeKindRawText) {
+        text = [NSString stringWithUTF8String:n.text.c_str()];
+    }
+
+    return [[RNWShadowNodeSnapshot alloc] initWithTag:(NSInteger)tag
+                                                 kind:n.kind
+                                             viewName:n.viewName
+                                                props:n.props
+                                            modifiers:n.modifiers
+                                        eventHandlers:n.eventHandlers
+                                                 text:text
+                                             children:children];
+}
+
+template <typename F>
+void installFn(jsi::Runtime &rt,
+               jsi::Object &target,
+               const char *name,
+               unsigned paramCount,
+               F &&fn) {
+    target.setProperty(
+        rt,
+        name,
+        jsi::Function::createFromHostFunction(
+            rt,
+            jsi::PropNameID::forAscii(rt, name),
+            paramCount,
+            std::forward<F>(fn)));
+}
+
+// Reconciler removes a subtree by only unlinking the top — descendants must
+// be reclaimed here or they leak.
+void eraseSubtree(Registry &reg, Tag tag) {
+    auto it = reg.nodes.find(tag);
+    if (it == reg.nodes.end()) return;
+    // Copy before erasing the parent — it owns the vector.
+    std::vector<Tag> children = it->second->children;
+    reg.nodes.erase(it);
+    for (Tag child : children) {
+        eraseSubtree(reg, child);
+    }
+}
+
+} // namespace
+
+void rnwInstallUIManager(jsi::Runtime &rt,
+                         std::shared_ptr<CallInvoker> jsInvoker,
+                         void (^onCommit)(NSArray<RNWShadowNodeSnapshot *> *)) {
+    auto reg = std::make_shared<Registry>();
+    void (^commit)(NSArray<RNWShadowNodeSnapshot *> *) = [onCommit copy];
+
+    jsi::Object api(rt);
+
+    installFn(rt, api, "createNode", 2,
+        [reg, jsInvoker](jsi::Runtime &rt,
+                         const jsi::Value &,
+                         const jsi::Value *args,
+                         size_t count) -> jsi::Value {
+            if (count < 2 || !args[0].isString()) {
+                throw jsi::JSError(rt, "createNode: expected (string, object)");
+            }
+            std::string type = args[0].getString(rt).utf8(rt);
+            ParsedProps parsed = parseProps(rt, args[1], jsInvoker);
+
+            auto node = std::make_shared<MutableNode>();
+            node->tag = reg->nextTag++;
+            node->kind = RNWNodeKindView;
+            node->viewName = [NSString stringWithUTF8String:type.c_str()];
+            node->props = parsed.props;
+            node->modifiers = parsed.modifiers;
+            node->eventHandlers = parsed.eventHandlers;
+            reg->nodes.emplace(node->tag, node);
+            return jsi::Value(static_cast<double>(node->tag));
+        });
+
+    installFn(rt, api, "createTextNode", 1,
+        [reg](jsi::Runtime &rt,
+              const jsi::Value &,
+              const jsi::Value *args,
+              size_t count) -> jsi::Value {
+            if (count < 1 || !args[0].isString()) {
+                throw jsi::JSError(rt, "createTextNode: expected (string)");
+            }
+            auto node = std::make_shared<MutableNode>();
+            node->tag = reg->nextTag++;
+            node->kind = RNWNodeKindRawText;
+            node->text = args[0].getString(rt).utf8(rt);
+            reg->nodes.emplace(node->tag, node);
+            return jsi::Value(static_cast<double>(node->tag));
+        });
+
+    installFn(rt, api, "updateNodeProps", 2,
+        [reg, jsInvoker](jsi::Runtime &rt,
+                         const jsi::Value &,
+                         const jsi::Value *args,
+                         size_t count) -> jsi::Value {
+            if (count < 2 || !args[0].isNumber()) return jsi::Value::undefined();
+            Tag tag = static_cast<Tag>(args[0].getNumber());
+            auto it = reg->nodes.find(tag);
+            if (it == reg->nodes.end()) return jsi::Value::undefined();
+            MutableNode &n = *it->second;
+            if (n.kind != RNWNodeKindView) return jsi::Value::undefined();
+            ParsedProps parsed = parseProps(rt, args[1], jsInvoker);
+            n.props = parsed.props;
+            n.modifiers = parsed.modifiers;
+            n.eventHandlers = parsed.eventHandlers;
+            return jsi::Value::undefined();
+        });
+
+    installFn(rt, api, "updateTextNode", 2,
+        [reg](jsi::Runtime &rt,
+              const jsi::Value &,
+              const jsi::Value *args,
+              size_t count) -> jsi::Value {
+            if (count < 2 || !args[0].isNumber() || !args[1].isString()) {
+                return jsi::Value::undefined();
+            }
+            Tag tag = static_cast<Tag>(args[0].getNumber());
+            auto it = reg->nodes.find(tag);
+            if (it == reg->nodes.end()) return jsi::Value::undefined();
+            it->second->text = args[1].getString(rt).utf8(rt);
+            return jsi::Value::undefined();
+        });
+
+    installFn(rt, api, "appendChild", 2,
+        [reg](jsi::Runtime &rt,
+              const jsi::Value &,
+              const jsi::Value *args,
+              size_t count) -> jsi::Value {
+            if (count < 2 || !args[0].isNumber() || !args[1].isNumber()) {
+                return jsi::Value::undefined();
+            }
+            Tag parent = static_cast<Tag>(args[0].getNumber());
+            Tag child  = static_cast<Tag>(args[1].getNumber());
+            auto it = reg->nodes.find(parent);
+            if (it == reg->nodes.end()) return jsi::Value::undefined();
+            // Reparenting: detach from previous position first.
+            auto &siblings = it->second->children;
+            siblings.erase(
+                std::remove(siblings.begin(), siblings.end(), child),
+                siblings.end());
+            siblings.push_back(child);
+            (void)rt;
+            return jsi::Value::undefined();
+        });
+
+    installFn(rt, api, "insertBefore", 3,
+        [reg](jsi::Runtime &rt,
+              const jsi::Value &,
+              const jsi::Value *args,
+              size_t count) -> jsi::Value {
+            if (count < 3 || !args[0].isNumber() || !args[1].isNumber() ||
+                !args[2].isNumber()) {
+                return jsi::Value::undefined();
+            }
+            Tag parent = static_cast<Tag>(args[0].getNumber());
+            Tag child  = static_cast<Tag>(args[1].getNumber());
+            Tag before = static_cast<Tag>(args[2].getNumber());
+            auto it = reg->nodes.find(parent);
+            if (it == reg->nodes.end()) return jsi::Value::undefined();
+            auto &siblings = it->second->children;
+            // Reparenting/reorder: detach first.
+            siblings.erase(
+                std::remove(siblings.begin(), siblings.end(), child),
+                siblings.end());
+            auto pos = std::find(siblings.begin(), siblings.end(), before);
+            siblings.insert(pos, child);
+            (void)rt;
+            return jsi::Value::undefined();
+        });
+
+    installFn(rt, api, "removeChild", 2,
+        [reg](jsi::Runtime &rt,
+              const jsi::Value &,
+              const jsi::Value *args,
+              size_t count) -> jsi::Value {
+            if (count < 2 || !args[0].isNumber() || !args[1].isNumber()) {
+                return jsi::Value::undefined();
+            }
+            Tag parent = static_cast<Tag>(args[0].getNumber());
+            Tag child  = static_cast<Tag>(args[1].getNumber());
+            auto it = reg->nodes.find(parent);
+            if (it != reg->nodes.end()) {
+                auto &siblings = it->second->children;
+                siblings.erase(
+                    std::remove(siblings.begin(), siblings.end(), child),
+                    siblings.end());
+            }
+            eraseSubtree(*reg, child);
+            (void)rt;
+            return jsi::Value::undefined();
+        });
+
+    installFn(rt, api, "appendToRoot", 1,
+        [reg](jsi::Runtime &rt,
+              const jsi::Value &,
+              const jsi::Value *args,
+              size_t count) -> jsi::Value {
+            if (count < 1 || !args[0].isNumber()) return jsi::Value::undefined();
+            Tag child = static_cast<Tag>(args[0].getNumber());
+            auto &roots = reg->rootChildren;
+            roots.erase(std::remove(roots.begin(), roots.end(), child),
+                        roots.end());
+            roots.push_back(child);
+            (void)rt;
+            return jsi::Value::undefined();
+        });
+
+    installFn(rt, api, "removeFromRoot", 1,
+        [reg](jsi::Runtime &rt,
+              const jsi::Value &,
+              const jsi::Value *args,
+              size_t count) -> jsi::Value {
+            if (count < 1 || !args[0].isNumber()) return jsi::Value::undefined();
+            Tag child = static_cast<Tag>(args[0].getNumber());
+            auto &roots = reg->rootChildren;
+            roots.erase(std::remove(roots.begin(), roots.end(), child),
+                        roots.end());
+            eraseSubtree(*reg, child);
+            (void)rt;
+            return jsi::Value::undefined();
+        });
+
+    installFn(rt, api, "clearRoot", 0,
+        [reg](jsi::Runtime &rt,
+              const jsi::Value &,
+              const jsi::Value *,
+              size_t) -> jsi::Value {
+            std::vector<Tag> roots = reg->rootChildren;
+            reg->rootChildren.clear();
+            for (Tag t : roots) {
+                eraseSubtree(*reg, t);
+            }
+            (void)rt;
+            return jsi::Value::undefined();
+        });
+
+    // Snapshot the mutable tree and dispatch onto main — SwiftUI state
+    // updates must happen there.
+    installFn(rt, api, "completeRoot", 0,
+        [reg, commit](jsi::Runtime &rt,
+                      const jsi::Value &,
+                      const jsi::Value *,
+                      size_t) -> jsi::Value {
+            NSMutableArray<RNWShadowNodeSnapshot *> *snap =
+                [NSMutableArray arrayWithCapacity:reg->rootChildren.size()];
+            for (Tag t : reg->rootChildren) {
+                RNWShadowNodeSnapshot *node = snapshotNode(*reg, t);
+                if (node != nil) {
+                    [snap addObject:node];
+                }
+            }
+            if (commit != nil) {
+                dispatch_async(dispatch_get_main_queue(), ^{
+                    commit(snap);
+                });
+            }
+            (void)rt;
+            return jsi::Value::undefined();
+        });
+
+    rt.global().setProperty(rt, "__RNW_UI", api);
+}

package/apple/Sources/ReactNativeWatchOSCxx/RNWWebSocket.h

@@ -0,0 +1,20 @@
+// Private — not in the XCFramework Headers/ or modulemap. C++/ObjC++ glue;
+// exposing to Swift would drag `jsi::Runtime &` across the bridge.
+
+#import <Foundation/Foundation.h>
+
+#import <jsi/jsi.h>
+
+#include "RNWCallInvoker.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Install a minimal WHATWG-shaped `WebSocket` on `globalThis`, backed by
+/// `NSURLSessionWebSocketTask`. Surface is what Metro's HMRClient calls:
+/// `new WebSocket(url)`, `onopen`/`onmessage`/`onerror`/`onclose`,
+/// `send(string)`, `close()`. Binary frames and `addEventListener` are not
+/// implemented; `send(ArrayBuffer)` falls back to UTF-8 decoding.
+void rnwInstallWebSocket(facebook::jsi::Runtime &rt,
+                         facebook::react::RNWJSQueue jsQueue);
+
+NS_ASSUME_NONNULL_END