@thelacanians/vue-native-cli 0.4.14 → 0.6.0

package/native/macos/VueNativeMacOS/Sources/VueNativeMacOS/Bridge/VueNativeWindowController.swift

@@ -0,0 +1,125 @@
+import AppKit
+
+/// Base window controller for Vue Native macOS apps.
+/// Subclass and override `bundleName` and optionally `devServerURL`.
+///
+/// Usage:
+/// ```swift
+/// class MainWindowController: VueNativeWindowController {
+///     override var bundleName: String { "vue-native-bundle" }
+///     override var devServerURL: URL? {
+///         #if DEBUG
+///         URL(string: "ws://localhost:8174")
+///         #else
+///         nil
+///         #endif
+///     }
+/// }
+/// ```
+open class VueNativeWindowController: NSWindowController {
+
+    // MARK: - Overridable API
+
+    /// Name of the JS bundle resource (without extension) bundled in your app target.
+    open var bundleName: String { "vue-native-bundle" }
+
+    /// WebSocket URL of the Vite dev server for hot reload.
+    /// Return `nil` (the default) to disable hot reload and load only from the bundle.
+    open var devServerURL: URL? { nil }
+
+    // MARK: - Private state
+
+    private let runtime = JSRuntime.shared
+    private let bridge  = NativeBridge.shared
+
+    // MARK: - Convenience initializer
+
+    public convenience init() {
+        let window = NSWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 800, height: 600),
+            styleMask: [.titled, .closable, .resizable, .miniaturizable],
+            backing: .buffered,
+            defer: false
+        )
+        window.center()
+        window.title = "Vue Native"
+
+        // Use a FlippedView as the content view so all coordinates are top-left origin.
+        let flippedContent = FlippedView(frame: window.contentView!.bounds)
+        flippedContent.autoresizingMask = [.width, .height]
+        window.contentView = flippedContent
+
+        self.init(window: window)
+    }
+
+    // MARK: - Lifecycle
+
+    override open func windowDidLoad() {
+        super.windowDidLoad()
+
+        guard let contentView = window?.contentView else { return }
+        contentView.wantsLayer = true
+        contentView.layer?.backgroundColor = NSColor.black.cgColor
+
+        // Initialize JS engine first, then bridge.
+        runtime.initialize { [weak self] in
+            guard let self = self else { return }
+            self.bridge.initialize(contentView: contentView)
+            DispatchQueue.main.async {
+                self.loadBundle()
+            }
+        }
+    }
+
+    // MARK: - Bundle loading
+
+    private func loadBundle() {
+        #if DEBUG
+        if let wsURL = devServerURL {
+            HotReloadManager.shared.connect(to: wsURL)
+        }
+        #endif
+        loadEmbeddedBundle()
+    }
+
+    private func loadEmbeddedBundle() {
+        runtime.loadBundle(source: .embedded(name: bundleName)) { success in
+            if !success {
+                NSLog("[VueNative macOS] ERROR: Failed to load bundle '%@'", self.bundleName)
+            }
+        }
+    }
+}
+
+// MARK: - VueNativeAppDelegate
+
+/// Convenience NSApplicationDelegate for single-window Vue Native apps.
+/// Subclass and override `createWindowController()` to provide your custom window controller.
+///
+/// Usage:
+/// ```swift
+/// @main
+/// class AppDelegate: VueNativeAppDelegate {
+///     override func createWindowController() -> VueNativeWindowController {
+///         return MainWindowController()
+///     }
+/// }
+/// ```
+open class VueNativeAppDelegate: NSObject, NSApplicationDelegate {
+    public var windowController: VueNativeWindowController?
+
+    open func applicationDidFinishLaunching(_ notification: Notification) {
+        let controller = createWindowController()
+        controller.showWindow(nil)
+        windowController = controller
+    }
+
+    /// Override this to provide your custom VueNativeWindowController subclass.
+    open func createWindowController() -> VueNativeWindowController {
+        return VueNativeWindowController()
+    }
+
+    open func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool {
+        return true
+    }
+}

package/native/macos/VueNativeMacOS/Sources/VueNativeMacOS/Components/ComponentRegistry.swift

@@ -0,0 +1,209 @@
+import AppKit
+import ObjectiveC
+
+// MARK: - Associated object key for factory reference
+
+private var factoryAssociatedKey: UInt8 = 0
+
+// MARK: - ComponentRegistry
+
+/// Singleton registry that maps component type strings (e.g., "VView", "VText")
+/// to their corresponding NativeComponentFactory instances.
+/// When a view is created by a factory, the factory reference is stored on the
+/// view via objc_setAssociatedObject for later prop updates and event wiring.
+@MainActor
+final class ComponentRegistry {
+
+    // MARK: - Singleton
+
+    static let shared = ComponentRegistry()
+
+    // MARK: - Properties
+
+    /// Mapping from component type strings to factory instances.
+    private var factories: [String: NativeComponentFactory] = [:]
+
+    // MARK: - Initialization
+
+    private init() {
+        registerDefaults()
+    }
+
+    /// Register all built-in component factories.
+    private func registerDefaults() {
+        // Core components (Phase 1)
+        register("VView", factory: VViewFactory())
+        register("VText", factory: VTextFactory())
+        register("VButton", factory: VButtonFactory())
+        register("VInput", factory: VInputFactory())
+        register("VSwitch", factory: VSwitchFactory())
+        register("__ROOT__", factory: VRootFactory())
+
+        // Simple controls (Phase 2)
+        register("VSlider", factory: VSliderFactory())
+        register("VProgressBar", factory: VProgressBarFactory())
+        register("VActivityIndicator", factory: VActivityIndicatorFactory())
+        register("VPicker", factory: VPickerFactory())
+        register("VSegmentedControl", factory: VSegmentedControlFactory())
+        register("VCheckbox", factory: VCheckboxFactory())
+        register("VRadio", factory: VRadioFactory())
+        register("VDropdown", factory: VDropdownFactory())
+
+        // Complex components (Phase 2)
+        register("VScrollView", factory: VScrollViewFactory())
+        register("VList", factory: VListFactory())
+        register("VSectionList", factory: VSectionListFactory())
+        register("VImage", factory: VImageFactory())
+        register("VPressable", factory: VPressableFactory())
+
+        // Dialogs and media (Phase 2)
+        register("VModal", factory: VModalFactory())
+        register("VAlertDialog", factory: VAlertDialogFactory())
+        register("VActionSheet", factory: VActionSheetFactory())
+        register("VWebView", factory: VWebViewFactory())
+        register("VVideo", factory: VVideoFactory())
+
+        // Platform stubs (no-op on macOS)
+        register("VStatusBar", factory: VStatusBarFactory())
+        register("VKeyboardAvoiding", factory: VKeyboardAvoidingFactory())
+        register("VSafeArea", factory: VSafeAreaFactory())
+        register("VRefreshControl", factory: VRefreshControlFactory())
+
+        // macOS-specific components (Phase 3)
+        register("VToolbar", factory: VToolbarFactory())
+        register("VSplitView", factory: VSplitViewFactory())
+        register("VOutlineView", factory: VOutlineViewFactory())
+    }
+
+    // MARK: - Registration
+
+    /// Register a factory for a given component type string.
+    /// Replaces any existing factory for that type.
+    func register(_ type: String, factory: NativeComponentFactory) {
+        factories[type] = factory
+    }
+
+    /// Unregister a factory for a given component type string.
+    func unregister(_ type: String) {
+        factories.removeValue(forKey: type)
+    }
+
+    // MARK: - View Creation
+
+    /// Create a new NSView for the given component type.
+    /// Returns nil if no factory is registered for the type.
+    /// The factory is stored as an associated object on the created view
+    /// so it can be retrieved later for prop updates and event handling.
+    func createView(type: String) -> NSView? {
+        guard let factory = factories[type] else {
+            NSLog("[VueNative] Warning: No factory registered for component type '%@'", type)
+            return nil
+        }
+
+        let view = factory.createView()
+
+        // Store factory reference on the view for later lookups
+        objc_setAssociatedObject(
+            view,
+            &factoryAssociatedKey,
+            FactoryBox(factory: factory),
+            .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+        )
+
+        return view
+    }
+
+    // MARK: - Factory Retrieval
+
+    /// Retrieve the factory for the given component type string.
+    func factory(for type: String) -> NativeComponentFactory? {
+        return factories[type]
+    }
+
+    /// Retrieve the factory that was used to create the given view.
+    /// Uses the associated object stored during createView().
+    static func factory(for view: NSView) -> NativeComponentFactory? {
+        guard let box = objc_getAssociatedObject(view, &factoryAssociatedKey) as? FactoryBox else {
+            return nil
+        }
+        return box.factory
+    }
+
+    // MARK: - Prop Updates
+
+    /// Update a property on a view using its associated factory.
+    func updateProp(view: NSView, key: String, value: Any?) {
+        guard let factory = ComponentRegistry.factory(for: view) else {
+            NSLog("[VueNative] Warning: No factory found for view %@", String(describing: Swift.type(of: view)))
+            return
+        }
+        factory.updateProp(view: view, key: key, value: value)
+    }
+
+    // MARK: - Event Listeners
+
+    /// Add an event listener to a view using its associated factory.
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void) {
+        guard let factory = ComponentRegistry.factory(for: view) else {
+            NSLog("[VueNative] Warning: No factory found for view %@", String(describing: Swift.type(of: view)))
+            return
+        }
+        factory.addEventListener(view: view, event: event, handler: handler)
+    }
+
+    /// Remove an event listener from a view using its associated factory.
+    func removeEventListener(view: NSView, event: String) {
+        guard let factory = ComponentRegistry.factory(for: view) else { return }
+        factory.removeEventListener(view: view, event: event)
+    }
+}
+
+// MARK: - FactoryBox
+
+/// Box wrapper for NativeComponentFactory to store as an associated object.
+/// objc_setAssociatedObject requires an AnyObject, so we wrap the protocol.
+private final class FactoryBox {
+    let factory: NativeComponentFactory
+
+    init(factory: NativeComponentFactory) {
+        self.factory = factory
+    }
+}
+
+// MARK: - VRootFactory
+
+/// Factory for the __ROOT__ component type.
+/// Creates a FlippedView with a LayoutNode that serves as the root container.
+final class VRootFactory: NativeComponentFactory {
+
+    func createView() -> NSView {
+        let view = FlippedView()
+        // Configure the root layout node to fill its container and stack children
+        // vertically (column direction matches the default CSS flex behaviour).
+        let node = view.ensureLayoutNode()
+        node.flexDirection = .column
+        node.flexGrow = 1
+        node.flexShrink = 1
+        node.width = .percent(100)
+        node.height = .percent(100)
+        return view
+    }
+
+    func updateProp(view: NSView, key: String, value: Any?) {
+        // Root view generally doesn't have custom props.
+        // Delegate to StyleEngine for any style-related props.
+        StyleEngine.apply(key: key, value: value, to: view)
+    }
+
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void) {
+        if event == "press" {
+            let wrapper = ClickGestureWrapper(handler: handler)
+            let click = NSClickGestureRecognizer(
+                target: wrapper,
+                action: #selector(ClickGestureWrapper.handleGesture(_:))
+            )
+            view.addGestureRecognizer(click)
+            GestureStorage.store(wrapper, for: view, event: event)
+        }
+    }
+}

package/native/macos/VueNativeMacOS/Sources/VueNativeMacOS/Components/Factories/VActionSheetFactory.swift

@@ -0,0 +1,155 @@
+import AppKit
+import ObjectiveC
+
+/// Factory for VActionSheet — maps to NSMenu (context menu) on macOS.
+/// macOS has no action sheet UI; an NSMenu popup is the closest equivalent.
+/// The view itself is a zero-size hidden placeholder in the native tree.
+final class VActionSheetFactory: NativeComponentFactory {
+
+    // MARK: - Associated object keys
+
+    private static var actionsKey: UInt8 = 0
+    private static var cancelLabelKey: UInt8 = 1
+    nonisolated(unsafe) static var onActionKey: UInt8 = 2
+    nonisolated(unsafe) static var onCancelKey: UInt8 = 3
+    private static var menuDelegateKey: UInt8 = 4
+
+    // MARK: - NativeComponentFactory
+
+    func createView() -> NSView {
+        let view = FlippedView()
+        view.isHidden = true
+        let node = view.ensureLayoutNode()
+        node.width = .points(0)
+        node.height = .points(0)
+        return view
+    }
+
+    func updateProp(view: NSView, key: String, value: Any?) {
+        switch key {
+        case "visible":
+            let visible = (value as? Bool) ?? ((value as? Int).map { $0 != 0 } ?? false)
+            if visible {
+                showMenu(for: view)
+            }
+
+        case "title":
+            // Ignored on macOS — NSMenu doesn't display a title in popup mode
+            break
+
+        case "actions":
+            objc_setAssociatedObject(
+                view, &VActionSheetFactory.actionsKey,
+                value,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+        case "cancelLabel":
+            objc_setAssociatedObject(
+                view, &VActionSheetFactory.cancelLabelKey,
+                value as? String,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+        default:
+            break
+        }
+    }
+
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void) {
+        switch event {
+        case "action":
+            objc_setAssociatedObject(
+                view, &VActionSheetFactory.onActionKey,
+                handler as AnyObject,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+        case "cancel":
+            objc_setAssociatedObject(
+                view, &VActionSheetFactory.onCancelKey,
+                handler as AnyObject,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+        default:
+            break
+        }
+    }
+
+    func removeEventListener(view: NSView, event: String) {
+        switch event {
+        case "action":
+            objc_setAssociatedObject(view, &VActionSheetFactory.onActionKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+        case "cancel":
+            objc_setAssociatedObject(view, &VActionSheetFactory.onCancelKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+        default:
+            break
+        }
+    }
+
+    // MARK: - Menu presentation
+
+    private func showMenu(for view: NSView) {
+        let menu = NSMenu()
+
+        // Parse actions — supports [String] and [[String: Any]] with {label, destructive?}
+        var actionLabels: [String] = []
+        if let actions = objc_getAssociatedObject(view, &VActionSheetFactory.actionsKey) as? [String] {
+            actionLabels = actions
+        } else if let actions = objc_getAssociatedObject(view, &VActionSheetFactory.actionsKey) as? [[String: Any]] {
+            actionLabels = actions.compactMap { $0["label"] as? String }
+        }
+
+        // Create proxy to handle menu item selection
+        let proxy = ActionSheetProxy(view: view)
+        objc_setAssociatedObject(
+            view, &VActionSheetFactory.menuDelegateKey,
+            proxy, .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+        )
+
+        for (index, label) in actionLabels.enumerated() {
+            let item = NSMenuItem(title: label, action: #selector(ActionSheetProxy.itemSelected(_:)), keyEquivalent: "")
+            item.target = proxy
+            item.tag = index
+            menu.addItem(item)
+        }
+
+        // Add separator + cancel item if cancelLabel is set
+        if let cancelLabel = objc_getAssociatedObject(view, &VActionSheetFactory.cancelLabelKey) as? String {
+            menu.addItem(.separator())
+            let cancelItem = NSMenuItem(title: cancelLabel, action: #selector(ActionSheetProxy.cancelSelected(_:)), keyEquivalent: "")
+            cancelItem.target = proxy
+            cancelItem.tag = -1
+            menu.addItem(cancelItem)
+        }
+
+        // Pop up the menu at the view's location (use superview if placeholder is hidden)
+        let targetView = view.superview ?? view
+        let location = NSPoint(x: 0, y: 0)
+        menu.popUp(positioning: nil, at: location, in: targetView)
+    }
+}
+
+// MARK: - ActionSheetProxy
+
+/// Target-action proxy for NSMenu item selection.
+private final class ActionSheetProxy: NSObject {
+    private weak var view: NSView?
+
+    init(view: NSView) {
+        self.view = view
+    }
+
+    @objc func itemSelected(_ sender: NSMenuItem) {
+        guard let view = view else { return }
+        if let handler = objc_getAssociatedObject(view, &VActionSheetFactory.onActionKey) as? ((Any?) -> Void) {
+            handler(["label": sender.title, "index": sender.tag])
+        }
+    }
+
+    @objc func cancelSelected(_ sender: NSMenuItem) {
+        guard let view = view else { return }
+        if let handler = objc_getAssociatedObject(view, &VActionSheetFactory.onCancelKey) as? ((Any?) -> Void) {
+            handler(nil)
+        }
+    }
+}

package/native/macos/VueNativeMacOS/Sources/VueNativeMacOS/Components/Factories/VActivityIndicatorFactory.swift

@@ -0,0 +1,85 @@
+import AppKit
+
+/// Factory for VActivityIndicator — a spinning progress indicator.
+/// Maps to NSProgressIndicator with spinning style.
+final class VActivityIndicatorFactory: NativeComponentFactory {
+
+    // MARK: - NativeComponentFactory
+
+    func createView() -> NSView {
+        let indicator = NSProgressIndicator()
+        indicator.style = .spinning
+        indicator.isIndeterminate = true
+        indicator.isDisplayedWhenStopped = false
+        indicator.wantsLayer = true
+        indicator.ensureLayoutNode()
+        indicator.startAnimation(nil)
+        return indicator
+    }
+
+    func updateProp(view: NSView, key: String, value: Any?) {
+        guard let indicator = view as? NSProgressIndicator else {
+            StyleEngine.apply(key: key, value: value, to: view)
+            return
+        }
+
+        switch key {
+        case "animating":
+            let animating: Bool
+            if let val = value as? Bool {
+                animating = val
+            } else if let val = value as? Int {
+                animating = val != 0
+            } else {
+                animating = true
+            }
+            if animating {
+                indicator.startAnimation(nil)
+            } else {
+                indicator.stopAnimation(nil)
+            }
+
+        case "color":
+            if let colorStr = value as? String {
+                indicator.appearance = nil // Reset to allow tinting
+                indicator.contentFilters = [CIFilter(name: "CIFalseColor",
+                    parameters: [
+                        "inputColor0": CIColor(color: NSColor.fromHex(colorStr))!,
+                        "inputColor1": CIColor(color: NSColor.fromHex(colorStr))!
+                    ])!]
+            } else {
+                indicator.contentFilters = []
+            }
+
+        case "hidesWhenStopped":
+            let hides: Bool
+            if let val = value as? Bool {
+                hides = val
+            } else if let val = value as? Int {
+                hides = val != 0
+            } else {
+                hides = true
+            }
+            indicator.isDisplayedWhenStopped = !hides
+
+        case "size":
+            if let sizeStr = value as? String {
+                switch sizeStr {
+                case "small":
+                    indicator.controlSize = .small
+                case "large":
+                    indicator.controlSize = .large
+                default:
+                    indicator.controlSize = .regular
+                }
+            }
+
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void) {
+        // No events for activity indicator
+    }
+}