@thelacanians/vue-native-cli 0.4.14 → 0.6.0

package/native/macos/VueNativeMacOS/Sources/VueNativeMacOS/Modules/PermissionsModule.swift

@@ -0,0 +1,149 @@
+import AVFoundation
+import UserNotifications
+import CoreLocation
+import Contacts
+import VueNativeShared
+
+/// Native module for checking and requesting system permissions on macOS.
+///
+/// Methods:
+///   - check(type: String) -> "granted"/"denied"/"undetermined"
+///   - request(type: String) -> "granted"/"denied"
+///
+/// Supported permission types: "camera", "microphone", "notifications", "location", "contacts"
+final class PermissionsModule: NativeModule {
+    let moduleName = "Permissions"
+
+    private lazy var locationManager = CLLocationManager()
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        guard let permissionType = args.first as? String else {
+            callback(nil, "PermissionsModule: missing permission type argument")
+            return
+        }
+
+        switch method {
+        case "check":
+            checkPermission(type: permissionType, callback: callback)
+
+        case "request":
+            requestPermission(type: permissionType, callback: callback)
+
+        default:
+            callback(nil, "PermissionsModule: Unknown method '\(method)'")
+        }
+    }
+
+    // MARK: - Check
+
+    private func checkPermission(type: String, callback: @escaping (Any?, String?) -> Void) {
+        switch type {
+        case "camera":
+            let status = AVCaptureDevice.authorizationStatus(for: .video)
+            callback(mapAVStatus(status), nil)
+
+        case "microphone":
+            let status = AVCaptureDevice.authorizationStatus(for: .audio)
+            callback(mapAVStatus(status), nil)
+
+        case "notifications":
+            UNUserNotificationCenter.current().getNotificationSettings { settings in
+                let result: String
+                switch settings.authorizationStatus {
+                case .authorized, .provisional, .ephemeral:
+                    result = "granted"
+                case .denied:
+                    result = "denied"
+                case .notDetermined:
+                    result = "undetermined"
+                @unknown default:
+                    result = "undetermined"
+                }
+                callback(result, nil)
+            }
+
+        case "location":
+            let status: CLAuthorizationStatus
+            status = locationManager.authorizationStatus
+            callback(mapCLStatus(status), nil)
+
+        case "contacts":
+            let status = CNContactStore.authorizationStatus(for: .contacts)
+            switch status {
+            case .authorized:
+                callback("granted", nil)
+            case .denied, .restricted:
+                callback("denied", nil)
+            case .notDetermined:
+                callback("undetermined", nil)
+            @unknown default:
+                callback("undetermined", nil)
+            }
+
+        default:
+            callback(nil, "PermissionsModule: Unsupported permission type '\(type)'")
+        }
+    }
+
+    // MARK: - Request
+
+    private func requestPermission(type: String, callback: @escaping (Any?, String?) -> Void) {
+        switch type {
+        case "camera":
+            AVCaptureDevice.requestAccess(for: .video) { granted in
+                callback(granted ? "granted" : "denied", nil)
+            }
+
+        case "microphone":
+            AVCaptureDevice.requestAccess(for: .audio) { granted in
+                callback(granted ? "granted" : "denied", nil)
+            }
+
+        case "notifications":
+            UNUserNotificationCenter.current().requestAuthorization(
+                options: [.alert, .sound, .badge]
+            ) { granted, _ in
+                callback(granted ? "granted" : "denied", nil)
+            }
+
+        case "location":
+            locationManager.requestWhenInUseAuthorization()
+            // CLLocationManager doesn't provide a completion handler.
+            // Return current status; JS side should re-check after a delay.
+            let status = locationManager.authorizationStatus
+            callback(mapCLStatus(status), nil)
+
+        case "contacts":
+            CNContactStore().requestAccess(for: .contacts) { granted, _ in
+                callback(granted ? "granted" : "denied", nil)
+            }
+
+        default:
+            callback(nil, "PermissionsModule: Unsupported permission type '\(type)'")
+        }
+    }
+
+    // MARK: - Helpers
+
+    private func mapAVStatus(_ status: AVAuthorizationStatus) -> String {
+        switch status {
+        case .authorized: return "granted"
+        case .denied, .restricted: return "denied"
+        case .notDetermined: return "undetermined"
+        @unknown default: return "undetermined"
+        }
+    }
+
+    private func mapCLStatus(_ status: CLAuthorizationStatus) -> String {
+        switch status {
+        case .authorizedAlways:
+            return "granted"
+        case .denied, .restricted:
+            return "denied"
+        case .notDetermined:
+            return "undetermined"
+        @unknown default:
+            return "undetermined"
+        }
+    }
+}

package/native/macos/VueNativeMacOS/Sources/VueNativeMacOS/Modules/ShareModule.swift

@@ -0,0 +1,37 @@
+import AppKit
+import VueNativeShared
+
+/// Native module for sharing content on macOS via NSSharingServicePicker.
+///
+/// Methods:
+///   - share({ message?: String, url?: String }) -> { action: String }
+final class ShareModule: NativeModule {
+    var moduleName: String { "Share" }
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        switch method {
+        case "share":
+            guard let content = args.first as? [String: Any] else {
+                callback(nil, "Invalid content")
+                return
+            }
+            var items: [Any] = []
+            if let message = content["message"] as? String { items.append(message) }
+            if let urlStr = content["url"] as? String, let u = URL(string: urlStr) { items.append(u) }
+            if items.isEmpty { callback(nil, "No shareable content"); return }
+
+            DispatchQueue.main.async {
+                let picker = NSSharingServicePicker(items: items)
+                if let window = NSApp.mainWindow, let view = window.contentView {
+                    picker.show(relativeTo: view.bounds, of: view, preferredEdge: .minY)
+                }
+                callback(["action": "shared"], nil)
+            }
+
+        default:
+            callback(nil, "ShareModule: Unknown method '\(method)'")
+        }
+    }
+
+    func invokeSync(method: String, args: [Any]) -> Any? { nil }
+}

package/native/macos/VueNativeMacOS/Sources/VueNativeMacOS/Modules/WindowModule.swift

@@ -0,0 +1,71 @@
+import AppKit
+import VueNativeShared
+
+/// macOS-only module for window management.
+///
+/// Methods:
+///   - setTitle(title: String)
+///   - setSize(width: Double, height: Double)
+///   - center()
+///   - minimize()
+///   - toggleFullScreen()
+///   - close()
+///   - getInfo() -> { width, height, x, y, isFullScreen, isVisible, title }
+final class WindowModule: NativeModule {
+    let moduleName = "Window"
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        DispatchQueue.main.async {
+            switch method {
+            case "setTitle":
+                let title = args.first as? String ?? ""
+                NSApp.mainWindow?.title = title
+                callback(nil, nil)
+
+            case "setSize":
+                guard args.count >= 2,
+                      let width = args[0] as? Double,
+                      let height = args[1] as? Double else {
+                    callback(nil, "Invalid args")
+                    return
+                }
+                NSApp.mainWindow?.setContentSize(NSSize(width: width, height: height))
+                callback(nil, nil)
+
+            case "center":
+                NSApp.mainWindow?.center()
+                callback(nil, nil)
+
+            case "minimize":
+                NSApp.mainWindow?.miniaturize(nil)
+                callback(nil, nil)
+
+            case "toggleFullScreen":
+                NSApp.mainWindow?.toggleFullScreen(nil)
+                callback(nil, nil)
+
+            case "close":
+                NSApp.mainWindow?.close()
+                callback(nil, nil)
+
+            case "getInfo":
+                guard let window = NSApp.mainWindow else {
+                    callback(nil, "No main window")
+                    return
+                }
+                callback([
+                    "width": window.frame.width,
+                    "height": window.frame.height,
+                    "x": window.frame.origin.x,
+                    "y": window.frame.origin.y,
+                    "isFullScreen": window.styleMask.contains(.fullScreen),
+                    "isVisible": window.isVisible,
+                    "title": window.title,
+                ], nil)
+
+            default:
+                callback(nil, "WindowModule: Unknown method '\(method)'")
+            }
+        }
+    }
+}

package/native/macos/VueNativeMacOS/Sources/VueNativeMacOS/Resources/vue-native-placeholder.js

@@ -0,0 +1,2 @@
+// Placeholder JS bundle — replaced by the real app bundle at build time.
+console.log("[VueNative macOS] Placeholder bundle loaded. Replace with your app bundle.");