@thelacanians/vue-native-cli 0.4.14 → 0.6.0

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

@@ -0,0 +1,276 @@
+import AppKit
+import ObjectiveC
+
+/// Factory for VOutlineView — macOS-specific tree/outline view component.
+/// Maps to NSOutlineView wrapped in an NSScrollView.
+///
+/// Props:
+///   - data: [{ id, label, children?: [...] }]
+///   - expandAll: Bool
+///   - selectionMode: "single" | "multiple" | "none"
+///
+/// Events:
+///   - select -> { id, label }
+///   - expand -> { id }
+///   - collapse -> { id }
+final class VOutlineViewFactory: NativeComponentFactory {
+
+    // MARK: - Associated object keys
+
+    private static var dataSourceKey: UInt8 = 0
+    private static var selectHandlerKey: UInt8 = 0
+    private static var expandHandlerKey: UInt8 = 0
+    private static var collapseHandlerKey: UInt8 = 0
+    private static var outlineViewKey: UInt8 = 0
+
+    // MARK: - NativeComponentFactory
+
+    func createView() -> NSView {
+        let scrollView = NSScrollView()
+        scrollView.wantsLayer = true
+        scrollView.hasVerticalScroller = true
+        scrollView.hasHorizontalScroller = false
+        scrollView.autohidesScrollers = true
+        scrollView.drawsBackground = false
+
+        let outlineView = NSOutlineView()
+        outlineView.headerView = nil
+        outlineView.usesAlternatingRowBackgroundColors = false
+        outlineView.allowsMultipleSelection = false
+        outlineView.selectionHighlightStyle = .regular
+
+        let column = NSTableColumn(identifier: NSUserInterfaceItemIdentifier("label"))
+        column.title = ""
+        column.resizingMask = .autoresizingMask
+        outlineView.addTableColumn(column)
+        outlineView.outlineTableColumn = column
+
+        scrollView.documentView = outlineView
+
+        // Create and attach data source/delegate
+        let handler = OutlineHandler(outlineView: outlineView, scrollView: scrollView)
+        outlineView.dataSource = handler
+        outlineView.delegate = handler
+
+        objc_setAssociatedObject(
+            scrollView, &VOutlineViewFactory.dataSourceKey,
+            handler, .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+        )
+        objc_setAssociatedObject(
+            scrollView, &VOutlineViewFactory.outlineViewKey,
+            outlineView, .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+        )
+
+        scrollView.ensureLayoutNode()
+        return scrollView
+    }
+
+    func updateProp(view: NSView, key: String, value: Any?) {
+        let outlineView = objc_getAssociatedObject(
+            view, &VOutlineViewFactory.outlineViewKey
+        ) as? NSOutlineView
+
+        let handler = objc_getAssociatedObject(
+            view, &VOutlineViewFactory.dataSourceKey
+        ) as? OutlineHandler
+
+        switch key {
+        case "data":
+            guard let dataArray = value as? [[String: Any]] else { return }
+            let nodes = OutlineNode.parse(dataArray)
+            handler?.rootNodes = nodes
+            outlineView?.reloadData()
+
+            // If expandAll was previously set, re-expand
+            if handler?.shouldExpandAll == true {
+                outlineView?.expandItem(nil, expandChildren: true)
+            }
+
+        case "expandAll":
+            let expand = (value as? Bool) ?? false
+            handler?.shouldExpandAll = expand
+            if expand {
+                outlineView?.expandItem(nil, expandChildren: true)
+            } else {
+                outlineView?.collapseItem(nil, collapseChildren: true)
+            }
+
+        case "selectionMode":
+            guard let outlineView = outlineView else { return }
+            if let mode = value as? String {
+                switch mode {
+                case "multiple":
+                    outlineView.allowsMultipleSelection = true
+                    outlineView.allowsEmptySelection = true
+                case "none":
+                    outlineView.allowsMultipleSelection = false
+                    outlineView.allowsEmptySelection = true
+                    outlineView.selectionHighlightStyle = .none
+                default: // "single"
+                    outlineView.allowsMultipleSelection = false
+                    outlineView.allowsEmptySelection = true
+                    outlineView.selectionHighlightStyle = .regular
+                }
+            }
+
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void) {
+        let outlineHandler = objc_getAssociatedObject(
+            view, &VOutlineViewFactory.dataSourceKey
+        ) as? OutlineHandler
+
+        switch event {
+        case "select":
+            outlineHandler?.onSelect = handler
+
+        case "expand":
+            outlineHandler?.onExpand = handler
+
+        case "collapse":
+            outlineHandler?.onCollapse = handler
+
+        default:
+            break
+        }
+    }
+
+    func removeEventListener(view: NSView, event: String) {
+        let outlineHandler = objc_getAssociatedObject(
+            view, &VOutlineViewFactory.dataSourceKey
+        ) as? OutlineHandler
+
+        switch event {
+        case "select":
+            outlineHandler?.onSelect = nil
+
+        case "expand":
+            outlineHandler?.onExpand = nil
+
+        case "collapse":
+            outlineHandler?.onCollapse = nil
+
+        default:
+            break
+        }
+    }
+}
+
+// MARK: - OutlineNode
+
+private final class OutlineNode {
+    let id: String
+    let label: String
+    var children: [OutlineNode]
+
+    init(id: String, label: String, children: [OutlineNode] = []) {
+        self.id = id
+        self.label = label
+        self.children = children
+    }
+
+    static func parse(_ array: [[String: Any]]) -> [OutlineNode] {
+        return array.map { dict in
+            let id = (dict["id"] as? String) ?? UUID().uuidString
+            let label = (dict["label"] as? String) ?? ""
+            let childDicts = dict["children"] as? [[String: Any]] ?? []
+            let children = parse(childDicts)
+            return OutlineNode(id: id, label: label, children: children)
+        }
+    }
+}
+
+// MARK: - OutlineHandler
+
+private final class OutlineHandler: NSObject,
+    NSOutlineViewDataSource, NSOutlineViewDelegate
+{
+    var rootNodes: [OutlineNode] = []
+    var shouldExpandAll: Bool = false
+
+    var onSelect: ((Any?) -> Void)?
+    var onExpand: ((Any?) -> Void)?
+    var onCollapse: ((Any?) -> Void)?
+
+    private weak var outlineView: NSOutlineView?
+    private weak var scrollView: NSScrollView?
+
+    init(outlineView: NSOutlineView, scrollView: NSScrollView) {
+        self.outlineView = outlineView
+        self.scrollView = scrollView
+        super.init()
+    }
+
+    // MARK: - NSOutlineViewDataSource
+
+    func outlineView(_ outlineView: NSOutlineView, numberOfChildrenOfItem item: Any?) -> Int {
+        if let node = item as? OutlineNode {
+            return node.children.count
+        }
+        return rootNodes.count
+    }
+
+    func outlineView(_ outlineView: NSOutlineView, child index: Int, ofItem item: Any?) -> Any {
+        if let node = item as? OutlineNode {
+            return node.children[index]
+        }
+        return rootNodes[index]
+    }
+
+    func outlineView(_ outlineView: NSOutlineView, isItemExpandable item: Any) -> Bool {
+        if let node = item as? OutlineNode {
+            return !node.children.isEmpty
+        }
+        return false
+    }
+
+    // MARK: - NSOutlineViewDelegate
+
+    func outlineView(_ outlineView: NSOutlineView, viewFor tableColumn: NSTableColumn?, item: Any) -> NSView? {
+        guard let node = item as? OutlineNode else { return nil }
+
+        let cellId = NSUserInterfaceItemIdentifier("OutlineCell")
+        let cellView: NSTableCellView
+
+        if let reused = outlineView.makeView(withIdentifier: cellId, owner: nil) as? NSTableCellView {
+            cellView = reused
+        } else {
+            cellView = NSTableCellView()
+            cellView.identifier = cellId
+
+            let textField = NSTextField(labelWithString: "")
+            textField.translatesAutoresizingMaskIntoConstraints = false
+            cellView.addSubview(textField)
+            cellView.textField = textField
+
+            NSLayoutConstraint.activate([
+                textField.leadingAnchor.constraint(equalTo: cellView.leadingAnchor, constant: 4),
+                textField.trailingAnchor.constraint(equalTo: cellView.trailingAnchor, constant: -4),
+                textField.centerYAnchor.constraint(equalTo: cellView.centerYAnchor),
+            ])
+        }
+
+        cellView.textField?.stringValue = node.label
+        return cellView
+    }
+
+    func outlineViewSelectionDidChange(_ notification: Notification) {
+        guard let outlineView = outlineView else { return }
+        let row = outlineView.selectedRow
+        guard row >= 0, let node = outlineView.item(atRow: row) as? OutlineNode else { return }
+        onSelect?(["id": node.id, "label": node.label])
+    }
+
+    func outlineViewItemDidExpand(_ notification: Notification) {
+        guard let node = notification.userInfo?["NSObject"] as? OutlineNode else { return }
+        onExpand?(["id": node.id])
+    }
+
+    func outlineViewItemDidCollapse(_ notification: Notification) {
+        guard let node = notification.userInfo?["NSObject"] as? OutlineNode else { return }
+        onCollapse?(["id": node.id])
+    }
+}

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

@@ -0,0 +1,134 @@
+import AppKit
+import ObjectiveC
+
+/// Factory for VPicker — a popup button for selecting from a list of items.
+/// Maps to NSPopUpButton.
+final class VPickerFactory: NativeComponentFactory {
+
+    private static var changeHandlerKey: UInt8 = 0
+    nonisolated(unsafe) static var itemsKey: UInt8 = 0
+
+    // MARK: - NativeComponentFactory
+
+    func createView() -> NSView {
+        let popup = NSPopUpButton()
+        popup.pullsDown = false
+        popup.wantsLayer = true
+        popup.ensureLayoutNode()
+        return popup
+    }
+
+    func updateProp(view: NSView, key: String, value: Any?) {
+        guard let popup = view as? NSPopUpButton else {
+            StyleEngine.apply(key: key, value: value, to: view)
+            return
+        }
+
+        switch key {
+        case "items":
+            popup.removeAllItems()
+            var storedItems: [[String: Any]] = []
+
+            if let strings = value as? [String] {
+                popup.addItems(withTitles: strings)
+                storedItems = strings.map { ["label": $0, "value": $0] }
+            } else if let items = value as? [[String: Any]] {
+                for item in items {
+                    let label = item["label"] as? String ?? item["value"] as? String ?? ""
+                    popup.addItem(withTitle: label)
+                    storedItems.append(item)
+                }
+            }
+            objc_setAssociatedObject(popup, &VPickerFactory.itemsKey, storedItems, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+
+        case "selectedIndex":
+            if let idx = value as? Int {
+                if idx >= 0 && idx < popup.numberOfItems {
+                    popup.selectItem(at: idx)
+                }
+            } else if let idx = value as? Double {
+                let i = Int(idx)
+                if i >= 0 && i < popup.numberOfItems {
+                    popup.selectItem(at: i)
+                }
+            }
+
+        case "selectedValue":
+            if let val = value as? String,
+               let items = objc_getAssociatedObject(popup, &VPickerFactory.itemsKey) as? [[String: Any]] {
+                if let idx = items.firstIndex(where: { ($0["value"] as? String) == val }) {
+                    popup.selectItem(at: idx)
+                }
+            }
+
+        case "enabled":
+            if let enabled = value as? Bool {
+                popup.isEnabled = enabled
+            } else {
+                popup.isEnabled = true
+            }
+
+        case "disabled":
+            if let disabled = value as? Bool {
+                popup.isEnabled = !disabled
+            } else if let disabled = value as? Int {
+                popup.isEnabled = disabled == 0
+            } else {
+                popup.isEnabled = true
+            }
+
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void) {
+        guard let popup = view as? NSPopUpButton, event == "change" else { return }
+
+        let proxy = PickerActionProxy(popup: popup, handler: handler)
+        popup.target = proxy
+        popup.action = #selector(PickerActionProxy.selectionChanged(_:))
+        objc_setAssociatedObject(
+            popup,
+            &VPickerFactory.changeHandlerKey,
+            proxy,
+            .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+        )
+    }
+
+    func removeEventListener(view: NSView, event: String) {
+        guard let popup = view as? NSPopUpButton, event == "change" else { return }
+
+        popup.target = nil
+        popup.action = nil
+        objc_setAssociatedObject(popup, &VPickerFactory.changeHandlerKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+}
+
+// MARK: - PickerActionProxy
+
+/// Target-action proxy that routes NSPopUpButton selection changes to a closure handler.
+final class PickerActionProxy: NSObject {
+
+    private weak var popup: NSPopUpButton?
+    private let handler: (Any?) -> Void
+
+    init(popup: NSPopUpButton, handler: @escaping (Any?) -> Void) {
+        self.popup = popup
+        self.handler = handler
+    }
+
+    @objc func selectionChanged(_ sender: NSPopUpButton) {
+        let index = sender.indexOfSelectedItem
+        let items = objc_getAssociatedObject(sender, &VPickerFactory.itemsKey) as? [[String: Any]]
+        let item = items?[safe: index]
+        let label = sender.titleOfSelectedItem ?? ""
+        let value = item?["value"] as? String ?? label
+
+        handler([
+            "selectedIndex": index,
+            "value": value,
+            "label": label
+        ])
+    }
+}

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

@@ -0,0 +1,120 @@
+import AppKit
+import ObjectiveC
+
+/// Factory for VPressable — custom mouse-tracking view for pressable interactions.
+/// Maps to a PressableView (ClickableView subclass) with press, longPress,
+/// pressIn (mouseDown), and pressOut (mouseUp) events.
+final class VPressableFactory: NativeComponentFactory {
+
+    // MARK: - Associated object keys
+
+    private static var pressInHandlerKey: UInt8 = 0
+    private static var pressOutHandlerKey: UInt8 = 0
+
+    // MARK: - NativeComponentFactory
+
+    func createView() -> NSView {
+        let pressable = PressableView()
+        pressable.ensureLayoutNode()
+        return pressable
+    }
+
+    func updateProp(view: NSView, key: String, value: Any?) {
+        guard let pressable = view as? PressableView else {
+            StyleEngine.apply(key: key, value: value, to: view)
+            return
+        }
+
+        switch key {
+        case "disabled":
+            if let disabled = value as? Bool {
+                pressable.isDisabled = disabled
+            } else if let disabled = value as? Int {
+                pressable.isDisabled = disabled != 0
+            } else {
+                pressable.isDisabled = false
+            }
+
+        case "activeOpacity":
+            if let opacity = value as? Double {
+                pressable.activeOpacity = CGFloat(opacity)
+            } else if let opacity = value as? Int {
+                pressable.activeOpacity = CGFloat(opacity)
+            } else {
+                pressable.activeOpacity = 0.7
+            }
+
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void) {
+        guard let pressable = view as? PressableView else { return }
+
+        switch event {
+        case "press":
+            pressable.onPress = {
+                handler(nil)
+            }
+
+        case "longPress":
+            pressable.onLongPress = {
+                handler(nil)
+            }
+
+        case "pressIn":
+            pressable.onPressIn = {
+                handler(nil)
+            }
+
+        case "pressOut":
+            pressable.onPressOut = {
+                handler(nil)
+            }
+
+        default:
+            break
+        }
+    }
+
+    func removeEventListener(view: NSView, event: String) {
+        guard let pressable = view as? PressableView else { return }
+
+        switch event {
+        case "press":
+            pressable.onPress = nil
+        case "longPress":
+            pressable.onLongPress = nil
+        case "pressIn":
+            pressable.onPressIn = nil
+        case "pressOut":
+            pressable.onPressOut = nil
+        default:
+            break
+        }
+    }
+}
+
+// MARK: - PressableView
+
+/// ClickableView subclass that adds pressIn (mouseDown) and pressOut (mouseUp) callbacks.
+/// Provides the full set of press interaction events for the VPressable component.
+final class PressableView: ClickableView {
+
+    /// Called immediately when the mouse button goes down.
+    var onPressIn: (() -> Void)?
+
+    /// Called when the mouse button is released (regardless of position).
+    var onPressOut: (() -> Void)?
+
+    override func mouseDown(with event: NSEvent) {
+        onPressIn?()
+        super.mouseDown(with: event)
+    }
+
+    override func mouseUp(with event: NSEvent) {
+        onPressOut?()
+        super.mouseUp(with: event)
+    }
+}

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

@@ -0,0 +1,71 @@
+import AppKit
+
+/// Factory for VProgressBar — a determinate/indeterminate progress indicator.
+/// Maps to NSProgressIndicator with bar style.
+final class VProgressBarFactory: NativeComponentFactory {
+
+    // MARK: - NativeComponentFactory
+
+    func createView() -> NSView {
+        let indicator = NSProgressIndicator()
+        indicator.style = .bar
+        indicator.isIndeterminate = false
+        indicator.minValue = 0
+        indicator.maxValue = 1
+        indicator.doubleValue = 0
+        indicator.wantsLayer = true
+        indicator.ensureLayoutNode()
+        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 "progress", "value":
+            if let val = value as? Double {
+                indicator.isIndeterminate = false
+                indicator.doubleValue = val
+            } else if let val = value as? Int {
+                indicator.isIndeterminate = false
+                indicator.doubleValue = Double(val)
+            }
+
+        case "progressTintColor":
+            if let colorStr = value as? String {
+                indicator.wantsLayer = true
+                indicator.layer?.backgroundColor = NSColor.fromHex(colorStr).cgColor
+            }
+
+        case "trackTintColor":
+            // No direct API; would require custom drawing
+            break
+
+        case "animated", "indeterminate":
+            let indeterminate: Bool
+            if let val = value as? Bool {
+                indeterminate = val
+            } else if let val = value as? Int {
+                indeterminate = val != 0
+            } else {
+                indeterminate = false
+            }
+            indicator.isIndeterminate = indeterminate
+            if indeterminate {
+                indicator.startAnimation(nil)
+            } else {
+                indicator.stopAnimation(nil)
+            }
+
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void) {
+        // No events for progress bar
+    }
+}