@thelacanians/vue-native-cli 0.4.2 → 0.4.4

package/native/ios/VueNativeCore/Sources/VueNativeCore/Modules/DatabaseModule.swift

@@ -0,0 +1,259 @@
+#if canImport(UIKit)
+import Foundation
+import SQLite3
+
+/// Native module for SQLite database access.
+/// Uses the sqlite3 C API (built into iOS, no external dependencies).
+/// Supports multiple named databases, parameterized queries, and transactions.
+final class DatabaseModule: NativeModule {
+    let moduleName = "Database"
+
+    /// Open database handles keyed by database name.
+    private var databases: [String: OpaquePointer] = [:]
+
+    /// Directory for database files.
+    private var dbDirectory: URL {
+        let dir = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
+            .appendingPathComponent("databases", isDirectory: true)
+        try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+        return dir
+    }
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        switch method {
+        case "open":
+            let name = args.first as? String ?? "default"
+            open(name: name, callback: callback)
+        case "close":
+            let name = args.first as? String ?? "default"
+            close(name: name, callback: callback)
+        case "execute":
+            let name = args.count > 0 ? (args[0] as? String ?? "default") : "default"
+            let sql = args.count > 1 ? (args[1] as? String ?? "") : ""
+            let params = args.count > 2 ? (args[2] as? [Any] ?? []) : []
+            execute(name: name, sql: sql, params: params, callback: callback)
+        case "query":
+            let name = args.count > 0 ? (args[0] as? String ?? "default") : "default"
+            let sql = args.count > 1 ? (args[1] as? String ?? "") : ""
+            let params = args.count > 2 ? (args[2] as? [Any] ?? []) : []
+            query(name: name, sql: sql, params: params, callback: callback)
+        case "executeTransaction":
+            let name = args.count > 0 ? (args[0] as? String ?? "default") : "default"
+            let statements = args.count > 1 ? (args[1] as? [[String: Any]] ?? []) : []
+            executeTransaction(name: name, statements: statements, callback: callback)
+        default:
+            callback(nil, "DatabaseModule: unknown method '\(method)'")
+        }
+    }
+
+    // MARK: - Open / Close
+
+    private func open(name: String, callback: @escaping (Any?, String?) -> Void) {
+        if databases[name] != nil {
+            callback(true, nil)
+            return
+        }
+
+        let path = dbDirectory.appendingPathComponent("\(name).sqlite").path
+        var db: OpaquePointer?
+
+        let flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX
+        let result = sqlite3_open_v2(path, &db, flags, nil)
+        if result == SQLITE_OK, let db = db {
+            // Enable WAL mode for better concurrent read/write performance
+            sqlite3_exec(db, "PRAGMA journal_mode=WAL", nil, nil, nil)
+            databases[name] = db
+            callback(true, nil)
+        } else {
+            let errorMsg = db != nil ? String(cString: sqlite3_errmsg(db)) : "Unknown error"
+            if db != nil { sqlite3_close(db) }
+            callback(nil, "Failed to open database '\(name)': \(errorMsg)")
+        }
+    }
+
+    private func close(name: String, callback: @escaping (Any?, String?) -> Void) {
+        guard let db = databases.removeValue(forKey: name) else {
+            callback(nil, nil)
+            return
+        }
+        sqlite3_close(db)
+        callback(nil, nil)
+    }
+
+    // MARK: - Execute (INSERT, UPDATE, DELETE, CREATE TABLE, etc.)
+
+    private func execute(name: String, sql: String, params: [Any], callback: @escaping (Any?, String?) -> Void) {
+        guard let db = getOrOpen(name: name, callback: callback) else { return }
+
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else {
+            let err = String(cString: sqlite3_errmsg(db))
+            callback(nil, "SQL prepare error: \(err)")
+            return
+        }
+        defer { sqlite3_finalize(stmt) }
+
+        bindParams(stmt: stmt!, params: params)
+
+        let stepResult = sqlite3_step(stmt)
+        if stepResult == SQLITE_DONE || stepResult == SQLITE_ROW {
+            let rowsAffected = sqlite3_changes(db)
+            let lastInsertId = sqlite3_last_insert_rowid(db)
+            var result: [String: Any] = ["rowsAffected": Int(rowsAffected)]
+            if lastInsertId > 0 {
+                result["insertId"] = Int(lastInsertId)
+            }
+            callback(result, nil)
+        } else {
+            let err = String(cString: sqlite3_errmsg(db))
+            callback(nil, "SQL execute error: \(err)")
+        }
+    }
+
+    // MARK: - Query (SELECT)
+
+    private func query(name: String, sql: String, params: [Any], callback: @escaping (Any?, String?) -> Void) {
+        guard let db = getOrOpen(name: name, callback: callback) else { return }
+
+        var stmt: OpaquePointer?
+        guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else {
+            let err = String(cString: sqlite3_errmsg(db))
+            callback(nil, "SQL prepare error: \(err)")
+            return
+        }
+        defer { sqlite3_finalize(stmt) }
+
+        bindParams(stmt: stmt!, params: params)
+
+        var rows: [[String: Any]] = []
+        let columnCount = sqlite3_column_count(stmt)
+
+        while sqlite3_step(stmt) == SQLITE_ROW {
+            var row: [String: Any] = [:]
+            for i in 0..<columnCount {
+                let colName = String(cString: sqlite3_column_name(stmt, i))
+                row[colName] = columnValue(stmt: stmt!, index: i)
+            }
+            rows.append(row)
+        }
+
+        callback(rows, nil)
+    }
+
+    // MARK: - Transaction
+
+    private func executeTransaction(name: String, statements: [[String: Any]], callback: @escaping (Any?, String?) -> Void) {
+        guard let db = getOrOpen(name: name, callback: callback) else { return }
+
+        sqlite3_exec(db, "BEGIN TRANSACTION", nil, nil, nil)
+
+        var results: [[String: Any]] = []
+
+        for stmtData in statements {
+            let sql = stmtData["sql"] as? String ?? ""
+            let params = stmtData["params"] as? [Any] ?? []
+
+            var stmt: OpaquePointer?
+            guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else {
+                let err = String(cString: sqlite3_errmsg(db))
+                sqlite3_exec(db, "ROLLBACK", nil, nil, nil)
+                callback(nil, "Transaction SQL prepare error: \(err)")
+                return
+            }
+
+            bindParams(stmt: stmt!, params: params)
+
+            let stepResult = sqlite3_step(stmt)
+            sqlite3_finalize(stmt)
+
+            if stepResult == SQLITE_DONE || stepResult == SQLITE_ROW {
+                let rowsAffected = sqlite3_changes(db)
+                let lastInsertId = sqlite3_last_insert_rowid(db)
+                var result: [String: Any] = ["rowsAffected": Int(rowsAffected)]
+                if lastInsertId > 0 {
+                    result["insertId"] = Int(lastInsertId)
+                }
+                results.append(result)
+            } else {
+                let err = String(cString: sqlite3_errmsg(db))
+                sqlite3_exec(db, "ROLLBACK", nil, nil, nil)
+                callback(nil, "Transaction execute error: \(err)")
+                return
+            }
+        }
+
+        sqlite3_exec(db, "COMMIT", nil, nil, nil)
+        callback(results, nil)
+    }
+
+    // MARK: - Helpers
+
+    /// Get an existing database handle or auto-open it.
+    private func getOrOpen(name: String, callback: @escaping (Any?, String?) -> Void) -> OpaquePointer? {
+        if let db = databases[name] { return db }
+
+        // Auto-open
+        let path = dbDirectory.appendingPathComponent("\(name).sqlite").path
+        var db: OpaquePointer?
+        let flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX
+        let result = sqlite3_open_v2(path, &db, flags, nil)
+        if result == SQLITE_OK, let db = db {
+            sqlite3_exec(db, "PRAGMA journal_mode=WAL", nil, nil, nil)
+            databases[name] = db
+            return db
+        } else {
+            let errorMsg = db != nil ? String(cString: sqlite3_errmsg(db)) : "Unknown error"
+            if db != nil { sqlite3_close(db) }
+            callback(nil, "Failed to auto-open database '\(name)': \(errorMsg)")
+            return nil
+        }
+    }
+
+    /// Bind parameter array to a prepared statement. Supports String, Int, Double, Bool, nil/NSNull.
+    private func bindParams(stmt: OpaquePointer, params: [Any]) {
+        for (i, param) in params.enumerated() {
+            let idx = Int32(i + 1)
+            if param is NSNull {
+                sqlite3_bind_null(stmt, idx)
+            } else if let s = param as? String {
+                sqlite3_bind_text(stmt, idx, (s as NSString).utf8String, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
+            } else if let n = param as? Int {
+                sqlite3_bind_int64(stmt, idx, Int64(n))
+            } else if let d = param as? Double {
+                sqlite3_bind_double(stmt, idx, d)
+            } else if let b = param as? Bool {
+                sqlite3_bind_int(stmt, idx, b ? 1 : 0)
+            } else {
+                // Fallback: bind as text
+                let str = "\(param)"
+                sqlite3_bind_text(stmt, idx, (str as NSString).utf8String, -1, unsafeBitCast(-1, to: sqlite3_destructor_type.self))
+            }
+        }
+    }
+
+    /// Extract a column value from the current row of a statement.
+    private func columnValue(stmt: OpaquePointer, index: Int32) -> Any {
+        let type = sqlite3_column_type(stmt, index)
+        switch type {
+        case SQLITE_INTEGER:
+            return Int(sqlite3_column_int64(stmt, index))
+        case SQLITE_FLOAT:
+            return sqlite3_column_double(stmt, index)
+        case SQLITE_TEXT:
+            return String(cString: sqlite3_column_text(stmt, index))
+        case SQLITE_BLOB:
+            // Return blob as base64 string
+            if let data = sqlite3_column_blob(stmt, index) {
+                let bytes = sqlite3_column_bytes(stmt, index)
+                let d = Data(bytes: data, count: Int(bytes))
+                return d.base64EncodedString()
+            }
+            return NSNull()
+        case SQLITE_NULL:
+            return NSNull()
+        default:
+            return NSNull()
+        }
+    }
+}
+#endif

package/native/ios/VueNativeCore/Sources/VueNativeCore/Modules/DeviceInfoModule.swift

@@ -0,0 +1,34 @@
+#if canImport(UIKit)
+import UIKit
+
+/// Native module providing device and screen information.
+///
+/// Methods:
+///   - getInfo() -> { model, systemVersion, screenWidth, screenHeight, scale }
+final class DeviceInfoModule: NativeModule {
+    let moduleName = "DeviceInfo"
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        DispatchQueue.main.async {
+            switch method {
+            case "getInfo":
+                let device = UIDevice.current
+                let screen = UIScreen.main
+                let info: [String: Any] = [
+                    "model": device.model,
+                    "systemVersion": device.systemVersion,
+                    "systemName": device.systemName,
+                    "name": device.name,
+                    "screenWidth": screen.bounds.width,
+                    "screenHeight": screen.bounds.height,
+                    "scale": screen.scale
+                ]
+                callback(info, nil)
+
+            default:
+                callback(nil, "DeviceInfoModule: Unknown method '\(method)'")
+            }
+        }
+    }
+}
+#endif

package/native/ios/VueNativeCore/Sources/VueNativeCore/Modules/FileSystemModule.swift

@@ -0,0 +1,233 @@
+#if canImport(UIKit)
+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)
+final class FileSystemModule: NativeModule {
+    let moduleName = "FileSystem"
+
+    private let fileManager = FileManager.default
+
+    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)'")
+            }
+        }
+    }
+}
+#endif

package/native/ios/VueNativeCore/Sources/VueNativeCore/Modules/GeolocationModule.swift

@@ -0,0 +1,147 @@
+#if canImport(UIKit)
+import UIKit
+import CoreLocation
+
+/// Native module for GPS/location access.
+///
+/// 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
+final class GeolocationModule: NativeModule {
+    var moduleName: String { "Geolocation" }
+    private weak var bridge: NativeBridge?
+
+    init(bridge: NativeBridge) { self.bridge = bridge }
+
+    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 weakBridge = bridge
+            DispatchQueue.main.async {
+                let watchId = GeolocationManager.shared.watchPosition(bridge: weakBridge)
+                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)'")
+        }
+    }
+
+    func invokeSync(method: String, args: [Any]) -> Any? { nil }
+}
+
+// MARK: - Internal location manager
+
+/// All CLLocationManager interactions happen on @MainActor (main thread),
+/// matching the UIKit + 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 bridge reference
+    private struct WeakBridge { weak var bridge: NativeBridge? }
+    private var watchCallbacks: [Int: WeakBridge] = [:]
+    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)
+
+    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 status == .authorizedWhenInUse || status == .authorizedAlways else {
+            callback(nil, "Location permission not granted"); return
+        }
+        pendingCallbacks.append(callback)
+        manager.requestLocation()
+    }
+
+    func watchPosition(bridge: NativeBridge?) -> Int {
+        ensureManager()
+        guard let manager = manager else {
+            return -1
+        }
+        let status = manager.authorizationStatus
+        guard status == .authorizedWhenInUse || status == .authorizedAlways else {
+            // Return a sentinel; caller will get no updates
+            return -1
+        }
+        let watchId = nextWatchId; nextWatchId += 1
+        watchCallbacks[watchId] = WeakBridge(bridge: bridge)
+        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 (_, wb) in self.watchCallbacks {
+                wb.bridge?.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) }
+        }
+    }
+}
+#endif