@thelacanians/vue-native-cli 0.4.3 → 0.4.4

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

@@ -0,0 +1,50 @@
+#if canImport(UIKit)
+import UIKit
+
+/// Native module providing haptic feedback.
+///
+/// Methods:
+///   - vibrate(style: String) -- trigger impact feedback ("light"|"medium"|"heavy"|"rigid"|"soft")
+///   - notificationFeedback(type: String) -- "success"|"warning"|"error"
+///   - selectionChanged() -- selection change feedback
+final class HapticsModule: NativeModule {
+    let moduleName = "Haptics"
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        DispatchQueue.main.async {
+            switch method {
+            case "vibrate":
+                let style = args.first as? String ?? "medium"
+                let feedbackStyle: UIImpactFeedbackGenerator.FeedbackStyle
+                switch style {
+                case "light": feedbackStyle = .light
+                case "heavy": feedbackStyle = .heavy
+                case "rigid": feedbackStyle = .rigid
+                case "soft": feedbackStyle = .soft
+                default: feedbackStyle = .medium
+                }
+                UIImpactFeedbackGenerator(style: feedbackStyle).impactOccurred()
+                callback(nil, nil)
+
+            case "notificationFeedback":
+                let type = args.first as? String ?? "success"
+                let feedbackType: UINotificationFeedbackGenerator.FeedbackType
+                switch type {
+                case "warning": feedbackType = .warning
+                case "error": feedbackType = .error
+                default: feedbackType = .success
+                }
+                UINotificationFeedbackGenerator().notificationOccurred(feedbackType)
+                callback(nil, nil)
+
+            case "selectionChanged":
+                UISelectionFeedbackGenerator().selectionChanged()
+                callback(nil, nil)
+
+            default:
+                callback(nil, "HapticsModule: Unknown method '\(method)'")
+            }
+        }
+    }
+}
+#endif

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

@@ -0,0 +1,194 @@
+#if canImport(UIKit)
+import StoreKit
+
+/// Native module for In-App Purchases using StoreKit 2.
+///
+/// Methods:
+///   - initialize() -- set up transaction listener
+///   - getProducts(skus: [String]) -- fetch product info
+///   - purchase(sku: String) -- purchase a product
+///   - restorePurchases() -- restore completed transactions
+///   - getActiveSubscriptions() -- list active auto-renewable subscriptions
+///
+/// Events:
+///   - iap:transactionUpdate { productId, state, transactionId, error? }
+@available(iOS 15.0, *)
+final class IAPModule: NativeModule {
+    let moduleName = "IAP"
+    private weak var bridge: NativeBridge?
+    private var transactionTask: Task<Void, Never>?
+
+    init(bridge: NativeBridge? = nil) {
+        self.bridge = bridge
+    }
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        switch method {
+        case "initialize":
+            startTransactionListener()
+            callback(nil, nil)
+
+        case "getProducts":
+            guard let skus = args.first as? [String] else {
+                callback(nil, "getProducts: expected array of SKU strings")
+                return
+            }
+            Task {
+                do {
+                    let products = try await Product.products(for: Set(skus))
+                    let result: [[String: Any]] = products.map { product in
+                        [
+                            "id": product.id,
+                            "displayName": product.displayName,
+                            "description": product.description,
+                            "price": NSDecimalNumber(decimal: product.price).doubleValue,
+                            "displayPrice": product.displayPrice,
+                            "currencyCode": product.priceFormatStyle.currencyCode,
+                            "type": self.productTypeString(product.type),
+                        ]
+                    }
+                    callback(result, nil)
+                } catch {
+                    callback(nil, "getProducts: \(error.localizedDescription)")
+                }
+            }
+
+        case "purchase":
+            guard let sku = args.first as? String else {
+                callback(nil, "purchase: expected SKU string")
+                return
+            }
+            Task {
+                do {
+                    let products = try await Product.products(for: [sku])
+                    guard let product = products.first else {
+                        callback(nil, "purchase: product '\(sku)' not found")
+                        return
+                    }
+                    let result = try await product.purchase()
+                    switch result {
+                    case .success(let verification):
+                        let transaction = try self.checkVerification(verification)
+                        await transaction.finish()
+                        let purchaseInfo: [String: Any] = [
+                            "productId": transaction.productID,
+                            "transactionId": String(transaction.id),
+                            "purchaseDate": transaction.purchaseDate.ISO8601Format(),
+                        ]
+                        callback(purchaseInfo, nil)
+                    case .userCancelled:
+                        callback(nil, "purchase: user cancelled")
+                    case .pending:
+                        callback(nil, "purchase: transaction pending approval")
+                    @unknown default:
+                        callback(nil, "purchase: unknown result")
+                    }
+                } catch {
+                    callback(nil, "purchase: \(error.localizedDescription)")
+                }
+            }
+
+        case "restorePurchases":
+            Task {
+                do {
+                    try await AppStore.sync()
+                    var restored: [[String: Any]] = []
+                    for await result in Transaction.currentEntitlements {
+                        if let transaction = try? self.checkVerification(result) {
+                            var info: [String: Any] = [
+                                "productId": transaction.productID,
+                                "transactionId": String(transaction.id),
+                                "purchaseDate": transaction.purchaseDate.ISO8601Format(),
+                            ]
+                            if let expires = transaction.expirationDate {
+                                info["expiresDate"] = expires.ISO8601Format()
+                            }
+                            restored.append(info)
+                        }
+                    }
+                    callback(restored, nil)
+                } catch {
+                    callback(nil, "restorePurchases: \(error.localizedDescription)")
+                }
+            }
+
+        case "getActiveSubscriptions":
+            Task {
+                var active: [[String: Any]] = []
+                for await result in Transaction.currentEntitlements {
+                    if let transaction = try? self.checkVerification(result) {
+                        guard transaction.productType == .autoRenewable else { continue }
+                        guard transaction.revocationDate == nil else { continue }
+                        var info: [String: Any] = [
+                            "productId": transaction.productID,
+                            "transactionId": String(transaction.id),
+                            "purchaseDate": transaction.purchaseDate.ISO8601Format(),
+                        ]
+                        if let expires = transaction.expirationDate {
+                            info["expiresDate"] = expires.ISO8601Format()
+                        }
+                        active.append(info)
+                    }
+                }
+                callback(active, nil)
+            }
+
+        default:
+            callback(nil, "IAPModule: unknown method '\(method)'")
+        }
+    }
+
+    // MARK: - Transaction Listener
+
+    private func startTransactionListener() {
+        transactionTask?.cancel()
+        transactionTask = Task.detached { [weak self] in
+            for await result in Transaction.updates {
+                guard let self = self else { return }
+                do {
+                    let transaction = try self.checkVerification(result)
+                    await transaction.finish()
+                    let payload: [String: Any] = [
+                        "productId": transaction.productID,
+                        "state": "purchased",
+                        "transactionId": String(transaction.id),
+                    ]
+                    await MainActor.run {
+                        self.bridge?.emitGlobalEvent("iap:transactionUpdate", payload: payload)
+                    }
+                } catch {
+                    let payload: [String: Any] = [
+                        "productId": "",
+                        "state": "failed",
+                        "error": error.localizedDescription,
+                    ]
+                    await MainActor.run {
+                        self.bridge?.emitGlobalEvent("iap:transactionUpdate", payload: payload)
+                    }
+                }
+            }
+        }
+    }
+
+    // MARK: - Helpers
+
+    private func checkVerification<T>(_ result: VerificationResult<T>) throws -> T {
+        switch result {
+        case .unverified(_, let error):
+            throw error
+        case .verified(let safe):
+            return safe
+        }
+    }
+
+    private func productTypeString(_ type: Product.ProductType) -> String {
+        switch type {
+        case .consumable: return "consumable"
+        case .nonConsumable: return "nonConsumable"
+        case .autoRenewable: return "autoRenewable"
+        case .nonRenewable: return "nonRenewable"
+        default: return "unknown"
+        }
+    }
+}
+#endif

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

@@ -0,0 +1,31 @@
+#if canImport(UIKit)
+import UIKit
+
+/// Native module providing keyboard management.
+///
+/// Methods:
+///   - dismiss() -- dismiss the keyboard
+///   - getHeight() -> { height: CGFloat, isVisible: Bool }
+final class KeyboardModule: NativeModule {
+    let moduleName = "Keyboard"
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        DispatchQueue.main.async {
+            switch method {
+            case "dismiss":
+                UIApplication.shared.sendAction(
+                    #selector(UIResponder.resignFirstResponder),
+                    to: nil, from: nil, for: nil
+                )
+                callback(nil, nil)
+
+            case "getHeight":
+                callback(["height": 0.0, "isVisible": false], nil)
+
+            default:
+                callback(nil, "KeyboardModule: Unknown method '\(method)'")
+            }
+        }
+    }
+}
+#endif

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

@@ -0,0 +1,42 @@
+#if canImport(UIKit)
+import UIKit
+
+final class LinkingModule: NativeModule {
+    var moduleName: String { "Linking" }
+
+    /// The URL that launched the app. Set by the host app's SceneDelegate
+    /// or AppDelegate before the JS bundle loads.
+    static var initialURL: String?
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        switch method {
+        case "openURL":
+            guard let urlString = args.first as? String,
+                  let url = URL(string: urlString) else {
+                callback(nil, "Invalid URL")
+                return
+            }
+            DispatchQueue.main.async {
+                UIApplication.shared.open(url, options: [:]) { success in
+                    callback(success, success ? nil : "Failed to open URL")
+                }
+            }
+        case "canOpenURL":
+            guard let urlString = args.first as? String,
+                  let url = URL(string: urlString) else {
+                callback(false, nil)
+                return
+            }
+            DispatchQueue.main.async {
+                callback(UIApplication.shared.canOpenURL(url), nil)
+            }
+        case "getInitialURL":
+            callback(LinkingModule.initialURL, nil)
+        default:
+            callback(nil, "Unknown method: \(method)")
+        }
+    }
+
+    func invokeSync(method: String, args: [Any]) -> Any? { nil }
+}
+#endif

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

@@ -0,0 +1,28 @@
+#if canImport(UIKit)
+import Foundation
+
+/// Protocol that all native modules must conform to.
+/// Modules are registered with NativeModuleRegistry and invoked from JS
+/// via NativeBridge's invokeNativeModule / invokeNativeModuleSync operations.
+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?
+}
+
+extension NativeModule {
+    /// Default sync implementation: just returns nil.
+    func invokeSync(method: String, args: [Any]) -> Any? { return nil }
+}
+#endif

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

@@ -0,0 +1,78 @@
+#if canImport(UIKit)
+import Foundation
+
+/// Singleton registry for all native modules.
+/// Modules are registered by name and looked up when JS invokes them.
+@MainActor
+final class NativeModuleRegistry {
+
+    static let shared = NativeModuleRegistry()
+
+    private var modules: [String: NativeModule] = [:]
+
+    private init() {}
+
+    // MARK: - Registration
+
+    func register(_ module: NativeModule) {
+        modules[module.moduleName] = module
+    }
+
+    /// Register all built-in modules.
+    func registerDefaults() {
+        register(HapticsModule())
+        register(AsyncStorageModule())
+        register(ClipboardModule())
+        register(DeviceInfoModule())
+        register(KeyboardModule())
+        register(AnimationModule())
+        let bridge = NativeBridge.shared
+        register(NetworkModule(bridge: bridge))
+        register(AppStateModule(bridge: bridge))
+        register(LinkingModule())
+        register(ShareModule())
+        // Phase 2 modules
+        register(PermissionsModule())
+        register(GeolocationModule(bridge: bridge))
+        register(CameraModule())
+        register(NotificationsModule(bridge: bridge))
+        register(BiometryModule())
+        register(SecureStorageModule())
+        register(WebSocketModule(bridge: bridge))
+        register(FileSystemModule())
+        register(SensorsModule(bridge: bridge))
+        register(AudioModule())
+        register(DatabaseModule())
+        register(PerformanceModule(bridge: bridge))
+        if #available(iOS 13.0, *) {
+            register(BackgroundTaskModule(bridge: bridge))
+        }
+        register(OTAModule(bridge: bridge))
+        if #available(iOS 15.0, *) {
+            register(IAPModule(bridge: bridge))
+        }
+        register(SocialAuthModule(bridge: bridge))
+        register(BluetoothModule(bridge: bridge))
+        register(CalendarModule())
+        register(ContactsModule())
+    }
+
+    // MARK: - Invocation
+
+    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)
+    }
+
+    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)
+    }
+}
+#endif

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

@@ -0,0 +1,62 @@
+#if canImport(UIKit)
+import Network
+import Foundation
+
+/// Monitors network connectivity and pushes changes to JS via global events.
+/// Use: NativeBridge.shared.dispatchGlobalEvent("network:change", payload: [...])
+final class NetworkModule: NativeModule {
+    var moduleName: String { "Network" }
+
+    private let monitor = NWPathMonitor()
+    private let monitorQueue = DispatchQueue(label: "vue-native.network")
+    private weak var bridge: NativeBridge?
+
+    init(bridge: NativeBridge) {
+        self.bridge = bridge
+        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 bridge = self?.bridge
+            // dispatchGlobalEvent is @MainActor-isolated — dispatch to main queue
+            DispatchQueue.main.async {
+                bridge?.dispatchGlobalEvent("network:change", payload: [
+                    "isConnected": isConnected,
+                    "connectionType": connectionType
+                ])
+            }
+        }
+        monitor.start(queue: monitorQueue)
+    }
+
+    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)")
+        }
+    }
+
+    func invokeSync(method: String, args: [Any]) -> Any? { nil }
+}
+#endif