@thelacanians/vue-native-cli 0.4.14 → 0.6.0

package/native/shared/VueNativeShared/Sources/VueNativeShared/Modules/WebSocketModule.swift

@@ -0,0 +1,212 @@
+import Foundation
+
+/// Native module for WebSocket connections.
+/// Uses URLSession which is available on both iOS and macOS.
+///
+/// Supports multiple simultaneous connections keyed by connection ID.
+///
+/// Methods:
+///   - connect(url: String, connectionId: String)
+///   - send(connectionId: String, data: String)
+///   - close(connectionId: String, code: Int?, reason: String?)
+///
+/// Global events dispatched via NativeEventDispatcher:
+///   "websocket:open"    { connectionId }
+///   "websocket:message" { connectionId, data }
+///   "websocket:close"   { connectionId, code, reason }
+///   "websocket:error"   { connectionId, message }
+public final class WebSocketModule: NativeModule {
+    public var moduleName: String { "WebSocket" }
+    private weak var eventDispatcher: NativeEventDispatcher?
+
+    /// Active WebSocket tasks keyed by connectionId
+    private var connections: [String: URLSessionWebSocketTask] = [:]
+    private var sessions: [String: URLSession] = [:]
+
+    public init(eventDispatcher: NativeEventDispatcher) {
+        self.eventDispatcher = eventDispatcher
+    }
+
+    public func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        switch method {
+        case "connect":
+            guard let url = args.first as? String,
+                  let connectionId = args.count > 1 ? args[1] as? String : nil else {
+                callback(nil, "WebSocketModule: expected (url, connectionId)")
+                return
+            }
+            connect(url: url, connectionId: connectionId, callback: callback)
+
+        case "send":
+            guard let connectionId = args.first as? String,
+                  let data = args.count > 1 ? args[1] as? String : nil else {
+                callback(nil, "WebSocketModule: expected (connectionId, data)")
+                return
+            }
+            send(connectionId: connectionId, data: data, callback: callback)
+
+        case "close":
+            guard let connectionId = args.first as? String else {
+                callback(nil, "WebSocketModule: expected (connectionId)")
+                return
+            }
+            let code = args.count > 1 ? args[1] as? Int : nil
+            let reason = args.count > 2 ? args[2] as? String : nil
+            close(connectionId: connectionId, code: code, reason: reason, callback: callback)
+
+        default:
+            callback(nil, "WebSocketModule: Unknown method '\(method)'")
+        }
+    }
+
+    // MARK: - Connect
+
+    private func connect(url: String, connectionId: String, callback: @escaping (Any?, String?) -> Void) {
+        guard let wsURL = URL(string: url) else {
+            callback(nil, "WebSocketModule: invalid URL '\(url)'")
+            return
+        }
+
+        // Clean up existing connection with same ID if any
+        closeConnection(connectionId)
+
+        let session = URLSession(configuration: .default)
+        let task = session.webSocketTask(with: wsURL)
+        connections[connectionId] = task
+        sessions[connectionId] = session
+
+        task.resume()
+
+        // Dispatch open event once resumed
+        let weakDispatcher = eventDispatcher
+        DispatchQueue.main.async {
+            weakDispatcher?.dispatchGlobalEvent("websocket:open", payload: [
+                "connectionId": connectionId
+            ])
+        }
+
+        // Start receive loop
+        receiveLoop(connectionId: connectionId, task: task)
+
+        callback(true, nil)
+    }
+
+    // MARK: - Receive loop
+
+    private func receiveLoop(connectionId: String, task: URLSessionWebSocketTask) {
+        task.receive { [weak self] result in
+            guard let self = self else { return }
+            // Check if connection still exists (may have been closed)
+            guard self.connections[connectionId] != nil else { return }
+
+            switch result {
+            case .success(let message):
+                let data: String
+                switch message {
+                case .string(let text):
+                    data = text
+                case .data(let bytes):
+                    data = String(data: bytes, encoding: .utf8) ?? ""
+                @unknown default:
+                    data = ""
+                }
+
+                let weakDispatcher = self.eventDispatcher
+                DispatchQueue.main.async {
+                    weakDispatcher?.dispatchGlobalEvent("websocket:message", payload: [
+                        "connectionId": connectionId,
+                        "data": data
+                    ])
+                }
+
+                // Continue receiving
+                self.receiveLoop(connectionId: connectionId, task: task)
+
+            case .failure(let error):
+                let weakDispatcher = self.eventDispatcher
+                let errorMessage = error.localizedDescription
+                DispatchQueue.main.async {
+                    // Check if this is a normal close or an actual error
+                    let nsError = error as NSError
+                    if nsError.domain == NSPOSIXErrorDomain && nsError.code == 57 {
+                        // Socket not connected — normal close, dispatch close event
+                        weakDispatcher?.dispatchGlobalEvent("websocket:close", payload: [
+                            "connectionId": connectionId,
+                            "code": 1000,
+                            "reason": ""
+                        ])
+                    } else {
+                        weakDispatcher?.dispatchGlobalEvent("websocket:error", payload: [
+                            "connectionId": connectionId,
+                            "message": errorMessage
+                        ])
+                        weakDispatcher?.dispatchGlobalEvent("websocket:close", payload: [
+                            "connectionId": connectionId,
+                            "code": 1006,
+                            "reason": errorMessage
+                        ])
+                    }
+                }
+                self.connections.removeValue(forKey: connectionId)
+                self.sessions[connectionId]?.invalidateAndCancel()
+                self.sessions.removeValue(forKey: connectionId)
+            }
+        }
+    }
+
+    // MARK: - Send
+
+    private func send(connectionId: String, data: String, callback: @escaping (Any?, String?) -> Void) {
+        guard let task = connections[connectionId] else {
+            callback(nil, "WebSocketModule: no connection '\(connectionId)'")
+            return
+        }
+        task.send(.string(data)) { error in
+            if let error = error {
+                callback(nil, error.localizedDescription)
+            } else {
+                callback(true, nil)
+            }
+        }
+    }
+
+    // MARK: - Close
+
+    private func close(connectionId: String, code: Int?, reason: String?, callback: @escaping (Any?, String?) -> Void) {
+        guard let task = connections[connectionId] else {
+            callback(nil, nil) // Already closed, not an error
+            return
+        }
+
+        let closeCode = URLSessionWebSocketTask.CloseCode(rawValue: code ?? 1000) ?? .normalClosure
+        let reasonData = reason?.data(using: .utf8)
+        task.cancel(with: closeCode, reason: reasonData)
+
+        let weakDispatcher = eventDispatcher
+        DispatchQueue.main.async {
+            weakDispatcher?.dispatchGlobalEvent("websocket:close", payload: [
+                "connectionId": connectionId,
+                "code": code ?? 1000,
+                "reason": reason ?? ""
+            ])
+        }
+
+        connections.removeValue(forKey: connectionId)
+        sessions[connectionId]?.invalidateAndCancel()
+        sessions.removeValue(forKey: connectionId)
+
+        callback(true, nil)
+    }
+
+    // MARK: - Helpers
+
+    private func closeConnection(_ connectionId: String) {
+        guard let task = connections[connectionId] else { return }
+        task.cancel(with: .normalClosure, reason: nil)
+        connections.removeValue(forKey: connectionId)
+        sessions[connectionId]?.invalidateAndCancel()
+        sessions.removeValue(forKey: connectionId)
+    }
+
+    public func invokeSync(method: String, args: [Any]) -> Any? { nil }
+}

package/native/shared/VueNativeShared/Sources/VueNativeShared/NativeEventDispatcher.swift

@@ -0,0 +1,6 @@
+import Foundation
+
+/// Protocol for dispatching events back to JS. Platform-specific bridges conform to this.
+public protocol NativeEventDispatcher: AnyObject {
+    func dispatchGlobalEvent(_ eventName: String, payload: [String: Any])
+}

package/native/shared/VueNativeShared/Sources/VueNativeShared/NativeModule.swift

@@ -0,0 +1,26 @@
+import Foundation
+
+/// Protocol that all native modules must conform to.
+/// Modules are registered with NativeModuleRegistry and invoked from JS
+/// via the platform-specific bridge's invokeNativeModule / invokeNativeModuleSync operations.
+public protocol NativeModule: AnyObject {
+    /// The name used to identify this module from JS (e.g. "Haptics", "AsyncStorage").
+    var moduleName: String { get }
+
+    /// Invoke a method asynchronously.
+    /// - Parameters:
+    ///   - method: The method name to invoke.
+    ///   - args: Arguments passed from JS.
+    ///   - callback: Called when the method completes. Pass (result, nil) on success,
+    ///               (nil, errorMessage) on failure.
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void)
+
+    /// Invoke a method synchronously and return the result.
+    /// Use sparingly — prefer the async variant.
+    func invokeSync(method: String, args: [Any]) -> Any?
+}
+
+public extension NativeModule {
+    /// Default sync implementation: just returns nil.
+    func invokeSync(method: String, args: [Any]) -> Any? { return nil }
+}

package/native/shared/VueNativeShared/Sources/VueNativeShared/NativeModuleRegistry.swift

@@ -0,0 +1,37 @@
+import Foundation
+
+/// Registry for all native modules.
+/// Modules are registered by name and looked up when JS invokes them.
+/// Each platform registers its own set of modules — there is no `registerDefaults()` here.
+public final class NativeModuleRegistry {
+
+    public static let shared = NativeModuleRegistry()
+
+    private var modules: [String: NativeModule] = [:]
+
+    private init() {}
+
+    // MARK: - Registration
+
+    public func register(_ module: NativeModule) {
+        modules[module.moduleName] = module
+    }
+
+    // MARK: - Invocation
+
+    public func invoke(module moduleName: String, method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        guard let module = modules[moduleName] else {
+            callback(nil, "Module '\(moduleName)' not found")
+            return
+        }
+        module.invoke(method: method, args: args, callback: callback)
+    }
+
+    public func invokeSync(module moduleName: String, method: String, args: [Any]) -> Any? {
+        guard let module = modules[moduleName] else {
+            NSLog("[VueNative] NativeModuleRegistry: Module '\(moduleName)' not found")
+            return nil
+        }
+        return module.invokeSync(method: method, args: args)
+    }
+}