@thelacanians/vue-native-cli 0.4.15 → 0.6.2

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

@@ -0,0 +1,49 @@
+import AppKit
+import VueNativeShared
+
+/// Native module providing device and screen information for macOS.
+///
+/// Methods:
+///   - getInfo() -> { platform, systemName, systemVersion, model, name, 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 processInfo = ProcessInfo.processInfo
+                let version = processInfo.operatingSystemVersion
+
+                var systemInfo = utsname()
+                uname(&systemInfo)
+                let machine = withUnsafePointer(to: &systemInfo.machine) {
+                    $0.withMemoryRebound(to: CChar.self, capacity: 1) {
+                        String(validatingUTF8: $0) ?? "unknown"
+                    }
+                }
+
+                let screen = NSScreen.main
+                let screenWidth = screen?.frame.width ?? 0
+                let screenHeight = screen?.frame.height ?? 0
+                let scale = screen?.backingScaleFactor ?? 1.0
+
+                let info: [String: Any] = [
+                    "platform": "macos",
+                    "systemName": "macOS",
+                    "systemVersion": "\(version.majorVersion).\(version.minorVersion).\(version.patchVersion)",
+                    "model": machine,
+                    "name": Host.current().localizedName ?? "Mac",
+                    "isSimulator": false,
+                    "screenWidth": screenWidth,
+                    "screenHeight": screenHeight,
+                    "scale": scale,
+                ]
+                callback(info, nil)
+
+            default:
+                callback(nil, "DeviceInfoModule: Unknown method '\(method)'")
+            }
+        }
+    }
+}

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

@@ -0,0 +1,50 @@
+import AppKit
+import VueNativeShared
+
+/// macOS-only module for drag and drop support.
+///
+/// Methods:
+///   - enableDropZone(viewId: Int) -- register a view for file/text drops
+///   - startDrag(data: { text: String }) -- initiate a drag operation
+///
+/// Events dispatched:
+///   - dragDrop:drop { files: [String], text: String? }
+final class DragDropModule: NativeModule {
+    let moduleName = "DragDrop"
+    private weak var dispatcher: NativeEventDispatcher?
+
+    init(dispatcher: NativeEventDispatcher) {
+        self.dispatcher = dispatcher
+    }
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        DispatchQueue.main.async { [weak self] in
+            switch method {
+            case "enableDropZone":
+                guard args.first is Int else {
+                    callback(nil, "Invalid viewId")
+                    return
+                }
+                // Register the main window's content view for file and string drops.
+                // Full per-view registration would require access to the bridge's view registry.
+                if let window = NSApp.mainWindow, let view = window.contentView {
+                    view.registerForDraggedTypes([.fileURL, .string])
+                }
+                callback(nil, nil)
+
+            case "startDrag":
+                guard let data = args.first as? [String: Any] else {
+                    callback(nil, "Invalid args")
+                    return
+                }
+                // Drag operations are typically initiated by mouse events.
+                // This method prepares drag data that can be used by event handlers.
+                _ = data
+                callback(nil, nil)
+
+            default:
+                callback(nil, "DragDropModule: Unknown method '\(method)'")
+            }
+        }
+    }
+}

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

@@ -0,0 +1,86 @@
+import AppKit
+import UniformTypeIdentifiers
+import VueNativeShared
+
+/// macOS-only module for file open/save dialogs.
+///
+/// Methods:
+///   - openFile(options?: { multiple?, allowedTypes?, title? }) -> [String]? (file paths)
+///   - openDirectory(options?: { title? }) -> String? (directory path)
+///   - saveFile(options?: { title?, defaultName? }) -> String? (save path)
+final class FileDialogModule: NativeModule {
+    let moduleName = "FileDialog"
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        DispatchQueue.main.async {
+            switch method {
+            case "openFile":
+                let options = args.first as? [String: Any] ?? [:]
+                let panel = NSOpenPanel()
+                panel.canChooseFiles = true
+                panel.canChooseDirectories = false
+                panel.allowsMultipleSelection = (options["multiple"] as? Bool) ?? false
+
+                if let types = options["allowedTypes"] as? [String] {
+                    panel.allowedContentTypes = types.compactMap { ext in
+                        UTType(filenameExtension: ext)
+                    }
+                }
+
+                if let title = options["title"] as? String {
+                    panel.title = title
+                }
+
+                panel.begin { response in
+                    if response == .OK {
+                        let urls = panel.urls.map { $0.path }
+                        callback(urls, nil)
+                    } else {
+                        callback(nil, nil) // cancelled
+                    }
+                }
+
+            case "openDirectory":
+                let options = args.first as? [String: Any] ?? [:]
+                let panel = NSOpenPanel()
+                panel.canChooseFiles = false
+                panel.canChooseDirectories = true
+                panel.allowsMultipleSelection = false
+
+                if let title = options["title"] as? String {
+                    panel.title = title
+                }
+
+                panel.begin { response in
+                    if response == .OK {
+                        callback(panel.url?.path, nil)
+                    } else {
+                        callback(nil, nil)
+                    }
+                }
+
+            case "saveFile":
+                let options = args.first as? [String: Any] ?? [:]
+                let panel = NSSavePanel()
+
+                if let title = options["title"] as? String {
+                    panel.title = title
+                }
+                if let defaultName = options["defaultName"] as? String {
+                    panel.nameFieldStringValue = defaultName
+                }
+
+                panel.begin { response in
+                    if response == .OK {
+                        callback(panel.url?.path, nil)
+                    } else {
+                        callback(nil, nil)
+                    }
+                }
+
+            default:
+                callback(nil, "FileDialogModule: Unknown method '\(method)'")
+            }
+        }
+    }
+}

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

@@ -0,0 +1,42 @@
+import AppKit
+import VueNativeShared
+
+/// Native module providing haptic feedback via Force Touch trackpad.
+///
+/// Methods:
+///   - vibrate(style: String) -- trigger haptic feedback ("light"|"medium"|"heavy")
+///   - notificationFeedback(type: String) -- generic haptic (macOS has no distinct types)
+///   - selectionChanged() -- alignment 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 pattern: NSHapticFeedbackManager.FeedbackPattern
+                switch style {
+                case "light": pattern = .alignment
+                case "medium": pattern = .levelChange
+                case "heavy": pattern = .generic
+                default: pattern = .generic
+                }
+                NSHapticFeedbackManager.defaultPerformer.perform(pattern, performanceTime: .now)
+                callback(nil, nil)
+
+            case "notificationFeedback":
+                // macOS doesn't have distinct notification haptics — use generic
+                NSHapticFeedbackManager.defaultPerformer.perform(.generic, performanceTime: .now)
+                callback(nil, nil)
+
+            case "selectionChanged":
+                NSHapticFeedbackManager.defaultPerformer.perform(.alignment, performanceTime: .now)
+                callback(nil, nil)
+
+            default:
+                callback(nil, "HapticsModule: Unknown method '\(method)'")
+            }
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+import AppKit
+import VueNativeShared
+
+/// Native module providing keyboard management for macOS.
+///
+/// Methods:
+///   - dismiss() -- resign first responder (dismiss any focused input)
+///   - getHeight() -> { height: 0, isVisible: false } (macOS has no virtual keyboard)
+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":
+                NSApp.mainWindow?.makeFirstResponder(nil)
+                callback(nil, nil)
+
+            case "getHeight":
+                // macOS has no virtual keyboard
+                callback(["height": 0.0, "isVisible": false], nil)
+
+            default:
+                callback(nil, "KeyboardModule: Unknown method '\(method)'")
+            }
+        }
+    }
+}

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

@@ -0,0 +1,49 @@
+import AppKit
+import VueNativeShared
+
+/// Native module for opening URLs and deep links on macOS.
+///
+/// Methods:
+///   - openURL(url: String) -> Bool
+///   - canOpenURL(url: String) -> Bool
+///   - getInitialURL() -> String?
+final class LinkingModule: NativeModule {
+    var moduleName: String { "Linking" }
+
+    /// The URL that launched the app. Set by the host app 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 {
+                let success = NSWorkspace.shared.open(url)
+                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 {
+                let canOpen = NSWorkspace.shared.urlForApplication(toOpen: url) != nil
+                callback(canOpen, nil)
+            }
+
+        case "getInitialURL":
+            callback(LinkingModule.initialURL, nil)
+
+        default:
+            callback(nil, "LinkingModule: Unknown method '\(method)'")
+        }
+    }
+
+    func invokeSync(method: String, args: [Any]) -> Any? { nil }
+}

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

@@ -0,0 +1,95 @@
+import AppKit
+import VueNativeShared
+
+/// macOS-only module for menu bar control.
+///
+/// Methods:
+///   - setAppMenu(items: [{ title, items: [{ title, key?, id?, separator?, disabled? }] }])
+///   - showContextMenu(items: [{ title, key?, id?, separator?, disabled? }])
+///
+/// Events dispatched:
+///   - menu:itemClick { id, title }
+final class MenuModule: NativeModule {
+    let moduleName = "Menu"
+    private weak var dispatcher: NativeEventDispatcher?
+
+    init(dispatcher: NativeEventDispatcher) {
+        self.dispatcher = dispatcher
+    }
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        DispatchQueue.main.async { [weak self] in
+            switch method {
+            case "setAppMenu":
+                guard let items = args.first as? [[String: Any]] else {
+                    callback(nil, "Invalid args")
+                    return
+                }
+                self?.buildMenu(items: items)
+                callback(nil, nil)
+
+            case "showContextMenu":
+                guard let items = args.first as? [[String: Any]] else {
+                    callback(nil, "Invalid args")
+                    return
+                }
+                let menu = NSMenu()
+                self?.addMenuItems(items, to: menu)
+
+                if let window = NSApp.mainWindow, let view = window.contentView {
+                    let location = NSEvent.mouseLocation
+                    let windowPoint = window.convertPoint(fromScreen: location)
+                    let viewPoint = view.convert(windowPoint, from: nil)
+                    menu.popUp(positioning: nil, at: viewPoint, in: view)
+                }
+                callback(nil, nil)
+
+            default:
+                callback(nil, "MenuModule: Unknown method '\(method)'")
+            }
+        }
+    }
+
+    private func buildMenu(items: [[String: Any]]) {
+        let mainMenu = NSMenu()
+        for item in items {
+            guard let title = item["title"] as? String else { continue }
+            let menuItem = NSMenuItem(title: title, action: nil, keyEquivalent: "")
+            let submenu = NSMenu(title: title)
+            if let children = item["items"] as? [[String: Any]] {
+                addMenuItems(children, to: submenu)
+            }
+            menuItem.submenu = submenu
+            mainMenu.addItem(menuItem)
+        }
+        NSApp.mainMenu = mainMenu
+    }
+
+    private func addMenuItems(_ items: [[String: Any]], to menu: NSMenu) {
+        for item in items {
+            if let separator = item["separator"] as? Bool, separator {
+                menu.addItem(.separator())
+                continue
+            }
+
+            guard let title = item["title"] as? String else { continue }
+            let key = item["key"] as? String ?? ""
+            let id = item["id"] as? String ?? title
+
+            let menuItem = NSMenuItem(title: title, action: #selector(menuItemClicked(_:)), keyEquivalent: key)
+            menuItem.target = self
+            menuItem.representedObject = id
+
+            if let disabled = item["disabled"] as? Bool, disabled {
+                menuItem.isEnabled = false
+            }
+
+            menu.addItem(menuItem)
+        }
+    }
+
+    @objc private func menuItemClicked(_ sender: NSMenuItem) {
+        guard let id = sender.representedObject as? String else { return }
+        dispatcher?.dispatchGlobalEvent("menu:itemClick", payload: ["id": id, "title": sender.title])
+    }
+}

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

@@ -0,0 +1,63 @@
+import AppKit
+import VueNativeShared
+
+/// 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 macOS modules.
+    func registerDefaults(dispatcher: NativeEventDispatcher, viewLookup: @escaping (Int) -> NSView?) {
+        // Cross-platform ports
+        register(HapticsModule())
+        register(ClipboardModule())
+        register(DeviceInfoModule())
+        register(AnimationModule(viewLookup: viewLookup))
+        register(AppStateModule(dispatcher: dispatcher))
+        register(KeyboardModule())
+        register(LinkingModule())
+        register(ShareModule())
+
+        // macOS-only modules
+        register(WindowModule())
+        register(MenuModule(dispatcher: dispatcher))
+        register(FileDialogModule())
+        register(DragDropModule(dispatcher: dispatcher))
+
+        // Additional cross-platform modules
+        register(CameraModule())
+        register(NotificationsModule())
+        register(BiometryModule())
+        register(PermissionsModule())
+    }
+
+    // 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)
+    }
+}

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

@@ -0,0 +1,112 @@
+import UserNotifications
+import AppKit
+import VueNativeShared
+
+/// Native module providing local notification access on macOS.
+///
+/// Methods:
+///   - requestPermission() -> Bool
+///   - checkPermission() -> "granted"/"denied"/"notDetermined"
+///   - scheduleLocal(title, body, delay) -> { id }
+///   - cancelAll()
+///   - cancel(id)
+///   - getBadgeCount() -> String?
+///   - setBadgeCount(count)
+final class NotificationsModule: NativeModule {
+    let moduleName = "Notifications"
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        let center = UNUserNotificationCenter.current()
+
+        switch method {
+        case "requestPermission":
+            center.requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
+                if let error = error {
+                    callback(nil, "Notification permission error: \(error.localizedDescription)")
+                } else {
+                    callback(granted, nil)
+                }
+            }
+
+        case "checkPermission":
+            center.getNotificationSettings { settings in
+                let result: String
+                switch settings.authorizationStatus {
+                case .authorized, .provisional, .ephemeral:
+                    result = "granted"
+                case .denied:
+                    result = "denied"
+                case .notDetermined:
+                    result = "notDetermined"
+                @unknown default:
+                    result = "notDetermined"
+                }
+                callback(result, nil)
+            }
+
+        case "scheduleLocal":
+            let title = args.count > 0 ? (args[0] as? String ?? "") : ""
+            let body = args.count > 1 ? (args[1] as? String ?? "") : ""
+            let delay = args.count > 2 ? (args[2] as? Double ?? 1.0) : 1.0
+
+            let content = UNMutableNotificationContent()
+            content.title = title
+            content.body = body
+            content.sound = .default
+
+            let trigger = UNTimeIntervalNotificationTrigger(
+                timeInterval: max(delay, 0.1),
+                repeats: false
+            )
+
+            let requestId = UUID().uuidString
+            let request = UNNotificationRequest(
+                identifier: requestId,
+                content: content,
+                trigger: trigger
+            )
+
+            center.add(request) { error in
+                if let error = error {
+                    callback(nil, "Schedule error: \(error.localizedDescription)")
+                } else {
+                    callback(["id": requestId], nil)
+                }
+            }
+
+        case "cancelAll":
+            center.removeAllPendingNotificationRequests()
+            callback(nil, nil)
+
+        case "cancel":
+            guard let identifier = args.first as? String else {
+                callback(nil, "cancel: missing notification id")
+                return
+            }
+            center.removePendingNotificationRequests(withIdentifiers: [identifier])
+            callback(nil, nil)
+
+        case "getBadgeCount":
+            DispatchQueue.main.async {
+                let badge = NSApplication.shared.dockTile.badgeLabel
+                callback(badge, nil)
+            }
+
+        case "setBadgeCount":
+            let count = args.first
+            DispatchQueue.main.async {
+                if let num = count as? Int {
+                    NSApplication.shared.dockTile.badgeLabel = num == 0 ? nil : String(num)
+                } else if let str = count as? String {
+                    NSApplication.shared.dockTile.badgeLabel = str.isEmpty ? nil : str
+                } else {
+                    NSApplication.shared.dockTile.badgeLabel = nil
+                }
+                callback(nil, nil)
+            }
+
+        default:
+            callback(nil, "NotificationsModule: Unknown method '\(method)'")
+        }
+    }
+}