@thelacanians/vue-native-cli 0.4.15 → 0.6.2

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

@@ -0,0 +1,233 @@
+import Foundation
+
+/// Native module providing file system access.
+///
+/// Methods:
+///   - readFile(path: String, encoding: String?) -> String
+///   - writeFile(path: String, content: String, encoding: String?)
+///   - deleteFile(path: String)
+///   - exists(path: String) -> Bool
+///   - listDirectory(path: String) -> [String]
+///   - downloadFile(url: String, destPath: String) -> String
+///   - getDocumentsPath() -> String
+///   - getCachesPath() -> String
+///   - stat(path: String) -> { size, isDirectory, modified }
+///   - mkdir(path: String)
+///   - copyFile(srcPath: String, destPath: String)
+///   - moveFile(srcPath: String, destPath: String)
+public final class FileSystemModule: NativeModule {
+    public let moduleName = "FileSystem"
+
+    private let fileManager = FileManager.default
+
+    public init() {}
+
+    public func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            guard let self = self else { return }
+            switch method {
+            case "readFile":
+                guard let path = args.first as? String else {
+                    callback(nil, "readFile: missing path")
+                    return
+                }
+                let encoding = (args.count > 1 ? args[1] as? String : nil) ?? "utf8"
+                guard self.fileManager.fileExists(atPath: path) else {
+                    callback(nil, "readFile: file not found at \(path)")
+                    return
+                }
+                guard let data = self.fileManager.contents(atPath: path) else {
+                    callback(nil, "readFile: could not read file at \(path)")
+                    return
+                }
+                if encoding == "base64" {
+                    callback(data.base64EncodedString(), nil)
+                } else {
+                    guard let text = String(data: data, encoding: .utf8) else {
+                        callback(nil, "readFile: file is not valid UTF-8")
+                        return
+                    }
+                    callback(text, nil)
+                }
+
+            case "writeFile":
+                guard args.count >= 2,
+                      let path = args[0] as? String,
+                      let content = args[1] as? String else {
+                    callback(nil, "writeFile: missing path or content")
+                    return
+                }
+                let encoding = (args.count > 2 ? args[2] as? String : nil) ?? "utf8"
+                let data: Data?
+                if encoding == "base64" {
+                    data = Data(base64Encoded: content)
+                } else {
+                    data = content.data(using: .utf8)
+                }
+                guard let fileData = data else {
+                    callback(nil, "writeFile: could not encode content")
+                    return
+                }
+                // Create parent directory if needed
+                let dir = (path as NSString).deletingLastPathComponent
+                if !self.fileManager.fileExists(atPath: dir) {
+                    do {
+                        try self.fileManager.createDirectory(atPath: dir, withIntermediateDirectories: true)
+                    } catch {
+                        callback(nil, "writeFile: could not create directory: \(error.localizedDescription)")
+                        return
+                    }
+                }
+                self.fileManager.createFile(atPath: path, contents: fileData)
+                callback(nil, nil)
+
+            case "deleteFile":
+                guard let path = args.first as? String else {
+                    callback(nil, "deleteFile: missing path")
+                    return
+                }
+                guard self.fileManager.fileExists(atPath: path) else {
+                    callback(nil, "deleteFile: file not found at \(path)")
+                    return
+                }
+                do {
+                    try self.fileManager.removeItem(atPath: path)
+                    callback(nil, nil)
+                } catch {
+                    callback(nil, "deleteFile: \(error.localizedDescription)")
+                }
+
+            case "exists":
+                guard let path = args.first as? String else {
+                    callback(nil, "exists: missing path")
+                    return
+                }
+                callback(self.fileManager.fileExists(atPath: path), nil)
+
+            case "listDirectory":
+                guard let path = args.first as? String else {
+                    callback(nil, "listDirectory: missing path")
+                    return
+                }
+                do {
+                    let contents = try self.fileManager.contentsOfDirectory(atPath: path)
+                    callback(contents, nil)
+                } catch {
+                    callback(nil, "listDirectory: \(error.localizedDescription)")
+                }
+
+            case "downloadFile":
+                guard args.count >= 2,
+                      let urlString = args[0] as? String,
+                      let destPath = args[1] as? String else {
+                    callback(nil, "downloadFile: missing url or destPath")
+                    return
+                }
+                guard let url = URL(string: urlString) else {
+                    callback(nil, "downloadFile: invalid URL")
+                    return
+                }
+                let task = URLSession.shared.dataTask(with: url) { data, response, error in
+                    if let error = error {
+                        callback(nil, "downloadFile: \(error.localizedDescription)")
+                        return
+                    }
+                    guard let data = data else {
+                        callback(nil, "downloadFile: no data received")
+                        return
+                    }
+                    // Create parent directory if needed
+                    let dir = (destPath as NSString).deletingLastPathComponent
+                    if !self.fileManager.fileExists(atPath: dir) {
+                        do {
+                            try self.fileManager.createDirectory(atPath: dir, withIntermediateDirectories: true)
+                        } catch {
+                            callback(nil, "downloadFile: could not create directory: \(error.localizedDescription)")
+                            return
+                        }
+                    }
+                    self.fileManager.createFile(atPath: destPath, contents: data)
+                    callback(destPath, nil)
+                }
+                task.resume()
+
+            case "getDocumentsPath":
+                let paths = NSSearchPathForDirectoriesInDomains(.documentDirectory, .userDomainMask, true)
+                callback(paths.first, nil)
+
+            case "getCachesPath":
+                let paths = NSSearchPathForDirectoriesInDomains(.cachesDirectory, .userDomainMask, true)
+                callback(paths.first, nil)
+
+            case "stat":
+                guard let path = args.first as? String else {
+                    callback(nil, "stat: missing path")
+                    return
+                }
+                do {
+                    let attrs = try self.fileManager.attributesOfItem(atPath: path)
+                    let size = (attrs[.size] as? Int) ?? 0
+                    let isDir = (attrs[.type] as? FileAttributeType) == .typeDirectory
+                    let modified = (attrs[.modificationDate] as? Date)?.timeIntervalSince1970 ?? 0
+                    callback([
+                        "size": size,
+                        "isDirectory": isDir,
+                        "modified": modified * 1000 // milliseconds for JS
+                    ] as [String: Any], nil)
+                } catch {
+                    callback(nil, "stat: \(error.localizedDescription)")
+                }
+
+            case "mkdir":
+                guard let path = args.first as? String else {
+                    callback(nil, "mkdir: missing path")
+                    return
+                }
+                do {
+                    try self.fileManager.createDirectory(atPath: path, withIntermediateDirectories: true)
+                    callback(nil, nil)
+                } catch {
+                    callback(nil, "mkdir: \(error.localizedDescription)")
+                }
+
+            case "copyFile":
+                guard args.count >= 2,
+                      let srcPath = args[0] as? String,
+                      let destPath = args[1] as? String else {
+                    callback(nil, "copyFile: missing srcPath or destPath")
+                    return
+                }
+                do {
+                    // Remove destination if it exists (copyItem throws if dest exists)
+                    if self.fileManager.fileExists(atPath: destPath) {
+                        try self.fileManager.removeItem(atPath: destPath)
+                    }
+                    try self.fileManager.copyItem(atPath: srcPath, toPath: destPath)
+                    callback(nil, nil)
+                } catch {
+                    callback(nil, "copyFile: \(error.localizedDescription)")
+                }
+
+            case "moveFile":
+                guard args.count >= 2,
+                      let srcPath = args[0] as? String,
+                      let destPath = args[1] as? String else {
+                    callback(nil, "moveFile: missing srcPath or destPath")
+                    return
+                }
+                do {
+                    if self.fileManager.fileExists(atPath: destPath) {
+                        try self.fileManager.removeItem(atPath: destPath)
+                    }
+                    try self.fileManager.moveItem(atPath: srcPath, toPath: destPath)
+                    callback(nil, nil)
+                } catch {
+                    callback(nil, "moveFile: \(error.localizedDescription)")
+                }
+
+            default:
+                callback(nil, "FileSystemModule: Unknown method '\(method)'")
+            }
+        }
+    }
+}

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

@@ -0,0 +1,156 @@
+import Foundation
+import CoreLocation
+
+/// Native module for GPS/location access.
+/// Uses CoreLocation which is available on both iOS and macOS.
+///
+/// Methods:
+///   - getCurrentPosition() -> location payload
+///   - watchPosition() -> watchId (Int); fires "location:update" global events
+///   - clearWatch(watchId: Int)
+///
+/// Location payload keys: latitude, longitude, altitude, accuracy,
+///                        altitudeAccuracy, heading, speed, timestamp
+public final class GeolocationModule: NativeModule {
+    public var moduleName: String { "Geolocation" }
+    private weak var eventDispatcher: NativeEventDispatcher?
+
+    public init(eventDispatcher: NativeEventDispatcher) {
+        self.eventDispatcher = eventDispatcher
+    }
+
+    public func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        switch method {
+        case "getCurrentPosition":
+            DispatchQueue.main.async {
+                GeolocationManager.shared.getCurrentPosition(callback: callback)
+            }
+        case "watchPosition":
+            let weakDispatcher = eventDispatcher
+            DispatchQueue.main.async {
+                let watchId = GeolocationManager.shared.watchPosition(eventDispatcher: weakDispatcher)
+                callback(watchId, nil)
+            }
+        case "clearWatch":
+            guard let watchId = args.first.flatMap({ $0 as? Int }) else {
+                callback(nil, nil); return
+            }
+            DispatchQueue.main.async {
+                GeolocationManager.shared.clearWatch(watchId)
+                callback(nil, nil)
+            }
+        default:
+            callback(nil, "GeolocationModule: Unknown method '\(method)'")
+        }
+    }
+
+    public func invokeSync(method: String, args: [Any]) -> Any? { nil }
+}
+
+// MARK: - Internal location manager
+
+/// All CLLocationManager interactions happen on @MainActor (main thread),
+/// matching the CoreLocation threading requirement.
+@MainActor
+private final class GeolocationManager: NSObject, CLLocationManagerDelegate {
+    static let shared = GeolocationManager()
+
+    private var manager: CLLocationManager?
+    private var pendingCallbacks: [(Any?, String?) -> Void] = []
+
+    // Map watchId -> weak event dispatcher reference
+    private struct WeakDispatcher { weak var dispatcher: NativeEventDispatcher? }
+    private var watchCallbacks: [Int: WeakDispatcher] = [:]
+    private var nextWatchId = 1
+
+    // MARK: Setup
+
+    private func ensureManager() {
+        guard manager == nil else { return }
+        let mgr = CLLocationManager()
+        mgr.delegate = self
+        mgr.desiredAccuracy = kCLLocationAccuracyBest
+        manager = mgr
+    }
+
+    // MARK: Public interface (called on main thread)
+
+    private func isAuthorized(_ status: CLAuthorizationStatus) -> Bool {
+        if status == .authorizedAlways { return true }
+        #if os(iOS)
+        if status == .authorizedWhenInUse { return true }
+        #endif
+        // On macOS, .authorized maps to .authorizedAlways — already covered above
+        return false
+    }
+
+    func getCurrentPosition(callback: @escaping (Any?, String?) -> Void) {
+        ensureManager()
+        guard let manager = manager else {
+            callback(nil, "Failed to initialize location manager"); return
+        }
+        let status = manager.authorizationStatus
+        guard isAuthorized(status) else {
+            callback(nil, "Location permission not granted"); return
+        }
+        pendingCallbacks.append(callback)
+        manager.requestLocation()
+    }
+
+    func watchPosition(eventDispatcher: NativeEventDispatcher?) -> Int {
+        ensureManager()
+        guard let manager = manager else {
+            return -1
+        }
+        let status = manager.authorizationStatus
+        guard isAuthorized(status) else {
+            return -1
+        }
+        let watchId = nextWatchId; nextWatchId += 1
+        watchCallbacks[watchId] = WeakDispatcher(dispatcher: eventDispatcher)
+        manager.startUpdatingLocation()
+        return watchId
+    }
+
+    func clearWatch(_ watchId: Int) {
+        watchCallbacks.removeValue(forKey: watchId)
+        if watchCallbacks.isEmpty {
+            manager?.stopUpdatingLocation()
+        }
+    }
+
+    // MARK: CLLocationManagerDelegate
+    // nonisolated required by protocol; we hop to @MainActor via Task.
+
+    nonisolated func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
+        guard let loc = locations.last else { return }
+        let payload: [String: Any] = [
+            "latitude": loc.coordinate.latitude,
+            "longitude": loc.coordinate.longitude,
+            "altitude": loc.altitude,
+            "accuracy": loc.horizontalAccuracy,
+            "altitudeAccuracy": loc.verticalAccuracy,
+            "heading": loc.course,
+            "speed": loc.speed,
+            "timestamp": loc.timestamp.timeIntervalSince1970 * 1000
+        ]
+        Task { @MainActor in
+            // Fire one-shot callbacks
+            let cbs = self.pendingCallbacks
+            self.pendingCallbacks.removeAll()
+            for cb in cbs { cb(payload, nil) }
+            // Fire watch callbacks
+            for (_, wd) in self.watchCallbacks {
+                wd.dispatcher?.dispatchGlobalEvent("location:update", payload: payload)
+            }
+        }
+    }
+
+    nonisolated func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
+        Task { @MainActor in
+            let cbs = self.pendingCallbacks
+            self.pendingCallbacks.removeAll()
+            for cb in cbs { cb(nil, error.localizedDescription) }
+        }
+    }
+}

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

@@ -0,0 +1,59 @@
+import Network
+import Foundation
+
+/// Monitors network connectivity and pushes changes to JS via global events.
+/// Uses NativeEventDispatcher protocol instead of a concrete bridge type.
+public final class NetworkModule: NativeModule {
+    public var moduleName: String { "Network" }
+
+    private let monitor = NWPathMonitor()
+    private let monitorQueue = DispatchQueue(label: "vue-native.network")
+    private weak var eventDispatcher: NativeEventDispatcher?
+
+    public init(eventDispatcher: NativeEventDispatcher) {
+        self.eventDispatcher = eventDispatcher
+        startMonitoring()
+    }
+
+    private func startMonitoring() {
+        monitor.pathUpdateHandler = { [weak self] path in
+            let isConnected = path.status == .satisfied
+            let connectionType: String
+            if path.usesInterfaceType(.wifi) {
+                connectionType = "wifi"
+            } else if path.usesInterfaceType(.cellular) {
+                connectionType = "cellular"
+            } else if path.usesInterfaceType(.wiredEthernet) {
+                connectionType = "ethernet"
+            } else {
+                connectionType = "none"
+            }
+            let dispatcher = self?.eventDispatcher
+            DispatchQueue.main.async {
+                dispatcher?.dispatchGlobalEvent("network:change", payload: [
+                    "isConnected": isConnected,
+                    "connectionType": connectionType
+                ])
+            }
+        }
+        monitor.start(queue: monitorQueue)
+    }
+
+    public func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        switch method {
+        case "getStatus":
+            let path = monitor.currentPath
+            let isConnected = path.status == .satisfied
+            let connectionType: String
+            if path.usesInterfaceType(.wifi) { connectionType = "wifi" }
+            else if path.usesInterfaceType(.cellular) { connectionType = "cellular" }
+            else if path.usesInterfaceType(.wiredEthernet) { connectionType = "ethernet" }
+            else { connectionType = "none" }
+            callback(["isConnected": isConnected, "connectionType": connectionType], nil)
+        default:
+            callback(nil, "Unknown method: \(method)")
+        }
+    }
+
+    public func invokeSync(method: String, args: [Any]) -> Any? { nil }
+}

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

@@ -0,0 +1,113 @@
+import Foundation
+
+/// Native module for performance profiling.
+/// Tracks memory usage via task_info and bridge operation counts.
+/// Dispatches `perf:metrics` global events every 1 second while profiling is active.
+///
+/// NOTE: FPS tracking is platform-specific (requires CADisplayLink on iOS,
+/// CVDisplayLink or CADisplayLink on macOS). This shared module reports FPS as 0
+/// unless a platform-specific subclass or wrapper provides it.
+/// Platforms can set `fpsProvider` to supply real-time FPS data.
+public final class PerformanceModule: NSObject, NativeModule {
+
+    public let moduleName = "Performance"
+
+    private weak var eventDispatcher: NativeEventDispatcher?
+    private var isProfiling = false
+
+    // Metrics timer
+    private var metricsTimer: Timer?
+
+    // Bridge operation count
+    private var bridgeOpsCount: Int = 0
+
+    /// Optional FPS provider. Platform-specific code sets this to a closure
+    /// that returns the current FPS reading (e.g., from CADisplayLink).
+    public var fpsProvider: (() -> Double)?
+
+    public init(eventDispatcher: NativeEventDispatcher) {
+        self.eventDispatcher = eventDispatcher
+        super.init()
+    }
+
+    public func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        switch method {
+        case "startProfiling":
+            startProfiling(callback: callback)
+        case "stopProfiling":
+            stopProfiling(callback: callback)
+        case "getMetrics":
+            let metrics = collectMetrics()
+            callback(metrics, nil)
+        default:
+            callback(nil, "PerformanceModule: unknown method '\(method)'")
+        }
+    }
+
+    // MARK: - Start / Stop
+
+    private func startProfiling(callback: @escaping (Any?, String?) -> Void) {
+        guard !isProfiling else { callback(true, nil); return }
+        isProfiling = true
+        bridgeOpsCount = 0
+
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+
+            // Timer for periodic metrics dispatch (every 1 second)
+            self.metricsTimer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
+                self?.dispatchMetrics()
+            }
+
+            callback(true, nil)
+        }
+    }
+
+    private func stopProfiling(callback: @escaping (Any?, String?) -> Void) {
+        guard isProfiling else { callback(true, nil); return }
+        isProfiling = false
+
+        DispatchQueue.main.async { [weak self] in
+            self?.metricsTimer?.invalidate()
+            self?.metricsTimer = nil
+            callback(true, nil)
+        }
+    }
+
+    // MARK: - Metrics collection
+
+    private func collectMetrics() -> [String: Any] {
+        let fps = fpsProvider?() ?? 0
+        return [
+            "fps": round(fps * 10) / 10,
+            "memoryMB": getMemoryUsageMB(),
+            "bridgeOps": bridgeOpsCount,
+            "timestamp": Date().timeIntervalSince1970 * 1000,
+        ]
+    }
+
+    private func dispatchMetrics() {
+        guard isProfiling else { return }
+        bridgeOpsCount += 1 // Count the metrics dispatch itself
+        let metrics = collectMetrics()
+        DispatchQueue.main.async { [weak self] in
+            self?.eventDispatcher?.dispatchGlobalEvent("perf:metrics", payload: metrics)
+        }
+    }
+
+    // MARK: - Memory measurement
+
+    private func getMemoryUsageMB() -> Double {
+        var info = mach_task_basic_info()
+        var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.size) / 4
+        let result = withUnsafeMutablePointer(to: &info) {
+            $0.withMemoryRebound(to: integer_t.self, capacity: Int(count)) {
+                task_info(mach_task_self_, task_flavor_t(MACH_TASK_BASIC_INFO), $0, &count)
+            }
+        }
+        if result == KERN_SUCCESS {
+            return Double(info.resident_size) / (1024 * 1024)
+        }
+        return 0
+    }
+}

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

@@ -0,0 +1,119 @@
+import Foundation
+import Security
+
+/// Native module providing secure key-value storage backed by the Keychain.
+/// Works on both iOS and macOS via the Security framework.
+///
+/// Methods:
+///   - get(key: String) -> String?
+///   - set(key: String, value: String)
+///   - remove(key: String)
+///   - clear()
+public final class SecureStorageModule: NativeModule {
+    public let moduleName = "SecureStorage"
+
+    private let service = "com.vuenative.securestorage"
+
+    public init() {}
+
+    public func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            guard let self = self else { return }
+            switch method {
+            case "get":
+                guard let key = args.first as? String else {
+                    callback(nil, "get: missing key")
+                    return
+                }
+                let query: [String: Any] = [
+                    kSecClass as String: kSecClassGenericPassword,
+                    kSecAttrService as String: self.service,
+                    kSecAttrAccount as String: key,
+                    kSecReturnData as String: true,
+                    kSecMatchLimit as String: kSecMatchLimitOne,
+                ]
+                var result: AnyObject?
+                let status = SecItemCopyMatching(query as CFDictionary, &result)
+                if status == errSecSuccess, let data = result as? Data,
+                   let value = String(data: data, encoding: .utf8) {
+                    callback(value, nil)
+                } else if status == errSecItemNotFound {
+                    callback(nil, nil)
+                } else {
+                    callback(nil, "get: Keychain error \(status)")
+                }
+
+            case "set":
+                guard args.count >= 2,
+                      let key = args[0] as? String,
+                      let value = args[1] as? String else {
+                    callback(nil, "set: missing key or value")
+                    return
+                }
+                guard let data = value.data(using: .utf8) else {
+                    callback(nil, "set: failed to encode value")
+                    return
+                }
+
+                // Try to update first
+                let searchQuery: [String: Any] = [
+                    kSecClass as String: kSecClassGenericPassword,
+                    kSecAttrService as String: self.service,
+                    kSecAttrAccount as String: key,
+                ]
+                let updateAttributes: [String: Any] = [
+                    kSecValueData as String: data,
+                ]
+                let updateStatus = SecItemUpdate(searchQuery as CFDictionary, updateAttributes as CFDictionary)
+
+                if updateStatus == errSecItemNotFound {
+                    // Item doesn't exist yet, add it
+                    var addQuery = searchQuery
+                    addQuery[kSecValueData as String] = data
+                    let addStatus = SecItemAdd(addQuery as CFDictionary, nil)
+                    if addStatus == errSecSuccess {
+                        callback(nil, nil)
+                    } else {
+                        callback(nil, "set: Keychain add error \(addStatus)")
+                    }
+                } else if updateStatus == errSecSuccess {
+                    callback(nil, nil)
+                } else {
+                    callback(nil, "set: Keychain update error \(updateStatus)")
+                }
+
+            case "remove":
+                guard let key = args.first as? String else {
+                    callback(nil, "remove: missing key")
+                    return
+                }
+                let query: [String: Any] = [
+                    kSecClass as String: kSecClassGenericPassword,
+                    kSecAttrService as String: self.service,
+                    kSecAttrAccount as String: key,
+                ]
+                let status = SecItemDelete(query as CFDictionary)
+                if status == errSecSuccess || status == errSecItemNotFound {
+                    callback(nil, nil)
+                } else {
+                    callback(nil, "remove: Keychain error \(status)")
+                }
+
+            case "clear":
+                let query: [String: Any] = [
+                    kSecClass as String: kSecClassGenericPassword,
+                    kSecAttrService as String: self.service,
+                ]
+                let status = SecItemDelete(query as CFDictionary)
+                if status == errSecSuccess || status == errSecItemNotFound {
+                    callback(nil, nil)
+                } else {
+                    callback(nil, "clear: Keychain error \(status)")
+                }
+
+            default:
+                callback(nil, "SecureStorageModule: Unknown method '\(method)'")
+            }
+        }
+    }
+}