@thelacanians/vue-native-cli 0.4.14 → 0.6.0

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

@@ -0,0 +1,374 @@
+import AppKit
+import ObjectiveC
+
+/// Factory for VSectionList — sectioned list component backed by NSTableView with group rows.
+/// Children marked with `__sectionHeader` are treated as section headers.
+final class VSectionListFactory: NativeComponentFactory {
+
+    // MARK: - Associated object keys
+
+    nonisolated(unsafe) private static var scrollThrottleKey: UInt8 = 0
+    nonisolated(unsafe) private static var scrollObserverKey: UInt8 = 0
+    nonisolated(unsafe) private static var endReachedHandlerKey: UInt8 = 0
+
+    // MARK: - NativeComponentFactory
+
+    func createView() -> NSView {
+        let container = VSectionListContainerView()
+        container.ensureLayoutNode()
+        return container
+    }
+
+    func updateProp(view: NSView, key: String, value: Any?) {
+        guard let container = view as? VSectionListContainerView else {
+            StyleEngine.apply(key: key, value: value, to: view)
+            return
+        }
+
+        switch key {
+        case "estimatedItemHeight":
+            container.estimatedItemHeight = Self.cgFloat(from: value) ?? 44
+
+        case "stickySectionHeaders":
+            let sticky = (value as? Bool) ?? true
+            container.stickySectionHeaders = sticky
+            container.tableView.floatsGroupRows = sticky
+
+        case "showsScrollIndicator":
+            container.scrollView.hasVerticalScroller = (value as? Bool) ?? true
+
+        case "bounces":
+            let elasticity: NSScrollView.Elasticity = ((value as? Bool) ?? true) ? .allowed : .none
+            container.scrollView.verticalScrollElasticity = elasticity
+            container.scrollView.horizontalScrollElasticity = elasticity
+
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void) {
+        guard let container = view as? VSectionListContainerView else { return }
+
+        switch event {
+        case "scroll":
+            let throttle = EventThrottle(interval: 0.016) { payload in
+                handler(payload)
+            }
+            objc_setAssociatedObject(
+                view, &VSectionListFactory.scrollThrottleKey,
+                throttle, .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+            container.scrollView.contentView.postsBoundsChangedNotifications = true
+            let observer = NotificationCenter.default.addObserver(
+                forName: NSView.boundsDidChangeNotification,
+                object: container.scrollView.contentView,
+                queue: .main
+            ) { [weak container] _ in
+                guard let c = container else { return }
+                let clipBounds = c.scrollView.contentView.bounds
+                let docSize = c.scrollView.documentView?.frame.size ?? .zero
+                let visibleSize = c.scrollView.contentView.bounds.size
+
+                let payload: [String: Any] = [
+                    "x": clipBounds.origin.x,
+                    "y": clipBounds.origin.y,
+                    "contentWidth": docSize.width,
+                    "contentHeight": docSize.height,
+                    "layoutWidth": visibleSize.width,
+                    "layoutHeight": visibleSize.height,
+                ]
+                throttle.fire(payload)
+
+                let endThreshold: CGFloat = 100
+                let scrolledToBottom = clipBounds.origin.y + visibleSize.height >= docSize.height - endThreshold
+                if scrolledToBottom, let wrapper = objc_getAssociatedObject(
+                    c, &VSectionListFactory.endReachedHandlerKey
+                ) as? SectionHandlerWrapper {
+                    wrapper.handler(nil)
+                }
+            }
+
+            objc_setAssociatedObject(
+                view, &VSectionListFactory.scrollObserverKey,
+                observer, .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+        case "endReached":
+            let wrapper = SectionHandlerWrapper(handler: handler)
+            objc_setAssociatedObject(
+                view, &VSectionListFactory.endReachedHandlerKey,
+                wrapper, .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+        default:
+            break
+        }
+    }
+
+    func removeEventListener(view: NSView, event: String) {
+        switch event {
+        case "scroll":
+            if let observer = objc_getAssociatedObject(view, &VSectionListFactory.scrollObserverKey) {
+                NotificationCenter.default.removeObserver(observer)
+                objc_setAssociatedObject(
+                    view, &VSectionListFactory.scrollObserverKey,
+                    nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+                )
+            }
+            objc_setAssociatedObject(
+                view, &VSectionListFactory.scrollThrottleKey,
+                nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+        case "endReached":
+            objc_setAssociatedObject(
+                view, &VSectionListFactory.endReachedHandlerKey,
+                nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+        default:
+            break
+        }
+    }
+
+    // MARK: - Child management
+
+    func insertChild(_ child: NSView, into parent: NSView, before anchor: NSView?) {
+        guard let container = parent as? VSectionListContainerView else { return }
+        child.ensureLayoutNode()
+
+        if let anchor = anchor, let idx = container.allChildren.firstIndex(where: { $0 === anchor }) {
+            container.allChildren.insert(child, at: idx)
+        } else {
+            container.allChildren.append(child)
+        }
+        container.rebuildSections()
+        container.tableView.reloadData()
+    }
+
+    func removeChild(_ child: NSView, from parent: NSView) {
+        guard let container = parent as? VSectionListContainerView else {
+            child.removeFromSuperview()
+            return
+        }
+
+        container.allChildren.removeAll { $0 === child }
+        child.removeFromSuperview()
+        container.rebuildSections()
+        container.tableView.reloadData()
+    }
+}
+
+// MARK: - SectionHandlerWrapper
+
+private final class SectionHandlerWrapper: NSObject {
+    let handler: (Any?) -> Void
+
+    init(handler: @escaping (Any?) -> Void) {
+        self.handler = handler
+        super.init()
+    }
+}
+
+// MARK: - SectionData
+
+private struct SectionData {
+    var headerView: NSView?
+    var itemViews: [NSView]
+}
+
+// MARK: - FlatRow
+
+private enum FlatRow {
+    case sectionHeader(sectionIndex: Int)
+    case item(sectionIndex: Int, itemIndex: Int)
+}
+
+// MARK: - VSectionListContainerView
+
+/// Container view hosting NSScrollView + NSTableView with section support.
+final class VSectionListContainerView: FlippedView, NSTableViewDataSource, NSTableViewDelegate {
+
+    // MARK: - Subviews
+
+    let scrollView: NSScrollView
+    let tableView: NSTableView
+
+    // MARK: - State
+
+    var allChildren: [NSView] = []
+    var estimatedItemHeight: CGFloat = 44
+    var stickySectionHeaders = true
+    fileprivate var sections: [SectionData] = []
+    fileprivate var flatRows: [FlatRow] = []
+
+    private static let cellIdentifier = NSUserInterfaceItemIdentifier("VSectionListCell")
+
+    // MARK: - Init
+
+    override init(frame: NSRect) {
+        scrollView = NSScrollView()
+        tableView = NSTableView()
+
+        super.init(frame: frame)
+
+        let column = NSTableColumn(identifier: NSUserInterfaceItemIdentifier("main"))
+        column.isEditable = false
+        tableView.addTableColumn(column)
+        tableView.headerView = nil
+        tableView.style = .plain
+        tableView.selectionHighlightStyle = .none
+        tableView.intercellSpacing = NSSize(width: 0, height: 0)
+        tableView.dataSource = self
+        tableView.delegate = self
+        tableView.floatsGroupRows = true
+
+        scrollView.documentView = tableView
+        scrollView.hasVerticalScroller = true
+        scrollView.autohidesScrollers = true
+        scrollView.drawsBackground = false
+
+        addSubview(scrollView)
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    override func layout() {
+        super.layout()
+        scrollView.frame = bounds
+    }
+
+    func rebuildSections() {
+        sections.removeAll()
+        var currentSection = SectionData(headerView: nil, itemViews: [])
+
+        for child in allChildren {
+            let isSectionHeader = StyleEngine.getInternalProp("__sectionHeader", from: child) as? Bool ?? false
+            if isSectionHeader {
+                if currentSection.headerView != nil || !currentSection.itemViews.isEmpty {
+                    sections.append(currentSection)
+                }
+                currentSection = SectionData(headerView: child, itemViews: [])
+            } else {
+                currentSection.itemViews.append(child)
+            }
+        }
+
+        if currentSection.headerView != nil || !currentSection.itemViews.isEmpty {
+            sections.append(currentSection)
+        }
+
+        rebuildFlatRows()
+    }
+
+    private func rebuildFlatRows() {
+        flatRows.removeAll()
+
+        for (sectionIndex, section) in sections.enumerated() {
+            if section.headerView != nil {
+                flatRows.append(.sectionHeader(sectionIndex: sectionIndex))
+            }
+            for itemIndex in section.itemViews.indices {
+                flatRows.append(.item(sectionIndex: sectionIndex, itemIndex: itemIndex))
+            }
+        }
+    }
+
+    // MARK: - NSTableViewDataSource
+
+    func numberOfRows(in tableView: NSTableView) -> Int {
+        flatRows.count
+    }
+
+    // MARK: - NSTableViewDelegate
+
+    func tableView(_ tableView: NSTableView, isGroupRow row: Int) -> Bool {
+        guard row < flatRows.count else { return false }
+        if case .sectionHeader = flatRows[row] {
+            return true
+        }
+        return false
+    }
+
+    func tableView(_ tableView: NSTableView, viewFor tableColumn: NSTableColumn?, row: Int) -> NSView? {
+        guard row < flatRows.count else { return nil }
+
+        switch flatRows[row] {
+        case .sectionHeader(let sectionIndex):
+            guard sectionIndex < sections.count,
+                  let headerView = sections[sectionIndex].headerView else { return nil }
+            headerView.removeFromSuperview()
+            return headerView
+
+        case .item(let sectionIndex, let itemIndex):
+            guard sectionIndex < sections.count,
+                  itemIndex < sections[sectionIndex].itemViews.count else { return nil }
+
+            let cellView: NSTableCellView
+            if let reused = tableView.makeView(withIdentifier: VSectionListContainerView.cellIdentifier, owner: nil) as? NSTableCellView {
+                reused.subviews.forEach { $0.removeFromSuperview() }
+                cellView = reused
+            } else {
+                cellView = NSTableCellView()
+                cellView.identifier = VSectionListContainerView.cellIdentifier
+            }
+
+            let child = sections[sectionIndex].itemViews[itemIndex]
+            child.removeFromSuperview()
+            cellView.addSubview(child)
+            child.frame = cellView.bounds
+            child.autoresizingMask = [.width, .height]
+            return cellView
+        }
+    }
+
+    func tableView(_ tableView: NSTableView, heightOfRow row: Int) -> CGFloat {
+        guard row < flatRows.count else { return estimatedItemHeight }
+
+        switch flatRows[row] {
+        case .sectionHeader(let sectionIndex):
+            guard sectionIndex < sections.count,
+                  let headerView = sections[sectionIndex].headerView else { return estimatedItemHeight }
+            return resolvedHeight(for: headerView)
+
+        case .item(let sectionIndex, let itemIndex):
+            guard sectionIndex < sections.count,
+                  itemIndex < sections[sectionIndex].itemViews.count else { return estimatedItemHeight }
+            return resolvedHeight(for: sections[sectionIndex].itemViews[itemIndex])
+        }
+    }
+
+    private func resolvedHeight(for view: NSView) -> CGFloat {
+        let explicitHeight = view.frame.size.height
+        if explicitHeight > 1 {
+            return explicitHeight
+        }
+
+        if let node = view.layoutNode {
+            if node.computedFrame.height > 0 {
+                return node.computedFrame.height
+            }
+            if let resolved = node.height.resolve(relativeTo: bounds.height), resolved > 0 {
+                return resolved
+            }
+        }
+
+        return estimatedItemHeight
+    }
+}
+
+private extension VSectionListFactory {
+    static func cgFloat(from value: Any?) -> CGFloat? {
+        if let value = value as? CGFloat { return value }
+        if let value = value as? Double { return CGFloat(value) }
+        if let value = value as? Int { return CGFloat(value) }
+        if let value = value as? String, let parsed = Double(value) {
+            return CGFloat(parsed)
+        }
+        return nil
+    }
+}

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

@@ -0,0 +1,125 @@
+import AppKit
+import ObjectiveC
+
+/// Factory for VSegmentedControl — a segmented control for mutually exclusive choices.
+/// Maps to NSSegmentedControl.
+final class VSegmentedControlFactory: NativeComponentFactory {
+
+    private static var changeHandlerKey: UInt8 = 0
+    nonisolated(unsafe) static var valuesKey: UInt8 = 0
+
+    // MARK: - NativeComponentFactory
+
+    func createView() -> NSView {
+        let control = NSSegmentedControl()
+        control.segmentStyle = .rounded
+        control.trackingMode = .selectOne
+        control.wantsLayer = true
+        control.ensureLayoutNode()
+        return control
+    }
+
+    func updateProp(view: NSView, key: String, value: Any?) {
+        guard let control = view as? NSSegmentedControl else {
+            StyleEngine.apply(key: key, value: value, to: view)
+            return
+        }
+
+        switch key {
+        case "values":
+            if let labels = value as? [String] {
+                control.segmentCount = labels.count
+                for (i, label) in labels.enumerated() {
+                    control.setLabel(label, forSegment: i)
+                    control.setWidth(0, forSegment: i) // Auto-size
+                }
+                objc_setAssociatedObject(control, &VSegmentedControlFactory.valuesKey, labels, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+            }
+
+        case "selectedIndex":
+            if let idx = value as? Int {
+                if idx >= 0 && idx < control.segmentCount {
+                    control.selectedSegment = idx
+                }
+            } else if let idx = value as? Double {
+                let i = Int(idx)
+                if i >= 0 && i < control.segmentCount {
+                    control.selectedSegment = i
+                }
+            }
+
+        case "tintColor":
+            if let colorStr = value as? String {
+                if #available(macOS 10.14, *) {
+                    control.selectedSegmentBezelColor = NSColor.fromHex(colorStr)
+                }
+            }
+
+        case "enabled":
+            if let enabled = value as? Bool {
+                control.isEnabled = enabled
+            } else {
+                control.isEnabled = true
+            }
+
+        case "disabled":
+            if let disabled = value as? Bool {
+                control.isEnabled = !disabled
+            } else if let disabled = value as? Int {
+                control.isEnabled = disabled == 0
+            } else {
+                control.isEnabled = true
+            }
+
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void) {
+        guard let control = view as? NSSegmentedControl, event == "change" else { return }
+
+        let proxy = SegmentedActionProxy(control: control, handler: handler)
+        control.target = proxy
+        control.action = #selector(SegmentedActionProxy.selectionChanged(_:))
+        objc_setAssociatedObject(
+            control,
+            &VSegmentedControlFactory.changeHandlerKey,
+            proxy,
+            .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+        )
+    }
+
+    func removeEventListener(view: NSView, event: String) {
+        guard let control = view as? NSSegmentedControl, event == "change" else { return }
+
+        control.target = nil
+        control.action = nil
+        objc_setAssociatedObject(control, &VSegmentedControlFactory.changeHandlerKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+}
+
+// MARK: - SegmentedActionProxy
+
+/// Target-action proxy that routes NSSegmentedControl selection changes to a closure handler.
+final class SegmentedActionProxy: NSObject {
+
+    private weak var control: NSSegmentedControl?
+    private let handler: (Any?) -> Void
+
+    init(control: NSSegmentedControl, handler: @escaping (Any?) -> Void) {
+        self.control = control
+        self.handler = handler
+    }
+
+    @objc func selectionChanged(_ sender: NSSegmentedControl) {
+        let index = sender.selectedSegment
+        let labels = objc_getAssociatedObject(sender, &VSegmentedControlFactory.valuesKey) as? [String]
+        let label = labels?[safe: index] ?? ""
+
+        handler([
+            "selectedIndex": index,
+            "value": label
+        ])
+    }
+}

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

@@ -0,0 +1,131 @@
+import AppKit
+import ObjectiveC
+
+/// Factory for VSlider — a continuous slider control.
+/// Maps to NSSlider with throttled change events (~60fps).
+final class VSliderFactory: NativeComponentFactory {
+
+    private static var changeHandlerKey: UInt8 = 0
+
+    // MARK: - NativeComponentFactory
+
+    func createView() -> NSView {
+        let slider = NSSlider()
+        slider.isContinuous = true
+        slider.minValue = 0
+        slider.maxValue = 1
+        slider.doubleValue = 0
+        slider.wantsLayer = true
+        slider.ensureLayoutNode()
+        return slider
+    }
+
+    func updateProp(view: NSView, key: String, value: Any?) {
+        guard let slider = view as? NSSlider else {
+            StyleEngine.apply(key: key, value: value, to: view)
+            return
+        }
+
+        switch key {
+        case "value":
+            if let val = value as? Double {
+                if slider.doubleValue != val {
+                    slider.doubleValue = val
+                }
+            } else if let val = value as? Int {
+                slider.doubleValue = Double(val)
+            }
+
+        case "minimumValue", "min":
+            if let val = value as? Double {
+                slider.minValue = val
+            } else if let val = value as? Int {
+                slider.minValue = Double(val)
+            }
+
+        case "maximumValue", "max":
+            if let val = value as? Double {
+                slider.maxValue = val
+            } else if let val = value as? Int {
+                slider.maxValue = Double(val)
+            }
+
+        case "minimumTrackTintColor":
+            if #available(macOS 14.0, *) {
+                if let colorStr = value as? String {
+                    slider.trackFillColor = NSColor.fromHex(colorStr)
+                } else {
+                    slider.trackFillColor = nil
+                }
+            }
+
+        case "maximumTrackTintColor":
+            // No direct NSSlider API for max track color
+            break
+
+        case "disabled":
+            if let disabled = value as? Bool {
+                slider.isEnabled = !disabled
+            } else if let disabled = value as? Int {
+                slider.isEnabled = disabled == 0
+            } else {
+                slider.isEnabled = true
+            }
+
+        case "enabled":
+            if let enabled = value as? Bool {
+                slider.isEnabled = enabled
+            } else if let enabled = value as? Int {
+                slider.isEnabled = enabled != 0
+            } else {
+                slider.isEnabled = true
+            }
+
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void) {
+        guard let slider = view as? NSSlider, event == "change" else { return }
+
+        let throttle = EventThrottle { payload in
+            handler(payload)
+        }
+        let proxy = SliderActionProxy(slider: slider, throttle: throttle)
+        slider.target = proxy
+        slider.action = #selector(SliderActionProxy.valueChanged(_:))
+        objc_setAssociatedObject(
+            slider,
+            &VSliderFactory.changeHandlerKey,
+            proxy,
+            .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+        )
+    }
+
+    func removeEventListener(view: NSView, event: String) {
+        guard let slider = view as? NSSlider, event == "change" else { return }
+
+        slider.target = nil
+        slider.action = nil
+        objc_setAssociatedObject(slider, &VSliderFactory.changeHandlerKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+}
+
+// MARK: - SliderActionProxy
+
+/// Target-action proxy that routes NSSlider value changes through an EventThrottle.
+final class SliderActionProxy: NSObject {
+
+    private weak var slider: NSSlider?
+    private let throttle: EventThrottle
+
+    init(slider: NSSlider, throttle: EventThrottle) {
+        self.slider = slider
+        self.throttle = throttle
+    }
+
+    @objc func valueChanged(_ sender: NSSlider) {
+        throttle.fire(["value": sender.doubleValue])
+    }
+}