@thelacanians/vue-native-cli 0.4.15 → 0.6.0

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

@@ -0,0 +1,193 @@
+import AppKit
+import ObjectiveC
+
+/// Factory for VRadio — a radio button group for mutually exclusive selection.
+/// Maps to an NSStackView containing multiple NSButton radio items.
+final class VRadioFactory: NativeComponentFactory {
+
+    private static var changeHandlerKey: UInt8 = 0
+    nonisolated(unsafe) static var optionsKey: UInt8 = 0
+    nonisolated(unsafe) static var selectedValueKey: UInt8 = 0
+
+    // MARK: - NativeComponentFactory
+
+    func createView() -> NSView {
+        let stack = NSStackView()
+        stack.orientation = .vertical
+        stack.alignment = .leading
+        stack.spacing = 4
+        stack.wantsLayer = true
+        stack.ensureLayoutNode()
+        return stack
+    }
+
+    func updateProp(view: NSView, key: String, value: Any?) {
+        guard let stack = view as? NSStackView else {
+            StyleEngine.apply(key: key, value: value, to: view)
+            return
+        }
+
+        switch key {
+        case "options":
+            guard let options = value as? [[String: Any]] else { return }
+            rebuildRadioButtons(in: stack, options: options)
+            objc_setAssociatedObject(stack, &VRadioFactory.optionsKey, options, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+
+        case "selectedValue":
+            if let val = value as? String {
+                objc_setAssociatedObject(stack, &VRadioFactory.selectedValueKey, val, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+                selectValue(val, in: stack)
+            }
+
+        case "disabled":
+            let disabled: Bool
+            if let val = value as? Bool {
+                disabled = val
+            } else if let val = value as? Int {
+                disabled = val != 0
+            } else {
+                disabled = false
+            }
+            for case let button as NSButton in stack.arrangedSubviews {
+                button.isEnabled = !disabled
+            }
+
+        case "tintColor":
+            if let colorStr = value as? String {
+                let color = NSColor.fromHex(colorStr)
+                for case let button as NSButton in stack.arrangedSubviews {
+                    button.contentTintColor = color
+                }
+            }
+
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void) {
+        guard event == "change" else { return }
+
+        let proxy = RadioGroupActionProxy(stack: view as? NSStackView, handler: handler)
+        objc_setAssociatedObject(
+            view,
+            &VRadioFactory.changeHandlerKey,
+            proxy,
+            .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+        )
+
+        // Wire existing buttons to this proxy
+        if let stack = view as? NSStackView {
+            wireButtons(in: stack, to: proxy)
+        }
+    }
+
+    func removeEventListener(view: NSView, event: String) {
+        guard event == "change" else { return }
+
+        if let stack = view as? NSStackView {
+            for case let button as NSButton in stack.arrangedSubviews {
+                button.target = nil
+                button.action = nil
+            }
+        }
+        objc_setAssociatedObject(view, &VRadioFactory.changeHandlerKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+
+    // Override insertChild/removeChild: radio group manages its own children
+    func insertChild(_ child: NSView, into parent: NSView, before anchor: NSView?) {
+        // No-op: radio buttons are internally managed
+    }
+
+    func removeChild(_ child: NSView, from parent: NSView) {
+        // No-op: radio buttons are internally managed
+    }
+
+    // MARK: - Private
+
+    private func rebuildRadioButtons(in stack: NSStackView, options: [[String: Any]]) {
+        // Remove existing buttons
+        for view in stack.arrangedSubviews {
+            stack.removeArrangedSubview(view)
+            view.removeFromSuperview()
+        }
+
+        let selectedValue = objc_getAssociatedObject(stack, &VRadioFactory.selectedValueKey) as? String
+        let proxy = objc_getAssociatedObject(stack, &VRadioFactory.changeHandlerKey) as? RadioGroupActionProxy
+
+        for (index, option) in options.enumerated() {
+            let label = option["label"] as? String ?? option["value"] as? String ?? ""
+            let value = option["value"] as? String ?? label
+
+            let button = NSButton()
+            button.setButtonType(.radio)
+            button.title = label
+            button.tag = index
+            button.wantsLayer = true
+
+            if value == selectedValue {
+                button.state = .on
+            } else {
+                button.state = .off
+            }
+
+            if let proxy = proxy {
+                button.target = proxy
+                button.action = #selector(RadioGroupActionProxy.radioSelected(_:))
+            }
+
+            stack.addArrangedSubview(button)
+        }
+    }
+
+    private func selectValue(_ value: String, in stack: NSStackView) {
+        let options = objc_getAssociatedObject(stack, &VRadioFactory.optionsKey) as? [[String: Any]] ?? []
+        for (index, option) in options.enumerated() {
+            let optionValue = option["value"] as? String ?? option["label"] as? String ?? ""
+            if let button = stack.arrangedSubviews[safe: index] as? NSButton {
+                button.state = optionValue == value ? .on : .off
+            }
+        }
+    }
+
+    private func wireButtons(in stack: NSStackView, to proxy: RadioGroupActionProxy) {
+        for case let button as NSButton in stack.arrangedSubviews {
+            button.target = proxy
+            button.action = #selector(RadioGroupActionProxy.radioSelected(_:))
+        }
+    }
+}
+
+// MARK: - RadioGroupActionProxy
+
+/// Target-action proxy that routes radio button selections to a closure handler.
+final class RadioGroupActionProxy: NSObject {
+
+    private weak var stack: NSStackView?
+    private let handler: (Any?) -> Void
+
+    init(stack: NSStackView?, handler: @escaping (Any?) -> Void) {
+        self.stack = stack
+        self.handler = handler
+    }
+
+    @objc func radioSelected(_ sender: NSButton) {
+        guard let stack = stack else { return }
+
+        // Deselect all other buttons (enforce mutual exclusivity)
+        for case let button as NSButton in stack.arrangedSubviews where button !== sender {
+            button.state = .off
+        }
+        sender.state = .on
+
+        let options = objc_getAssociatedObject(stack, &VRadioFactory.optionsKey) as? [[String: Any]] ?? []
+        let index = sender.tag
+        let option = options[safe: index]
+        let value = option?["value"] as? String ?? sender.title
+
+        // Update stored selected value
+        objc_setAssociatedObject(stack, &VRadioFactory.selectedValueKey, value, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+
+        handler(["value": value])
+    }
+}

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

@@ -0,0 +1,25 @@
+import AppKit
+
+/// Factory for VRefreshControl — stub on macOS.
+/// Pull-to-refresh is a mobile pattern that does not exist on desktop.
+/// This factory exists for API compatibility so that cross-platform code
+/// using VRefreshControl does not break on macOS.
+final class VRefreshControlFactory: 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 — pull-to-refresh doesn't exist on macOS
+    }
+
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void) {
+        // No-op
+    }
+}

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

@@ -0,0 +1,46 @@
+import AppKit
+import ObjectiveC
+
+/// Factory for VSafeArea — pass-through container on macOS.
+/// macOS has no notches or system bars that require safe area insets,
+/// so this component acts as a plain FlippedView container with gesture support.
+final class VSafeAreaFactory: NativeComponentFactory {
+
+    func createView() -> NSView {
+        let view = FlippedView()
+        view.ensureLayoutNode()
+        return view
+    }
+
+    func updateProp(view: NSView, key: String, value: Any?) {
+        // Delegate all props to StyleEngine — acts as a plain container
+        StyleEngine.apply(key: key, value: value, to: view)
+    }
+
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void) {
+        switch event {
+        case "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)
+
+        default:
+            break
+        }
+    }
+
+    func removeEventListener(view: NSView, event: String) {
+        GestureStorage.remove(for: view, event: event)
+        if event == "press" {
+            view.gestureRecognizers.forEach { recognizer in
+                if let click = recognizer as? NSClickGestureRecognizer, click.buttonMask == 0x1 {
+                    view.removeGestureRecognizer(recognizer)
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,190 @@
+import AppKit
+import ObjectiveC
+
+/// Factory for VScrollView — scrollable container component.
+/// Maps to NSScrollView with a FlippedView document view.
+/// NSScrollView hierarchy: NSScrollView → NSClipView → documentView (FlippedView).
+/// Children are added to the document view, not the scroll view itself.
+final class VScrollViewFactory: NativeComponentFactory {
+
+    // MARK: - Associated object keys
+
+    private static var scrollThrottleKey: UInt8 = 0
+    private static var scrollObserverKey: UInt8 = 0
+    private static var scrollHandlerKey: 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
+
+        // Create document view (children go here)
+        let documentView = FlippedView()
+        documentView.ensureLayoutNode()
+        scrollView.documentView = documentView
+
+        // Enable bounds change notifications on the clip view for scroll events
+        scrollView.contentView.postsBoundsChangedNotifications = true
+
+        scrollView.ensureLayoutNode()
+        return scrollView
+    }
+
+    func updateProp(view: NSView, key: String, value: Any?) {
+        guard let scrollView = view as? NSScrollView else {
+            StyleEngine.apply(key: key, value: value, to: view)
+            return
+        }
+
+        switch key {
+        case "horizontal":
+            let horizontal = (value as? Bool) ?? false
+            scrollView.hasHorizontalScroller = horizontal
+            scrollView.hasVerticalScroller = !horizontal
+
+        case "showsVerticalScrollIndicator":
+            let show = (value as? Bool) ?? true
+            if show {
+                scrollView.hasVerticalScroller = true
+            } else {
+                scrollView.hasVerticalScroller = false
+            }
+
+        case "showsHorizontalScrollIndicator":
+            let show = (value as? Bool) ?? false
+            if show {
+                scrollView.hasHorizontalScroller = true
+            } else {
+                scrollView.hasHorizontalScroller = false
+            }
+
+        case "bounces":
+            let bounces = (value as? Bool) ?? true
+            scrollView.verticalScrollElasticity = bounces ? .allowed : .none
+            scrollView.horizontalScrollElasticity = bounces ? .allowed : .none
+
+        case "scrollEnabled":
+            let enabled = (value as? Bool) ?? true
+            // Disabling scroll by removing scrollers and preventing scroll
+            if enabled {
+                scrollView.hasVerticalScroller = true
+                scrollView.verticalScrollElasticity = .allowed
+            } else {
+                scrollView.hasVerticalScroller = false
+                scrollView.hasHorizontalScroller = false
+                scrollView.verticalScrollElasticity = .none
+                scrollView.horizontalScrollElasticity = .none
+            }
+
+        case "contentContainerStyle":
+            // Apply styles to the document view
+            if let styles = value as? [String: Any], let docView = scrollView.documentView {
+                StyleEngine.applyStyles(styles, to: docView)
+            }
+
+        case "pagingEnabled":
+            // NSScrollView doesn't have native paging. Store as internal prop.
+            StyleEngine.setInternalPropDirect("__pagingEnabled", value: value, on: view)
+
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void) {
+        guard let scrollView = view as? NSScrollView else { return }
+
+        switch event {
+        case "scroll":
+            let throttle = EventThrottle(interval: 0.016) { payload in
+                handler(payload)
+            }
+            objc_setAssociatedObject(
+                view, &VScrollViewFactory.scrollThrottleKey,
+                throttle, .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+            let observer = NotificationCenter.default.addObserver(
+                forName: NSView.boundsDidChangeNotification,
+                object: scrollView.contentView,
+                queue: .main
+            ) { [weak scrollView] _ in
+                guard let sv = scrollView else { return }
+                let clipBounds = sv.contentView.bounds
+                let docSize = sv.documentView?.frame.size ?? .zero
+                let visibleSize = sv.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)
+            }
+
+            objc_setAssociatedObject(
+                view, &VScrollViewFactory.scrollObserverKey,
+                observer, .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+        default:
+            break
+        }
+    }
+
+    func removeEventListener(view: NSView, event: String) {
+        switch event {
+        case "scroll":
+            if let observer = objc_getAssociatedObject(view, &VScrollViewFactory.scrollObserverKey) {
+                NotificationCenter.default.removeObserver(observer)
+                objc_setAssociatedObject(
+                    view, &VScrollViewFactory.scrollObserverKey,
+                    nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+                )
+            }
+            objc_setAssociatedObject(
+                view, &VScrollViewFactory.scrollThrottleKey,
+                nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+        default:
+            break
+        }
+    }
+
+    // MARK: - Child management (redirect to document view)
+
+    func insertChild(_ child: NSView, into parent: NSView, before anchor: NSView?) {
+        guard let scrollView = parent as? NSScrollView,
+              let documentView = scrollView.documentView else {
+            // Fallback: add directly
+            if let anchor = anchor, let idx = parent.subviews.firstIndex(of: anchor) {
+                parent.addSubview(child, positioned: .below, relativeTo: anchor)
+            } else {
+                parent.addSubview(child)
+            }
+            child.ensureLayoutNode()
+            return
+        }
+
+        if let anchor = anchor, let idx = documentView.subviews.firstIndex(of: anchor) {
+            documentView.addSubview(child, positioned: .below, relativeTo: anchor)
+        } else {
+            documentView.addSubview(child)
+        }
+        child.ensureLayoutNode()
+    }
+
+    func removeChild(_ child: NSView, from parent: NSView) {
+        // Child is in the document view, just remove from superview
+        child.removeFromSuperview()
+    }
+}