@thelacanians/vue-native-cli 0.4.15 → 0.6.2

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

@@ -0,0 +1,314 @@
+import AppKit
+import ObjectiveC
+
+/// Factory for VView — the basic container component.
+/// Maps to a FlippedView (NSView subclass) with a LayoutNode.
+/// Supports all style props via StyleEngine and gesture events.
+final class VViewFactory: NativeComponentFactory {
+
+    func createView() -> NSView {
+        let view = FlippedView()
+        // Ensure layout node is attached
+        view.ensureLayoutNode()
+        return view
+    }
+
+    func updateProp(view: NSView, key: String, value: Any?) {
+        // All VView props are style-related — delegate to StyleEngine
+        StyleEngine.apply(key: key, value: value, to: view)
+    }
+
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void) {
+        switch event {
+
+        // MARK: Click / Press
+        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)
+
+        // MARK: Right Click
+        case "rightPress":
+            let wrapper = ClickGestureWrapper(handler: handler)
+            let click = NSClickGestureRecognizer(
+                target: wrapper,
+                action: #selector(ClickGestureWrapper.handleGesture(_:))
+            )
+            click.buttonMask = 0x2  // Right mouse button
+            view.addGestureRecognizer(click)
+            GestureStorage.store(wrapper, for: view, event: event)
+
+        // MARK: Pan
+        case "pan":
+            let panWrapper = PanGestureWrapper(handler: handler)
+            let pan = NSPanGestureRecognizer(
+                target: panWrapper,
+                action: #selector(PanGestureWrapper.handle(_:))
+            )
+            view.addGestureRecognizer(pan)
+            GestureStorage.storeObject(panWrapper, for: view, event: event)
+
+        // MARK: Magnify (macOS equivalent of pinch)
+        case "pinch", "magnify":
+            let magWrapper = MagnificationGestureWrapper(handler: handler)
+            let mag = NSMagnificationGestureRecognizer(
+                target: magWrapper,
+                action: #selector(MagnificationGestureWrapper.handle(_:))
+            )
+            view.addGestureRecognizer(mag)
+            GestureStorage.storeObject(magWrapper, for: view, event: event)
+
+        // MARK: Rotation
+        case "rotate":
+            let rotationWrapper = RotationGestureWrapper(handler: handler)
+            let rotation = NSRotationGestureRecognizer(
+                target: rotationWrapper,
+                action: #selector(RotationGestureWrapper.handle(_:))
+            )
+            view.addGestureRecognizer(rotation)
+            GestureStorage.storeObject(rotationWrapper, for: view, event: event)
+
+        // MARK: Double Click / Double Tap
+        case "doubleTap":
+            let wrapper = DoubleClickWrapper(handler: handler)
+            let click = NSClickGestureRecognizer(
+                target: wrapper,
+                action: #selector(DoubleClickWrapper.handleGesture(_:))
+            )
+            click.numberOfClicksRequired = 2
+            view.addGestureRecognizer(click)
+            GestureStorage.storeObject(wrapper, for: view, event: event)
+
+        // MARK: Hover
+        case "hover":
+            let hoverWrapper = HoverWrapper(handler: handler)
+            GestureStorage.storeObject(hoverWrapper, for: view, event: event)
+            attachHoverHandler(to: view, wrapper: hoverWrapper)
+
+        // MARK: Force Touch / Pressure
+        case "forceTouch":
+            let pressureWrapper = PressureWrapper(handler: handler)
+            GestureStorage.storeObject(pressureWrapper, for: view, event: event)
+            attachPressureHandler(to: view, wrapper: pressureWrapper)
+
+        default:
+            break
+        }
+    }
+
+    func removeEventListener(view: NSView, event: String) {
+        GestureStorage.remove(for: view, event: event)
+        // Remove matching gesture recognizers
+        view.gestureRecognizers.forEach { recognizer in
+            switch event {
+            case "press" where recognizer is NSClickGestureRecognizer:
+                let click = recognizer as! NSClickGestureRecognizer
+                if click.buttonMask == 0x1 {
+                    view.removeGestureRecognizer(recognizer)
+                }
+            case "rightPress" where recognizer is NSClickGestureRecognizer:
+                let click = recognizer as! NSClickGestureRecognizer
+                if click.buttonMask == 0x2 {
+                    view.removeGestureRecognizer(recognizer)
+                }
+            case "pan" where recognizer is NSPanGestureRecognizer:
+                view.removeGestureRecognizer(recognizer)
+            case "pinch", "magnify":
+                if recognizer is NSMagnificationGestureRecognizer {
+                    view.removeGestureRecognizer(recognizer)
+                }
+            case "rotate":
+                if recognizer is NSRotationGestureRecognizer {
+                    view.removeGestureRecognizer(recognizer)
+                }
+            case "doubleTap" where recognizer is NSClickGestureRecognizer:
+                let click = recognizer as! NSClickGestureRecognizer
+                if click.numberOfClicksRequired == 2 {
+                    view.removeGestureRecognizer(recognizer)
+                }
+            default:
+                break
+            }
+        }
+    }
+
+    // MARK: - Hover Helper
+
+    private func attachHoverHandler(to view: NSView, wrapper: HoverWrapper) {
+        let trackingView = HoverTrackingView(wrapper: wrapper)
+        objc_setAssociatedObject(view, &hoverTrackingKey, trackingView, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+        trackingView.attach(to: view)
+    }
+
+    // MARK: - Pressure Helper
+
+    private func attachPressureHandler(to view: NSView, wrapper: PressureWrapper) {
+        let pressureView = PressureTrackingView(wrapper: wrapper)
+        objc_setAssociatedObject(view, &pressureTrackingKey, pressureView, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+        pressureView.attach(to: view)
+    }
+}
+
+// MARK: - HoverTrackingView
+
+/// Custom NSView that handles hover events via tracking area
+private class HoverTrackingView: NSView {
+    private let wrapper: HoverWrapper
+    private weak var targetView: NSView?
+    private var trackingArea: NSTrackingArea?
+
+    init(wrapper: HoverWrapper) {
+        self.wrapper = wrapper
+        super.init(frame: .zero)
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    func attach(to view: NSView) {
+        targetView = view
+        updateTrackingAreas()
+    }
+
+    override func updateTrackingAreas() {
+        super.updateTrackingAreas()
+
+        if let existing = trackingArea {
+            removeTrackingArea(existing)
+        }
+
+        if let target = targetView {
+            let area = NSTrackingArea(
+                rect: target.bounds,
+                options: [.mouseEnteredAndExited, .mouseMoved, .activeAlways, .inVisibleRect],
+                owner: self,
+                userInfo: nil
+            )
+            addTrackingArea(area)
+            trackingArea = area
+        }
+    }
+
+    override func mouseEntered(with event: NSEvent) {
+        guard let target = targetView else { return }
+        let location = convert(event.locationInWindow, from: nil)
+        wrapper.handleHover(location: location, isEntering: true)
+    }
+
+    override func mouseExited(with event: NSEvent) {
+        guard let target = targetView else { return }
+        let location = convert(event.locationInWindow, from: nil)
+        wrapper.handleHover(location: location, isEntering: false)
+    }
+
+    override func mouseMoved(with event: NSEvent) {
+        guard let target = targetView else { return }
+        let location = convert(event.locationInWindow, from: nil)
+        wrapper.handleHover(location: location, isEntering: true)
+    }
+}
+
+// MARK: - PressureTrackingView
+
+/// Custom NSView that handles Force Touch / pressure events
+private class PressureTrackingView: NSView {
+    private let wrapper: PressureWrapper
+    private weak var targetView: NSView?
+
+    init(wrapper: PressureWrapper) {
+        self.wrapper = wrapper
+        super.init(frame: .zero)
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    func attach(to view: NSView) {
+        targetView = view
+    }
+
+    override func touchesBegan(with event: NSEvent) {
+        super.touchesBegan(with: event)
+        handlePressure(event: event)
+    }
+
+    override func touchesMoved(with event: NSEvent) {
+        super.touchesMoved(with: event)
+        handlePressure(event: event)
+    }
+
+    override func touchesEnded(with event: NSEvent) {
+        super.touchesEnded(with: event)
+        handlePressure(event: event)
+    }
+
+    private func handlePressure(event: NSEvent) {
+        guard let target = targetView else { return }
+
+        // Get pressure information (macOS 10.10.3+)
+        let pressure = CGFloat(event.pressure)
+        let location = event.locationInWindow
+        let locationInView = target.convert(location, from: nil)
+
+        // Pressure stages: 0 = no touch, 1-2 = light touch, 3+ = force touch
+        let stage: Int
+        if event.stage == 0 && pressure == 0 {
+            stage = 0
+        } else if event.stage == 1 {
+            stage = 1
+        } else if event.stage == 2 {
+            stage = 2
+        } else {
+            stage = Int(event.stage)
+        }
+
+        wrapper.handlePressure(pressure: pressure, location: locationInView, stage: stage)
+    }
+}
+
+private var hoverTrackingKey: UInt8 = 0
+private var pressureTrackingKey: UInt8 = 0
+
+// MARK: - GestureStorage
+
+/// Stores gesture wrapper references as associated objects on views to prevent deallocation.
+/// Uses a dictionary keyed by event name to support multiple gesture types per view.
+enum GestureStorage {
+    private static var storageKey: UInt8 = 0
+
+    // MARK: Legacy — typed store for ClickGestureWrapper
+    static func store(_ wrapper: ClickGestureWrapper, for view: NSView, event: String) {
+        storeObject(wrapper, for: view, event: event)
+    }
+
+    // MARK: Generic store for any NSObject-derived wrapper
+    static func storeObject(_ wrapper: NSObject, for view: NSView, event: String) {
+        var storage = getStorage(for: view)
+        storage[event] = wrapper
+        setStorage(storage, for: view)
+    }
+
+    static func remove(for view: NSView, event: String) {
+        var storage = getStorage(for: view)
+        storage.removeValue(forKey: event)
+        setStorage(storage, for: view)
+    }
+
+    static func get(for view: NSView, event: String) -> ClickGestureWrapper? {
+        return getStorage(for: view)[event] as? ClickGestureWrapper
+    }
+
+    private static func getStorage(for view: NSView) -> [String: NSObject] {
+        return objc_getAssociatedObject(view, &storageKey) as? [String: NSObject] ?? [:]
+    }
+
+    private static func setStorage(_ storage: [String: NSObject], for view: NSView) {
+        objc_setAssociatedObject(view, &storageKey, storage, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+}

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

@@ -0,0 +1,162 @@
+import AppKit
+import WebKit
+import ObjectiveC
+
+/// Factory for VWebView — wraps WKWebView for macOS.
+/// Supports loading URLs and inline HTML, plus load/error/loadStart events.
+final class VWebViewFactory: NativeComponentFactory {
+
+    // nonisolated(unsafe) for keys accessed from WKNavigationDelegate callbacks
+    nonisolated(unsafe) fileprivate static var onLoadKey: UInt8 = 0
+    nonisolated(unsafe) fileprivate static var onErrorKey: UInt8 = 1
+    nonisolated(unsafe) fileprivate static var onLoadStartKey: UInt8 = 2
+    fileprivate static var delegateKey: UInt8 = 3
+
+    // MARK: - NativeComponentFactory
+
+    func createView() -> NSView {
+        let config = WKWebViewConfiguration()
+        let webView = WKWebView(frame: .zero, configuration: config)
+        webView.wantsLayer = true
+        webView.ensureLayoutNode()
+        return webView
+    }
+
+    func updateProp(view: NSView, key: String, value: Any?) {
+        guard let webView = view as? WKWebView else {
+            StyleEngine.apply(key: key, value: value, to: view)
+            return
+        }
+
+        switch key {
+        case "source", "uri":
+            if let dict = value as? [String: Any] {
+                if let uri = dict["uri"] as? String, let url = URL(string: uri) {
+                    webView.load(URLRequest(url: url))
+                } else if let html = dict["html"] as? String {
+                    webView.loadHTMLString(html, baseURL: nil)
+                }
+            } else if let urlString = value as? String, let url = URL(string: urlString) {
+                webView.load(URLRequest(url: url))
+            }
+
+        case "html":
+            if let html = value as? String {
+                webView.loadHTMLString(html, baseURL: nil)
+            }
+
+        case "javaScriptEnabled":
+            // WKWebView has JS enabled by default; disabling requires WKPreferences on the
+            // configuration object, which cannot be changed after init. Silently ignore.
+            break
+
+        case "scrollEnabled":
+            // On macOS, WKWebView uses an enclosing scroll view
+            if let enabled = value as? Bool {
+                webView.enclosingScrollView?.hasVerticalScroller = enabled
+                webView.enclosingScrollView?.hasHorizontalScroller = enabled
+            }
+
+        case "userAgent":
+            if let ua = value as? String {
+                webView.customUserAgent = ua
+            }
+
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void) {
+        guard let webView = view as? WKWebView else { return }
+
+        switch event {
+        case "load":
+            objc_setAssociatedObject(
+                view, &VWebViewFactory.onLoadKey,
+                handler as AnyObject,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+            ensureDelegate(for: webView)
+
+        case "error":
+            objc_setAssociatedObject(
+                view, &VWebViewFactory.onErrorKey,
+                handler as AnyObject,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+            ensureDelegate(for: webView)
+
+        case "loadStart":
+            objc_setAssociatedObject(
+                view, &VWebViewFactory.onLoadStartKey,
+                handler as AnyObject,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+            ensureDelegate(for: webView)
+
+        default:
+            break
+        }
+    }
+
+    func removeEventListener(view: NSView, event: String) {
+        switch event {
+        case "load":
+            objc_setAssociatedObject(view, &VWebViewFactory.onLoadKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+        case "error":
+            objc_setAssociatedObject(view, &VWebViewFactory.onErrorKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+        case "loadStart":
+            objc_setAssociatedObject(view, &VWebViewFactory.onLoadStartKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+        default:
+            break
+        }
+    }
+
+    // MARK: - Helpers
+
+    private func ensureDelegate(for webView: WKWebView) {
+        guard !(webView.navigationDelegate is MacWebViewDelegate) else { return }
+        let delegate = MacWebViewDelegate(view: webView)
+        objc_setAssociatedObject(
+            webView, &VWebViewFactory.delegateKey,
+            delegate,
+            .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+        )
+        webView.navigationDelegate = delegate
+    }
+}
+
+// MARK: - MacWebViewDelegate
+
+private final class MacWebViewDelegate: NSObject, WKNavigationDelegate {
+    private weak var view: NSView?
+
+    init(view: NSView) { self.view = view }
+
+    func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
+        guard let view = view else { return }
+        let handler = objc_getAssociatedObject(view, &VWebViewFactory.onLoadKey) as? ((Any?) -> Void)
+        handler?(["url": webView.url?.absoluteString ?? ""])
+    }
+
+    func webView(_ webView: WKWebView, didStartProvisionalNavigation navigation: WKNavigation!) {
+        guard let view = view else { return }
+        let handler = objc_getAssociatedObject(view, &VWebViewFactory.onLoadStartKey) as? ((Any?) -> Void)
+        handler?(["url": webView.url?.absoluteString ?? ""])
+    }
+
+    func webView(_ webView: WKWebView, didFail navigation: WKNavigation!, withError error: Error) {
+        guard let view = view else { return }
+        let handler = objc_getAssociatedObject(view, &VWebViewFactory.onErrorKey) as? ((Any?) -> Void)
+        handler?(["message": error.localizedDescription])
+    }
+
+    func webView(_ webView: WKWebView,
+                 didFailProvisionalNavigation navigation: WKNavigation!,
+                 withError error: Error) {
+        guard let view = view else { return }
+        let handler = objc_getAssociatedObject(view, &VWebViewFactory.onErrorKey) as? ((Any?) -> Void)
+        handler?(["message": error.localizedDescription])
+    }
+}

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

@@ -0,0 +1,54 @@
+import AppKit
+
+/// Protocol that all native component factories must implement.
+/// Each factory knows how to create an NSView, update its properties,
+/// and wire up event listeners for a specific component type.
+@MainActor
+protocol NativeComponentFactory {
+
+    /// Create a new NSView instance for this component type.
+    /// The view should be configured with sensible defaults and a LayoutNode.
+    func createView() -> NSView
+
+    /// Update a property on the view. The key is the property name from JS,
+    /// and value is the property value (nil means the prop was removed).
+    func updateProp(view: NSView, key: String, value: Any?)
+
+    /// Add an event listener to the view. The handler closure will dispatch
+    /// the event payload back to the JS thread.
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void)
+
+    /// Remove an event listener from the view for the given event name.
+    /// Default implementation is a no-op.
+    func removeEventListener(view: NSView, event: String)
+
+    /// Insert a child view into the parent. Called by the bridge instead of addSubview.
+    /// Default implementation calls parent.addSubview(child) with optional anchor positioning.
+    func insertChild(_ child: NSView, into parent: NSView, before anchor: NSView?)
+
+    /// Remove a child view from the parent. Called by the bridge instead of removeFromSuperview.
+    /// Default implementation calls child.removeFromSuperview().
+    func removeChild(_ child: NSView, from parent: NSView)
+}
+
+// Default implementation for optional methods
+extension NativeComponentFactory {
+    func removeEventListener(view: NSView, event: String) {
+        // Default no-op. Factories can override to clean up specific listeners.
+    }
+
+    func insertChild(_ child: NSView, into parent: NSView, before anchor: NSView?) {
+        if let anchor = anchor, let idx = parent.subviews.firstIndex(of: anchor) {
+            // NSView uses addSubview(_:positioned:relativeTo:) for ordering.
+            // .below places the child just before the anchor in the subview array.
+            parent.addSubview(child, positioned: .below, relativeTo: anchor)
+        } else {
+            parent.addSubview(child)
+        }
+        child.ensureLayoutNode()
+    }
+
+    func removeChild(_ child: NSView, from parent: NSView) {
+        child.removeFromSuperview()
+    }
+}

package/native/macos/VueNativeMacOS/Sources/VueNativeMacOS/Helpers/ClickableView.swift

@@ -0,0 +1,100 @@
+import AppKit
+
+/// Custom NSView subclass that provides button-like behavior with mouse events.
+/// macOS equivalent of iOS TouchableView.
+/// Supports press and long press events with configurable active opacity.
+class ClickableView: FlippedView {
+
+    // MARK: - Public properties
+
+    /// The opacity to apply when the user is pressing the view.
+    var activeOpacity: CGFloat = 0.7
+
+    /// Called when a click completes within the view bounds.
+    var onPress: (() -> Void)?
+
+    /// Called when a long press gesture is recognized.
+    var onLongPress: (() -> Void)?
+
+    /// Whether mouse interactions are disabled.
+    var isDisabled: Bool = false {
+        didSet {
+            alphaValue = isDisabled ? 0.4 : 1.0
+        }
+    }
+
+    // MARK: - Private properties
+
+    private var isPressed = false
+    private var longPressTimer: Timer?
+
+    // MARK: - Mouse handling
+
+    override func mouseDown(with event: NSEvent) {
+        guard !isDisabled else { return }
+        isPressed = true
+
+        NSAnimationContext.runAnimationGroup { ctx in
+            ctx.duration = 0.1
+            self.animator().alphaValue = activeOpacity
+        }
+
+        // Start long press timer
+        longPressTimer = Timer.scheduledTimer(withTimeInterval: 0.5, repeats: false) { [weak self] _ in
+            self?.onLongPress?()
+        }
+    }
+
+    override func mouseUp(with event: NSEvent) {
+        guard !isDisabled, isPressed else { return }
+        isPressed = false
+
+        longPressTimer?.invalidate()
+        longPressTimer = nil
+
+        NSAnimationContext.runAnimationGroup { ctx in
+            ctx.duration = 0.1
+            self.animator().alphaValue = 1.0
+        }
+
+        // Check if mouse is still inside bounds
+        let location = convert(event.locationInWindow, from: nil)
+        if bounds.contains(location) {
+            onPress?()
+        }
+    }
+
+    override func mouseExited(with event: NSEvent) {
+        guard isPressed else { return }
+        NSAnimationContext.runAnimationGroup { ctx in
+            ctx.duration = 0.1
+            self.animator().alphaValue = 1.0
+        }
+    }
+
+    override func mouseEntered(with event: NSEvent) {
+        guard isPressed else { return }
+        NSAnimationContext.runAnimationGroup { ctx in
+            ctx.duration = 0.1
+            self.animator().alphaValue = activeOpacity
+        }
+    }
+
+    // MARK: - Tracking areas
+
+    override func updateTrackingAreas() {
+        super.updateTrackingAreas()
+        // Remove old tracking areas
+        for area in trackingAreas {
+            removeTrackingArea(area)
+        }
+        // Add new tracking area for mouse enter/exit events
+        let area = NSTrackingArea(
+            rect: bounds,
+            options: [.mouseEnteredAndExited, .activeInActiveApp],
+            owner: self,
+            userInfo: nil
+        )
+        addTrackingArea(area)
+    }
+}

package/native/macos/VueNativeMacOS/Sources/VueNativeMacOS/Helpers/Extensions.swift

@@ -0,0 +1,23 @@
+import AppKit
+
+// MARK: - Safe array subscript
+
+extension Array {
+    subscript(safe index: Int) -> Element? {
+        indices.contains(index) ? self[index] : nil
+    }
+}
+
+// MARK: - Main window helper
+
+extension NSApplication {
+    /// The main window, or the first visible window.
+    static var vn_mainWindow: NSWindow? {
+        NSApp.mainWindow ?? NSApp.windows.first { $0.isVisible }
+    }
+
+    /// Returns the main window's content view controller.
+    static var vn_contentViewController: NSViewController? {
+        vn_mainWindow?.contentViewController
+    }
+}