@thelacanians/vue-native-cli 0.4.2 → 0.4.4

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

@@ -0,0 +1,68 @@
+#if canImport(UIKit)
+import Foundation
+
+/// Native module providing async key-value storage backed by UserDefaults.
+///
+/// Methods:
+///   - getItem(key: String) -> String?
+///   - setItem(key: String, value: String)
+///   - removeItem(key: String)
+///   - getAllKeys() -> [String]
+///   - clear()
+final class AsyncStorageModule: NativeModule {
+    let moduleName = "AsyncStorage"
+
+    private let defaults = UserDefaults.standard
+    private let keyPrefix = "VueNative.AsyncStorage."
+
+    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 "getItem":
+                guard let key = args.first as? String else {
+                    callback(nil, "getItem: missing key")
+                    return
+                }
+                let result = self.defaults.string(forKey: self.keyPrefix + key)
+                callback(result, nil)
+
+            case "setItem":
+                guard args.count >= 2,
+                      let key = args[0] as? String,
+                      let val = args[1] as? String else {
+                    callback(nil, "setItem: missing key or value")
+                    return
+                }
+                self.defaults.set(val, forKey: self.keyPrefix + key)
+                callback(nil, nil)
+
+            case "removeItem":
+                guard let key = args.first as? String else {
+                    callback(nil, "removeItem: missing key")
+                    return
+                }
+                self.defaults.removeObject(forKey: self.keyPrefix + key)
+                callback(nil, nil)
+
+            case "getAllKeys":
+                let allKeys = self.defaults.dictionaryRepresentation().keys
+                    .filter { $0.hasPrefix(self.keyPrefix) }
+                    .map { String($0.dropFirst(self.keyPrefix.count)) }
+                callback(allKeys, nil)
+
+            case "clear":
+                let allKeys = self.defaults.dictionaryRepresentation().keys
+                    .filter { $0.hasPrefix(self.keyPrefix) }
+                for key in allKeys {
+                    self.defaults.removeObject(forKey: key)
+                }
+                callback(nil, nil)
+
+            default:
+                callback(nil, "AsyncStorageModule: Unknown method '\(method)'")
+            }
+        }
+    }
+}
+#endif

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

@@ -0,0 +1,366 @@
+#if canImport(UIKit)
+import UIKit
+import AVFoundation
+
+/// Native module for audio playback and recording.
+///
+/// Methods:
+///   - play(uri: String, options?: Object)  -- play audio from URI
+///   - pause()                              -- pause playback
+///   - resume()                             -- resume playback
+///   - stop()                               -- stop playback and release player
+///   - seek(position: Number)               -- seek to position in seconds
+///   - setVolume(volume: Number)            -- set volume 0.0–1.0
+///   - startRecording(options?: Object)     -- start audio recording
+///   - stopRecording()                      -- stop recording, returns { uri, duration }
+///   - pauseRecording()                     -- pause recording
+///   - resumeRecording()                    -- resume recording
+///   - getStatus()                          -- returns current playback status
+///
+/// Events (via bridge.sendGlobalEvent):
+///   - audio:progress { currentTime, duration }
+///   - audio:complete {}
+///   - audio:error { message }
+final class AudioModule: NativeModule {
+    let moduleName = "Audio"
+
+    private var player: AVAudioPlayer?
+    private var recorder: AVAudioRecorder?
+    private var displayLink: CADisplayLink?
+    private var isPlaying = false
+    private var bridge: NativeBridge? { NativeBridge.shared }
+
+    // MARK: - Delegate to forward completion events
+    private var playerDelegate: AudioPlayerDelegate?
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        switch method {
+        case "play":
+            let uri = args.first as? String ?? ""
+            let options = (args.count > 1 ? args[1] as? [String: Any] : nil) ?? [:]
+            play(uri: uri, options: options, callback: callback)
+
+        case "pause":
+            pause(callback: callback)
+
+        case "resume":
+            resume(callback: callback)
+
+        case "stop":
+            stop(callback: callback)
+
+        case "seek":
+            let position = (args.first as? Double) ?? (args.first as? Int).map(Double.init) ?? 0
+            seek(position: position, callback: callback)
+
+        case "setVolume":
+            let volume = (args.first as? Double) ?? (args.first as? Int).map(Double.init) ?? 1.0
+            setVolume(Float(volume), callback: callback)
+
+        case "startRecording":
+            let options = args.first as? [String: Any] ?? [:]
+            startRecording(options: options, callback: callback)
+
+        case "stopRecording":
+            stopRecording(callback: callback)
+
+        case "pauseRecording":
+            pauseRecording(callback: callback)
+
+        case "resumeRecording":
+            resumeRecording(callback: callback)
+
+        case "getStatus":
+            getStatus(callback: callback)
+
+        default:
+            callback(nil, "AudioModule: Unknown method '\(method)'")
+        }
+    }
+
+    // MARK: - Playback
+
+    private func play(uri: String, options: [String: Any], callback: @escaping (Any?, String?) -> Void) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+
+            // Stop any existing playback
+            self.stopProgressReporting()
+            self.player?.stop()
+
+            do {
+                try AVAudioSession.sharedInstance().setCategory(.playback, mode: .default)
+                try AVAudioSession.sharedInstance().setActive(true)
+            } catch {
+                callback(nil, "Failed to set audio session: \(error.localizedDescription)")
+                return
+            }
+
+            guard let url = URL(string: uri) else {
+                callback(nil, "Invalid audio URI: \(uri)")
+                return
+            }
+
+            // Check if it's a remote URL — download first
+            if url.scheme == "http" || url.scheme == "https" {
+                self.downloadAndPlay(url: url, options: options, callback: callback)
+            } else {
+                self.playLocal(url: url, options: options, callback: callback)
+            }
+        }
+    }
+
+    private func downloadAndPlay(url: URL, options: [String: Any], callback: @escaping (Any?, String?) -> Void) {
+        URLSession.shared.dataTask(with: url) { [weak self] data, _, error in
+            DispatchQueue.main.async {
+                guard let self = self else { return }
+                if let error = error {
+                    callback(nil, "Failed to download audio: \(error.localizedDescription)")
+                    self.bridge?.sendGlobalEvent("audio:error", payload: ["message": error.localizedDescription])
+                    return
+                }
+                guard let data = data else {
+                    callback(nil, "No audio data received")
+                    return
+                }
+                do {
+                    let player = try AVAudioPlayer(data: data)
+                    self.setupPlayer(player, options: options, callback: callback)
+                } catch {
+                    callback(nil, "Failed to initialize player: \(error.localizedDescription)")
+                }
+            }
+        }.resume()
+    }
+
+    private func playLocal(url: URL, options: [String: Any], callback: @escaping (Any?, String?) -> Void) {
+        do {
+            let player = try AVAudioPlayer(contentsOf: url)
+            setupPlayer(player, options: options, callback: callback)
+        } catch {
+            callback(nil, "Failed to play audio: \(error.localizedDescription)")
+        }
+    }
+
+    private func setupPlayer(_ player: AVAudioPlayer, options: [String: Any], callback: @escaping (Any?, String?) -> Void) {
+        let volume = Float(options["volume"] as? Double ?? 1.0)
+        let loop = options["loop"] as? Bool ?? false
+
+        player.volume = volume
+        player.numberOfLoops = loop ? -1 : 0
+
+        let delegate = AudioPlayerDelegate { [weak self] successfully in
+            guard let self = self else { return }
+            self.isPlaying = false
+            self.stopProgressReporting()
+            self.bridge?.sendGlobalEvent("audio:complete", payload: [:])
+        }
+        player.delegate = delegate
+        self.playerDelegate = delegate
+        self.player = player
+
+        player.prepareToPlay()
+        player.play()
+        self.isPlaying = true
+        self.startProgressReporting()
+
+        callback([
+            "duration": player.duration,
+            "currentTime": 0.0,
+        ], nil)
+    }
+
+    private func pause(callback: @escaping (Any?, String?) -> Void) {
+        DispatchQueue.main.async { [weak self] in
+            self?.player?.pause()
+            self?.isPlaying = false
+            self?.stopProgressReporting()
+            callback(nil, nil)
+        }
+    }
+
+    private func resume(callback: @escaping (Any?, String?) -> Void) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            self.player?.play()
+            self.isPlaying = true
+            self.startProgressReporting()
+            callback(nil, nil)
+        }
+    }
+
+    private func stop(callback: @escaping (Any?, String?) -> Void) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            self.player?.stop()
+            self.player = nil
+            self.playerDelegate = nil
+            self.isPlaying = false
+            self.stopProgressReporting()
+            callback(nil, nil)
+        }
+    }
+
+    private func seek(position: Double, callback: @escaping (Any?, String?) -> Void) {
+        DispatchQueue.main.async { [weak self] in
+            self?.player?.currentTime = position
+            callback(nil, nil)
+        }
+    }
+
+    private func setVolume(_ volume: Float, callback: @escaping (Any?, String?) -> Void) {
+        DispatchQueue.main.async { [weak self] in
+            self?.player?.volume = max(0, min(1, volume))
+            callback(nil, nil)
+        }
+    }
+
+    // MARK: - Progress Reporting
+
+    private func startProgressReporting() {
+        stopProgressReporting()
+        let link = CADisplayLink(target: self, selector: #selector(reportProgress))
+        // Report at ~4 Hz (every 15 frames at 60fps)
+        link.preferredFrameRateRange = CAFrameRateRange(minimum: 4, maximum: 4, preferred: 4)
+        link.add(to: .main, forMode: .common)
+        displayLink = link
+    }
+
+    private func stopProgressReporting() {
+        displayLink?.invalidate()
+        displayLink = nil
+    }
+
+    @objc private func reportProgress() {
+        guard let player = player, isPlaying else { return }
+        bridge?.sendGlobalEvent("audio:progress", payload: [
+            "currentTime": player.currentTime,
+            "duration": player.duration,
+        ])
+    }
+
+    // MARK: - Recording
+
+    private func startRecording(options: [String: Any], callback: @escaping (Any?, String?) -> Void) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+
+            do {
+                try AVAudioSession.sharedInstance().setCategory(.playAndRecord, mode: .default)
+                try AVAudioSession.sharedInstance().setActive(true)
+            } catch {
+                callback(nil, "Failed to set audio session for recording: \(error.localizedDescription)")
+                return
+            }
+
+            let quality = options["quality"] as? String ?? "medium"
+            let format = options["format"] as? String ?? "m4a"
+
+            let ext = format == "wav" ? "wav" : "m4a"
+            let url = FileManager.default.temporaryDirectory
+                .appendingPathComponent(UUID().uuidString + ".\(ext)")
+
+            var settings: [String: Any] = [:]
+            if format == "wav" {
+                settings = [
+                    AVFormatIDKey: Int(kAudioFormatLinearPCM),
+                    AVSampleRateKey: quality == "high" ? 44100.0 : 22050.0,
+                    AVNumberOfChannelsKey: 1,
+                    AVLinearPCMBitDepthKey: 16,
+                    AVLinearPCMIsFloatKey: false,
+                ]
+            } else {
+                let sampleRate: Double
+                let bitRate: Int
+                switch quality {
+                case "low":  sampleRate = 22050; bitRate = 32000
+                case "high": sampleRate = 44100; bitRate = 128000
+                default:     sampleRate = 44100; bitRate = 64000
+                }
+                settings = [
+                    AVFormatIDKey: Int(kAudioFormatMPEG4AAC),
+                    AVSampleRateKey: sampleRate,
+                    AVNumberOfChannelsKey: 1,
+                    AVEncoderAudioQualityKey: AVAudioQuality.medium.rawValue,
+                    AVEncoderBitRateKey: bitRate,
+                ]
+            }
+
+            do {
+                let recorder = try AVAudioRecorder(url: url, settings: settings)
+                recorder.prepareToRecord()
+                recorder.record()
+                self.recorder = recorder
+                callback(["uri": url.absoluteString], nil)
+            } catch {
+                callback(nil, "Failed to start recording: \(error.localizedDescription)")
+            }
+        }
+    }
+
+    private func stopRecording(callback: @escaping (Any?, String?) -> Void) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self, let recorder = self.recorder else {
+                callback(nil, "No active recording")
+                return
+            }
+            let duration = recorder.currentTime
+            let uri = recorder.url.absoluteString
+            recorder.stop()
+            self.recorder = nil
+            callback(["uri": uri, "duration": duration], nil)
+        }
+    }
+
+    private func pauseRecording(callback: @escaping (Any?, String?) -> Void) {
+        DispatchQueue.main.async { [weak self] in
+            self?.recorder?.pause()
+            callback(nil, nil)
+        }
+    }
+
+    private func resumeRecording(callback: @escaping (Any?, String?) -> Void) {
+        DispatchQueue.main.async { [weak self] in
+            self?.recorder?.record()
+            callback(nil, nil)
+        }
+    }
+
+    // MARK: - Status
+
+    private func getStatus(callback: @escaping (Any?, String?) -> Void) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { callback(nil, nil); return }
+            var status: [String: Any] = [
+                "isPlaying": self.isPlaying,
+                "isRecording": self.recorder?.isRecording ?? false,
+            ]
+            if let player = self.player {
+                status["currentTime"] = player.currentTime
+                status["duration"] = player.duration
+                status["volume"] = player.volume
+            }
+            callback(status, nil)
+        }
+    }
+}
+
+// MARK: - AVAudioPlayerDelegate wrapper
+
+private final class AudioPlayerDelegate: NSObject, AVAudioPlayerDelegate {
+    private let onComplete: (Bool) -> Void
+
+    init(onComplete: @escaping (Bool) -> Void) {
+        self.onComplete = onComplete
+    }
+
+    func audioPlayerDidFinishPlaying(_ player: AVAudioPlayer, successfully flag: Bool) {
+        onComplete(flag)
+    }
+
+    func audioPlayerDecodeErrorDidOccur(_ player: AVAudioPlayer, error: Error?) {
+        // Treat decode error as completion failure
+        onComplete(false)
+    }
+}
+#endif

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

@@ -0,0 +1,135 @@
+#if canImport(UIKit)
+import UIKit
+import BackgroundTasks
+
+/// Native module for scheduling background tasks using BGTaskScheduler.
+///
+/// Methods:
+///   - scheduleTask(taskId, type, options) — schedule a background task
+///   - cancelTask(taskId) — cancel a specific task
+///   - cancelAllTasks() — cancel all scheduled tasks
+///   - completeTask(taskId) — signal task completion from JS
+///
+/// Events:
+///   - background:taskExecute — fired when a background task runs, payload: { taskId }
+@available(iOS 13.0, *)
+final class BackgroundTaskModule: NativeModule {
+    var moduleName: String { "BackgroundTask" }
+    private weak var bridge: NativeBridge?
+
+    /// Track active tasks so we can call setTaskCompleted from JS
+    private var activeTasks: [String: BGTask] = [:]
+
+    /// Registered task identifiers
+    private var registeredIdentifiers: Set<String> = []
+
+    init(bridge: NativeBridge) {
+        self.bridge = bridge
+    }
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        switch method {
+        case "scheduleTask":
+            guard args.count >= 2,
+                  let taskId = args[0] as? String,
+                  let type = args[1] as? String else {
+                callback(nil, "scheduleTask: missing taskId or type")
+                return
+            }
+            let options = args.count >= 3 ? args[2] as? [String: Any] : nil
+            scheduleTask(taskId: taskId, type: type, options: options ?? [:], callback: callback)
+
+        case "cancelTask":
+            guard let taskId = args.first as? String else {
+                callback(nil, "cancelTask: missing taskId")
+                return
+            }
+            BGTaskScheduler.shared.cancel(taskIdentifier: taskId)
+            callback(nil, nil)
+
+        case "cancelAllTasks":
+            BGTaskScheduler.shared.cancelAllTaskRequests()
+            callback(nil, nil)
+
+        case "completeTask":
+            guard let taskId = args.first as? String else {
+                callback(nil, "completeTask: missing taskId")
+                return
+            }
+            let success = (args.count >= 2 ? args[1] as? Bool : nil) ?? true
+            if let task = activeTasks[taskId] {
+                task.setTaskCompleted(success: success)
+                activeTasks.removeValue(forKey: taskId)
+            }
+            callback(nil, nil)
+
+        case "registerTask":
+            guard let taskId = args.first as? String else {
+                callback(nil, "registerTask: missing taskId")
+                return
+            }
+            registerTaskHandler(taskId: taskId)
+            callback(nil, nil)
+
+        default:
+            callback(nil, "BackgroundTaskModule: Unknown method '\(method)'")
+        }
+    }
+
+    // MARK: - Private
+
+    private func registerTaskHandler(taskId: String) {
+        guard !registeredIdentifiers.contains(taskId) else { return }
+        registeredIdentifiers.insert(taskId)
+
+        BGTaskScheduler.shared.register(forTaskWithIdentifier: taskId, using: nil) { [weak self] task in
+            self?.handleTaskExecution(task: task)
+        }
+    }
+
+    private func handleTaskExecution(task: BGTask) {
+        let taskId = task.identifier
+        activeTasks[taskId] = task
+
+        task.expirationHandler = { [weak self] in
+            self?.activeTasks[taskId]?.setTaskCompleted(success: false)
+            self?.activeTasks.removeValue(forKey: taskId)
+        }
+
+        // Notify JS that the task is executing
+        let bridge = bridge
+        DispatchQueue.main.async {
+            bridge?.dispatchGlobalEvent("background:taskExecute", payload: ["taskId": taskId])
+        }
+    }
+
+    private func scheduleTask(taskId: String, type: String, options: [String: Any], callback: @escaping (Any?, String?) -> Void) {
+        // Ensure task handler is registered
+        registerTaskHandler(taskId: taskId)
+
+        let request: BGTaskRequest
+        if type == "processing" {
+            let processingRequest = BGProcessingTaskRequest(identifier: taskId)
+            processingRequest.requiresNetworkConnectivity = options["requiresNetworkConnectivity"] as? Bool ?? false
+            processingRequest.requiresExternalPower = options["requiresExternalPower"] as? Bool ?? false
+            request = processingRequest
+        } else {
+            // Default: app refresh
+            request = BGAppRefreshTaskRequest(identifier: taskId)
+        }
+
+        if let earliestBeginDate = options["earliestBeginDate"] as? Double {
+            request.earliestBeginDate = Date(timeIntervalSince1970: earliestBeginDate / 1000.0)
+        }
+
+        do {
+            try BGTaskScheduler.shared.submit(request)
+            callback(nil, nil)
+        } catch {
+            callback(nil, "Failed to schedule task: \(error.localizedDescription)")
+        }
+    }
+
+    func invokeSync(method: String, args: [Any]) -> Any? { nil }
+}
+#endif

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

@@ -0,0 +1,61 @@
+#if canImport(UIKit)
+import UIKit
+import LocalAuthentication
+
+/// Native module for biometric authentication (Face ID, Touch ID, Optic ID).
+///
+/// Methods:
+///   - getSupportedBiometry() -> "faceID" | "touchID" | "opticID" | "none"
+///   - isAvailable() -> Bool
+///   - authenticate(reason: String) -> { success: Bool, error?: String }
+final class BiometryModule: NativeModule {
+    var moduleName: String { "Biometry" }
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        switch method {
+        case "getSupportedBiometry":
+            callback(supportedBiometry(), nil)
+        case "isAvailable":
+            let context = LAContext()
+            var error: NSError?
+            let available = context.canEvaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, error: &error)
+            callback(available, nil)
+        case "authenticate":
+            let reason = args.first as? String ?? "Authenticate"
+            authenticate(reason: reason, callback: callback)
+        default:
+            callback(nil, "BiometryModule: Unknown method '\(method)'")
+        }
+    }
+
+    // MARK: - Private helpers
+
+    private func authenticate(reason: String, callback: @escaping (Any?, String?) -> Void) {
+        let context = LAContext()
+        context.evaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, localizedReason: reason) { success, error in
+            if success {
+                callback(["success": true], nil)
+            } else {
+                let msg = error?.localizedDescription ?? "Authentication failed"
+                callback(["success": false, "error": msg], nil)
+            }
+        }
+    }
+
+    private func supportedBiometry() -> String {
+        let context = LAContext()
+        var error: NSError?
+        guard context.canEvaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, error: &error) else {
+            return "none"
+        }
+        switch context.biometryType {
+        case .faceID:  return "faceID"
+        case .touchID: return "touchID"
+        case .opticID: return "opticID"
+        default:       return "none"
+        }
+    }
+
+    func invokeSync(method: String, args: [Any]) -> Any? { nil }
+}
+#endif