@thelacanians/vue-native-cli 0.4.14 → 0.6.0

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

@@ -0,0 +1,215 @@
+import AppKit
+import ObjectiveC
+
+/// Factory for VSplitView — macOS-specific split pane component.
+/// Maps to NSSplitView for side-by-side or top-and-bottom pane arrangements.
+///
+/// Props:
+///   - direction: "horizontal" | "vertical" (horizontal = side-by-side, vertical = top-bottom)
+///   - dividerStyle: "thin" | "thick" | "paneSplitter"
+///   - dividerColor: hex color string
+///   - dividerPosition: CGFloat (position of the first divider in points)
+///
+/// Events:
+///   - resize -> { positions: [CGFloat] }
+final class VSplitViewFactory: NativeComponentFactory {
+
+    // MARK: - Associated object keys
+
+    private static var delegateKey: UInt8 = 0
+    private static var resizeHandlerKey: UInt8 = 0
+    nonisolated(unsafe) static var dividerColorKey: UInt8 = 0
+
+    // MARK: - NativeComponentFactory
+
+    func createView() -> NSView {
+        let splitView = VNSplitView()
+        splitView.isVertical = true  // side-by-side by default
+        splitView.dividerStyle = .thin
+        splitView.wantsLayer = true
+        splitView.ensureLayoutNode()
+
+        let delegate = SplitViewDelegate(factory: self, view: splitView)
+        splitView.delegate = delegate
+        objc_setAssociatedObject(
+            splitView, &VSplitViewFactory.delegateKey,
+            delegate, .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+        )
+
+        return splitView
+    }
+
+    func updateProp(view: NSView, key: String, value: Any?) {
+        guard let splitView = view as? NSSplitView else {
+            StyleEngine.apply(key: key, value: value, to: view)
+            return
+        }
+
+        switch key {
+        case "direction":
+            if let direction = value as? String {
+                // "horizontal" means side-by-side (isVertical = true in NSSplitView terminology)
+                // "vertical" means top-and-bottom (isVertical = false)
+                splitView.isVertical = (direction == "horizontal")
+            }
+
+        case "dividerStyle":
+            if let style = value as? String {
+                switch style {
+                case "thin":
+                    splitView.dividerStyle = .thin
+                case "thick":
+                    splitView.dividerStyle = .thick
+                case "paneSplitter":
+                    splitView.dividerStyle = .paneSplitter
+                default:
+                    splitView.dividerStyle = .thin
+                }
+            }
+
+        case "dividerColor":
+            if let hex = value as? String {
+                let color = NSColor.fromHex(hex)
+                objc_setAssociatedObject(
+                    view, &VSplitViewFactory.dividerColorKey,
+                    color, .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+                )
+                splitView.needsDisplay = true
+            }
+
+        case "dividerPosition":
+            let position: CGFloat
+            if let p = value as? Double {
+                position = CGFloat(p)
+            } else if let p = value as? Int {
+                position = CGFloat(p)
+            } else {
+                return
+            }
+            if splitView.arrangedSubviews.count >= 2 {
+                splitView.setPosition(position, ofDividerAt: 0)
+            }
+
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void) {
+        switch event {
+        case "resize":
+            objc_setAssociatedObject(
+                view, &VSplitViewFactory.resizeHandlerKey,
+                handler as AnyObject, .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+        default:
+            break
+        }
+    }
+
+    func removeEventListener(view: NSView, event: String) {
+        switch event {
+        case "resize":
+            objc_setAssociatedObject(
+                view, &VSplitViewFactory.resizeHandlerKey,
+                nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+        default:
+            break
+        }
+    }
+
+    // MARK: - Child management
+
+    func insertChild(_ child: NSView, into parent: NSView, before anchor: NSView?) {
+        guard let splitView = parent as? NSSplitView else {
+            if let anchor = anchor, parent.subviews.contains(anchor) {
+                parent.addSubview(child, positioned: .below, relativeTo: anchor)
+            } else {
+                parent.addSubview(child)
+            }
+            child.ensureLayoutNode()
+            return
+        }
+
+        if let anchor = anchor, let idx = splitView.arrangedSubviews.firstIndex(of: anchor) {
+            splitView.insertArrangedSubview(child, at: idx)
+        } else {
+            splitView.addArrangedSubview(child)
+        }
+        child.ensureLayoutNode()
+    }
+
+    func removeChild(_ child: NSView, from parent: NSView) {
+        guard let splitView = parent as? NSSplitView else {
+            child.removeFromSuperview()
+            return
+        }
+        splitView.removeArrangedSubview(child)
+        child.removeFromSuperview()
+    }
+
+    // MARK: - Internal resize notification
+
+    fileprivate func notifyResize(view: NSSplitView) {
+        guard let handler = objc_getAssociatedObject(
+            view, &VSplitViewFactory.resizeHandlerKey
+        ) as? (Any?) -> Void else { return }
+
+        var positions: [CGFloat] = []
+        let count = max(0, view.arrangedSubviews.count - 1)
+        for i in 0..<count {
+            if view.isVertical {
+                var pos: CGFloat = 0
+                for j in 0...i {
+                    pos += view.arrangedSubviews[j].frame.width
+                    if j < i { pos += view.dividerThickness }
+                }
+                positions.append(pos)
+            } else {
+                var pos: CGFloat = 0
+                for j in 0...i {
+                    pos += view.arrangedSubviews[j].frame.height
+                    if j < i { pos += view.dividerThickness }
+                }
+                positions.append(pos)
+            }
+        }
+
+        handler(["positions": positions])
+    }
+}
+
+// MARK: - VNSplitView (custom divider color support)
+
+private class VNSplitView: NSSplitView {
+    override var dividerColor: NSColor {
+        if let custom = objc_getAssociatedObject(
+            self, &VSplitViewFactory.dividerColorKey
+        ) as? NSColor {
+            return custom
+        }
+        return super.dividerColor
+    }
+}
+
+// MARK: - SplitViewDelegate
+
+private final class SplitViewDelegate: NSObject, NSSplitViewDelegate {
+
+    private weak var factory: VSplitViewFactory?
+    private weak var view: NSSplitView?
+
+    init(factory: VSplitViewFactory, view: NSSplitView) {
+        self.factory = factory
+        self.view = view
+        super.init()
+    }
+
+    func splitViewDidResizeSubviews(_ notification: Notification) {
+        guard let view = view, let factory = factory else { return }
+        factory.notifyResize(view: view)
+    }
+}

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

@@ -0,0 +1,25 @@
+import AppKit
+
+/// Factory for VStatusBar — no-op on macOS.
+/// macOS does not have an app status bar like iOS. This factory exists
+/// for API compatibility so that cross-platform code using VStatusBar
+/// does not break on macOS.
+final class VStatusBarFactory: 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?) {
+        // No-op — macOS has no app status bar
+    }
+
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void) {
+        // No-op
+    }
+}

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

@@ -0,0 +1,92 @@
+import AppKit
+import ObjectiveC
+
+/// Factory for VSwitch — the boolean toggle switch component.
+/// Maps to NSSwitch (macOS 10.15+) with a LayoutNode.
+/// Supports v-model via the `value` prop and `change` event.
+final class VSwitchFactory: NativeComponentFactory {
+
+    private static var changeHandlerKey: UInt8 = 0
+
+    // MARK: - NativeComponentFactory
+
+    func createView() -> NSView {
+        let sw = NSSwitch()
+        sw.wantsLayer = true
+        sw.ensureLayoutNode()
+        return sw
+    }
+
+    func updateProp(view: NSView, key: String, value: Any?) {
+        guard let sw = view as? NSSwitch else {
+            StyleEngine.apply(key: key, value: value, to: view)
+            return
+        }
+
+        switch key {
+        case "value":
+            let newValue: NSControl.StateValue
+            if let val = value as? Bool {
+                newValue = val ? .on : .off
+            } else if let val = value as? Int {
+                newValue = val != 0 ? .on : .off
+            } else {
+                newValue = .off
+            }
+            if sw.state != newValue {
+                sw.state = newValue
+            }
+
+        case "disabled":
+            if let disabled = value as? Bool {
+                sw.isEnabled = !disabled
+            } else if let disabled = value as? Int {
+                sw.isEnabled = disabled == 0
+            } else {
+                sw.isEnabled = true
+            }
+
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void) {
+        guard let sw = view as? NSSwitch, event == "change" else { return }
+
+        let proxy = SwitchActionProxy(handler: handler)
+        sw.target = proxy
+        sw.action = #selector(SwitchActionProxy.valueChanged(_:))
+        objc_setAssociatedObject(
+            sw,
+            &VSwitchFactory.changeHandlerKey,
+            proxy,
+            .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+        )
+    }
+
+    func removeEventListener(view: NSView, event: String) {
+        guard let sw = view as? NSSwitch, event == "change" else { return }
+
+        sw.target = nil
+        sw.action = nil
+        objc_setAssociatedObject(sw, &VSwitchFactory.changeHandlerKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+}
+
+// MARK: - SwitchActionProxy
+
+/// Target-action proxy that routes NSSwitch value changes to a closure handler.
+/// Stored as an associated object on the NSSwitch.
+final class SwitchActionProxy: NSObject {
+
+    let handler: (Any?) -> Void
+
+    init(handler: @escaping (Any?) -> Void) {
+        self.handler = handler
+    }
+
+    @objc func valueChanged(_ sender: NSSwitch) {
+        handler(sender.state == .on)
+    }
+}

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

@@ -0,0 +1,336 @@
+import AppKit
+import ObjectiveC
+
+/// Factory for VText — the text display component.
+/// Maps to an NSTextField configured as a non-editable label.
+/// After any text or font change, calls layoutNode.markDirty() to trigger remeasurement.
+final class VTextFactory: NativeComponentFactory {
+
+    // MARK: - Font weight mapping
+
+    /// Maps CSS-like font weight strings to NSFont.Weight values.
+    static let fontWeightMap: [String: NSFont.Weight] = [
+        "100": .ultraLight,
+        "200": .thin,
+        "300": .light,
+        "400": .regular,
+        "normal": .regular,
+        "500": .medium,
+        "600": .semibold,
+        "semibold": .semibold,
+        "700": .bold,
+        "bold": .bold,
+        "800": .heavy,
+        "900": .black,
+    ]
+
+    // MARK: - Text alignment mapping
+
+    static let textAlignMap: [String: NSTextAlignment] = [
+        "left": .left,
+        "center": .center,
+        "right": .right,
+        "justify": .justified,
+        "auto": .natural,
+    ]
+
+    // MARK: - Associated object keys for stored state
+
+    private static var fontSizeKey: UInt8 = 0
+    private static var fontWeightKey: UInt8 = 0
+    private static var fontFamilyKey: UInt8 = 0
+    private static var textChildrenKey: UInt8 = 0
+
+    // MARK: - NativeComponentFactory
+
+    func createView() -> NSView {
+        let label = NSTextField(labelWithString: "")
+        label.isEditable = false
+        label.isBordered = false
+        label.drawsBackground = false
+        label.lineBreakMode = .byWordWrapping
+        label.maximumNumberOfLines = 0
+        label.wantsLayer = true
+        // Ensure layout node is attached
+        label.ensureLayoutNode()
+        return label
+    }
+
+    func updateProp(view: NSView, key: String, value: Any?) {
+        guard let label = view as? NSTextField else { return }
+
+        switch key {
+        case "text":
+            storeTextChildren([], on: label)
+            if let text = value as? String {
+                label.stringValue = text
+            } else {
+                label.stringValue = ""
+            }
+            label.layoutNode?.markDirty()
+
+        case "numberOfLines":
+            if let lines = value as? Int {
+                label.maximumNumberOfLines = lines
+            } else if let lines = value as? Double {
+                label.maximumNumberOfLines = Int(lines)
+            } else {
+                label.maximumNumberOfLines = 0
+            }
+            label.layoutNode?.markDirty()
+
+        case "color":
+            if let colorStr = value as? String {
+                label.textColor = NSColor.fromHex(colorStr)
+            } else {
+                label.textColor = .labelColor
+            }
+
+        case "fontSize":
+            let size: CGFloat
+            if let num = value as? Double {
+                size = CGFloat(num)
+            } else if let num = value as? Int {
+                size = CGFloat(num)
+            } else {
+                size = 13.0 // macOS system default
+            }
+            storeFontSize(size, on: label)
+            rebuildFont(for: label)
+            label.layoutNode?.markDirty()
+
+        case "fontWeight":
+            if let str = value as? String {
+                storeFontWeight(str, on: label)
+            } else {
+                storeFontWeight(nil, on: label)
+            }
+            rebuildFont(for: label)
+            label.layoutNode?.markDirty()
+
+        case "fontFamily":
+            if let family = value as? String {
+                storeFontFamily(family, on: label)
+            } else {
+                storeFontFamily(nil, on: label)
+            }
+            rebuildFont(for: label)
+            label.layoutNode?.markDirty()
+
+        case "textAlign":
+            if let alignStr = value as? String {
+                label.alignment = VTextFactory.textAlignMap[alignStr] ?? .natural
+            } else {
+                label.alignment = .natural
+            }
+
+        case "lineBreakMode":
+            if let mode = value as? String {
+                switch mode {
+                case "clip": label.lineBreakMode = .byClipping
+                case "head": label.lineBreakMode = .byTruncatingHead
+                case "middle": label.lineBreakMode = .byTruncatingMiddle
+                case "tail": label.lineBreakMode = .byTruncatingTail
+                case "wordwrap": label.lineBreakMode = .byWordWrapping
+                default: label.lineBreakMode = .byTruncatingTail
+                }
+            }
+
+        case "fontStyle":
+            if let str = value as? String {
+                let currentFont = label.font ?? NSFont.systemFont(ofSize: 13)
+                let currentSize = currentFont.pointSize
+                if str == "italic" {
+                    let descriptor = currentFont.fontDescriptor.withSymbolicTraits(.italic)
+                    label.font = NSFont(descriptor: descriptor, size: currentSize)
+                } else {
+                    var traits = currentFont.fontDescriptor.symbolicTraits
+                    traits.remove(.italic)
+                    let descriptor = currentFont.fontDescriptor.withSymbolicTraits(traits)
+                    label.font = NSFont(descriptor: descriptor, size: currentSize)
+                }
+            }
+            label.layoutNode?.markDirty()
+
+        case "lineHeight":
+            if let num = value as? Double {
+                let paragraphStyle = NSMutableParagraphStyle()
+                paragraphStyle.minimumLineHeight = CGFloat(num)
+                paragraphStyle.maximumLineHeight = CGFloat(num)
+                paragraphStyle.alignment = label.alignment
+                let text = label.stringValue
+                let font = label.font ?? NSFont.systemFont(ofSize: 13)
+                let attrs: [NSAttributedString.Key: Any] = [
+                    .paragraphStyle: paragraphStyle,
+                    .font: font
+                ]
+                label.attributedStringValue = NSAttributedString(string: text, attributes: attrs)
+                label.layoutNode?.markDirty()
+            }
+
+        case "letterSpacing":
+            if let num = value as? Double {
+                let text = label.stringValue
+                let font = label.font ?? NSFont.systemFont(ofSize: 13)
+                let attrs: [NSAttributedString.Key: Any] = [
+                    .kern: CGFloat(num),
+                    .font: font
+                ]
+                label.attributedStringValue = NSAttributedString(string: text, attributes: attrs)
+                label.layoutNode?.markDirty()
+            }
+
+        case "textDecorationLine":
+            if let str = value as? String {
+                let text = label.stringValue
+                let font = label.font ?? NSFont.systemFont(ofSize: 13)
+                var attrs: [NSAttributedString.Key: Any] = [.font: font]
+                switch str {
+                case "underline":
+                    attrs[.underlineStyle] = NSUnderlineStyle.single.rawValue
+                case "line-through", "lineThrough":
+                    attrs[.strikethroughStyle] = NSUnderlineStyle.single.rawValue
+                case "underline line-through":
+                    attrs[.underlineStyle] = NSUnderlineStyle.single.rawValue
+                    attrs[.strikethroughStyle] = NSUnderlineStyle.single.rawValue
+                default:
+                    break
+                }
+                label.attributedStringValue = NSAttributedString(string: text, attributes: attrs)
+                label.layoutNode?.markDirty()
+            }
+
+        case "textTransform":
+            if let str = value as? String {
+                let original = label.stringValue
+                switch str {
+                case "uppercase": label.stringValue = original.uppercased()
+                case "lowercase": label.stringValue = original.lowercased()
+                case "capitalize": label.stringValue = original.capitalized
+                default: break
+                }
+                label.layoutNode?.markDirty()
+            }
+
+        default:
+            // Delegate unknown props to StyleEngine for layout/visual styling
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void) {
+        // Click/press support via gesture recognizer.
+        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)
+        }
+    }
+
+    func removeEventListener(view: NSView, event: String) {
+        if event == "press" {
+            GestureStorage.remove(for: view, event: event)
+            view.gestureRecognizers.forEach { recognizer in
+                if recognizer is NSClickGestureRecognizer {
+                    view.removeGestureRecognizer(recognizer)
+                }
+            }
+        }
+    }
+
+    func insertChild(_ child: NSView, into parent: NSView, before anchor: NSView?) {
+        guard let label = parent as? NSTextField else {
+            child.removeFromSuperview()
+            return
+        }
+
+        var children = storedTextChildren(on: label)
+        if let anchor = anchor, let index = children.firstIndex(where: { $0 === anchor }) {
+            children.insert(child, at: index)
+        } else {
+            children.append(child)
+        }
+
+        storeTextChildren(children, on: label)
+        rebuildText(from: children, on: label)
+    }
+
+    func removeChild(_ child: NSView, from parent: NSView) {
+        guard let label = parent as? NSTextField else { return }
+        var children = storedTextChildren(on: label)
+        children.removeAll { $0 === child }
+        storeTextChildren(children, on: label)
+        rebuildText(from: children, on: label)
+    }
+
+    // MARK: - Font rebuilding
+
+    /// Rebuild the NSFont from stored fontSize, fontWeight, and fontFamily.
+    private func rebuildFont(for label: NSTextField) {
+        let size = storedFontSize(on: label) ?? 13.0
+        let weightStr = storedFontWeight(on: label)
+        let family = storedFontFamily(on: label)
+
+        let weight = weightStr.flatMap { VTextFactory.fontWeightMap[$0] } ?? .regular
+
+        if let family = family, !family.isEmpty {
+            // Try to create a font with the specified family
+            if let customFont = NSFont(name: family, size: size) {
+                label.font = customFont
+            } else {
+                // Fallback: try as a font descriptor family
+                let descriptor = NSFontDescriptor()
+                    .withFamily(family)
+                label.font = NSFont(descriptor: descriptor, size: size)
+            }
+        } else {
+            label.font = NSFont.systemFont(ofSize: size, weight: weight)
+        }
+    }
+
+    // MARK: - Font state storage via associated objects
+
+    private func storeFontSize(_ size: CGFloat, on view: NSView) {
+        objc_setAssociatedObject(view, &VTextFactory.fontSizeKey, size, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+
+    private func storedFontSize(on view: NSView) -> CGFloat? {
+        return objc_getAssociatedObject(view, &VTextFactory.fontSizeKey) as? CGFloat
+    }
+
+    private func storeFontWeight(_ weight: String?, on view: NSView) {
+        objc_setAssociatedObject(view, &VTextFactory.fontWeightKey, weight, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+
+    private func storedFontWeight(on view: NSView) -> String? {
+        return objc_getAssociatedObject(view, &VTextFactory.fontWeightKey) as? String
+    }
+
+    private func storeFontFamily(_ family: String?, on view: NSView) {
+        objc_setAssociatedObject(view, &VTextFactory.fontFamilyKey, family, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+
+    private func storedFontFamily(on view: NSView) -> String? {
+        return objc_getAssociatedObject(view, &VTextFactory.fontFamilyKey) as? String
+    }
+
+    private func storeTextChildren(_ children: [NSView], on view: NSView) {
+        objc_setAssociatedObject(view, &VTextFactory.textChildrenKey, children, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+
+    private func storedTextChildren(on view: NSView) -> [NSView] {
+        return objc_getAssociatedObject(view, &VTextFactory.textChildrenKey) as? [NSView] ?? []
+    }
+
+    private func rebuildText(from children: [NSView], on label: NSTextField) {
+        let text = children.compactMap { child -> String? in
+            (child as? NSTextField)?.stringValue
+        }.joined()
+        label.stringValue = text
+        label.layoutNode?.markDirty()
+    }
+}