@thelacanians/vue-native-cli 0.4.15 → 0.6.0

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

@@ -0,0 +1,270 @@
+import AppKit
+import ObjectiveC
+
+/// Factory for VImage — async image loading component.
+/// Maps to NSImageView with URL-based async loading via URLSession,
+/// NSCache for in-memory caching, and various resize modes.
+final class VImageFactory: NativeComponentFactory {
+
+    // MARK: - Associated object keys
+
+    private static var loadTaskKey: UInt8 = 0
+    private static var loadHandlerKey: UInt8 = 0
+    private static var errorHandlerKey: UInt8 = 0
+
+    // MARK: - Shared image cache
+
+    private static let imageCache = NSCache<NSString, NSImage>()
+
+    // MARK: - NativeComponentFactory
+
+    func createView() -> NSView {
+        let imageView = NSImageView()
+        imageView.imageScaling = .scaleProportionallyUpOrDown
+        imageView.wantsLayer = true
+        imageView.ensureLayoutNode()
+        return imageView
+    }
+
+    func updateProp(view: NSView, key: String, value: Any?) {
+        guard let imageView = view as? NSImageView else {
+            StyleEngine.apply(key: key, value: value, to: view)
+            return
+        }
+
+        switch key {
+        case "source", "src":
+            // Cancel any in-flight load
+            cancelLoad(on: view)
+
+            guard let source = value as? String, !source.isEmpty else {
+                imageView.image = nil
+                return
+            }
+
+            // Try loading as URL
+            if let url = URL(string: source), url.scheme == "https" || url.scheme == "http" {
+                loadImageFromURL(url, into: imageView)
+            } else {
+                // Try loading as local resource name
+                if let image = NSImage(named: source) {
+                    imageView.image = image
+                    fireLoadEvent(for: imageView, image: image)
+                } else if let image = loadFromBundle(source) {
+                    imageView.image = image
+                    fireLoadEvent(for: imageView, image: image)
+                } else {
+                    fireErrorEvent(for: imageView, message: "Image not found: \(source)")
+                }
+            }
+
+        case "resizeMode":
+            guard let mode = value as? String else { return }
+            switch mode {
+            case "cover":
+                imageView.imageScaling = .scaleProportionallyUpOrDown
+                imageView.layer?.contentsGravity = .resizeAspectFill
+                imageView.layer?.masksToBounds = true
+            case "contain":
+                imageView.imageScaling = .scaleProportionallyDown
+                imageView.layer?.contentsGravity = .resizeAspect
+            case "stretch":
+                imageView.imageScaling = .scaleAxesIndependently
+                imageView.layer?.contentsGravity = .resize
+            case "center":
+                imageView.imageScaling = .scaleNone
+                imageView.layer?.contentsGravity = .center
+            default:
+                imageView.imageScaling = .scaleProportionallyUpOrDown
+            }
+
+        case "tintColor":
+            if let colorStr = value as? String {
+                imageView.contentTintColor = NSColor.fromHex(colorStr)
+                // Set image as template so tint applies
+                imageView.image?.isTemplate = true
+            } else {
+                imageView.contentTintColor = nil
+            }
+
+        case "blurRadius":
+            if let radius = value as? Double, radius > 0 {
+                applyBlur(to: imageView, radius: radius)
+            } else {
+                // Remove blur
+                imageView.layer?.filters = nil
+            }
+
+        case "defaultSource":
+            // Set placeholder image
+            if let source = value as? String {
+                if let image = NSImage(named: source) {
+                    // Only set if no image is currently loaded
+                    if imageView.image == nil {
+                        imageView.image = image
+                    }
+                } else if let image = loadFromBundle(source) {
+                    if imageView.image == nil {
+                        imageView.image = image
+                    }
+                }
+            }
+
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void) {
+        switch event {
+        case "load":
+            objc_setAssociatedObject(
+                view, &VImageFactory.loadHandlerKey,
+                handler as AnyObject, .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+        case "error":
+            objc_setAssociatedObject(
+                view, &VImageFactory.errorHandlerKey,
+                handler as AnyObject, .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+        default:
+            break
+        }
+    }
+
+    func removeEventListener(view: NSView, event: String) {
+        switch event {
+        case "load":
+            objc_setAssociatedObject(
+                view, &VImageFactory.loadHandlerKey,
+                nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+        case "error":
+            objc_setAssociatedObject(
+                view, &VImageFactory.errorHandlerKey,
+                nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+        default:
+            break
+        }
+    }
+
+    // MARK: - Async image loading
+
+    private func loadImageFromURL(_ url: URL, into imageView: NSImageView) {
+        let cacheKey = url.absoluteString as NSString
+
+        // Check cache first
+        if let cached = VImageFactory.imageCache.object(forKey: cacheKey) {
+            imageView.image = cached
+            fireLoadEvent(for: imageView, image: cached)
+            return
+        }
+
+        let task = URLSession.shared.dataTask(with: url) { [weak imageView] data, response, error in
+            DispatchQueue.main.async {
+                guard let imageView = imageView else { return }
+
+                if let error = error {
+                    self.fireErrorEvent(for: imageView, message: error.localizedDescription)
+                    return
+                }
+
+                guard let data = data, let image = NSImage(data: data) else {
+                    self.fireErrorEvent(for: imageView, message: "Failed to decode image data")
+                    return
+                }
+
+                // Cache the image
+                VImageFactory.imageCache.setObject(image, forKey: cacheKey)
+
+                imageView.image = image
+                self.fireLoadEvent(for: imageView, image: image)
+            }
+        }
+        task.resume()
+
+        // Store the task so we can cancel it if source changes
+        objc_setAssociatedObject(
+            imageView, &VImageFactory.loadTaskKey,
+            task, .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+        )
+    }
+
+    private func cancelLoad(on view: NSView) {
+        if let task = objc_getAssociatedObject(view, &VImageFactory.loadTaskKey) as? URLSessionDataTask {
+            task.cancel()
+            objc_setAssociatedObject(
+                view, &VImageFactory.loadTaskKey,
+                nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+        }
+    }
+
+    private func loadFromBundle(_ name: String) -> NSImage? {
+        // Try loading from main bundle by path
+        if let path = Bundle.main.path(forResource: name, ofType: nil) {
+            return NSImage(contentsOfFile: path)
+        }
+        // Try without extension
+        let components = name.split(separator: ".")
+        if components.count >= 2 {
+            let baseName = String(components.dropLast().joined(separator: "."))
+            let ext = String(components.last!)
+            if let path = Bundle.main.path(forResource: baseName, ofType: ext) {
+                return NSImage(contentsOfFile: path)
+            }
+        }
+        return nil
+    }
+
+    // MARK: - Event helpers
+
+    private func fireLoadEvent(for imageView: NSImageView, image: NSImage) {
+        guard let handler = objc_getAssociatedObject(
+            imageView, &VImageFactory.loadHandlerKey
+        ) as? (Any?) -> Void else { return }
+
+        let payload: [String: Any] = [
+            "width": image.size.width,
+            "height": image.size.height
+        ]
+        handler(payload)
+    }
+
+    private func fireErrorEvent(for imageView: NSImageView, message: String) {
+        guard let handler = objc_getAssociatedObject(
+            imageView, &VImageFactory.errorHandlerKey
+        ) as? (Any?) -> Void else { return }
+
+        let payload: [String: Any] = [
+            "error": message
+        ]
+        handler(payload)
+    }
+
+    // MARK: - Blur effect
+
+    private func applyBlur(to imageView: NSImageView, radius: Double) {
+        guard let image = imageView.image,
+              let tiffData = image.tiffRepresentation,
+              let ciImage = CIImage(data: tiffData) else { return }
+
+        let filter = CIFilter(name: "CIGaussianBlur")
+        filter?.setValue(ciImage, forKey: kCIInputImageKey)
+        filter?.setValue(radius, forKey: kCIInputRadiusKey)
+
+        guard let outputImage = filter?.outputImage else { return }
+
+        let context = CIContext()
+        let extent = ciImage.extent
+        guard let cgImage = context.createCGImage(outputImage, from: extent) else { return }
+
+        let blurredImage = NSImage(cgImage: cgImage, size: image.size)
+        imageView.image = blurredImage
+    }
+}

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

@@ -0,0 +1,257 @@
+import AppKit
+import ObjectiveC
+
+/// Factory for VInput — the text input component.
+/// Maps to an NSTextField (editable) with a LayoutNode.
+/// Supports v-model via text prop and changetext event.
+/// For secure text entry, swaps to an NSSecureTextField.
+final class VInputFactory: NativeComponentFactory {
+
+    // MARK: - Associated object keys
+
+    private static var delegateKey: UInt8 = 0
+    private static var changeTextHandlerKey: UInt8 = 0
+    private static var focusHandlerKey: UInt8 = 0
+    private static var blurHandlerKey: UInt8 = 0
+    private static var submitHandlerKey: UInt8 = 0
+    private static var maxLengthKey: UInt8 = 0
+
+    // MARK: - NativeComponentFactory
+
+    func createView() -> NSView {
+        let textField = NSTextField()
+        textField.isBordered = true
+        textField.isEditable = true
+        textField.isSelectable = true
+        textField.wantsLayer = true
+        // Set a sensible default height so the text field is not collapsed
+        let node = textField.ensureLayoutNode()
+        node.height = .points(28)
+        return textField
+    }
+
+    func updateProp(view: NSView, key: String, value: Any?) {
+        guard let textField = view as? NSTextField else {
+            StyleEngine.apply(key: key, value: value, to: view)
+            return
+        }
+
+        switch key {
+        case "text", "value":
+            if let text = value as? String {
+                // Only update if different to avoid cursor jump
+                if textField.stringValue != text {
+                    textField.stringValue = text
+                }
+            } else {
+                textField.stringValue = ""
+            }
+
+        case "placeholder":
+            if let placeholder = value as? String {
+                textField.placeholderString = placeholder
+            } else {
+                textField.placeholderString = nil
+            }
+
+        case "placeholderColor", "placeholderTextColor":
+            if let colorStr = value as? String, let placeholder = textField.placeholderString {
+                textField.placeholderAttributedString = NSAttributedString(
+                    string: placeholder,
+                    attributes: [.foregroundColor: NSColor.fromHex(colorStr)]
+                )
+            }
+
+        case "secureTextEntry":
+            // Note: NSSecureTextField is a subclass, not a property toggle.
+            // Full secure text entry requires view replacement at the bridge level.
+            // Here we just store the prop for reference.
+            let secure: Bool
+            if let val = value as? Bool {
+                secure = val
+            } else if let val = value as? Int {
+                secure = val != 0
+            } else {
+                secure = false
+            }
+            StyleEngine.setInternalPropDirect("__secureTextEntry", value: secure, on: view)
+
+        case "editable":
+            if let editable = value as? Bool {
+                textField.isEditable = editable
+            } else {
+                textField.isEditable = true
+            }
+
+        case "maxLength":
+            if let maxLen = value as? Int {
+                storeMaxLength(maxLen, on: textField)
+            } else if let maxLen = value as? Double {
+                storeMaxLength(Int(maxLen), on: textField)
+            }
+
+        case "color":
+            if let colorStr = value as? String {
+                textField.textColor = NSColor.fromHex(colorStr)
+            } else {
+                textField.textColor = .labelColor
+            }
+
+        case "fontSize":
+            if let size = value as? Double {
+                textField.font = NSFont.systemFont(ofSize: CGFloat(size))
+            } else if let size = value as? Int {
+                textField.font = NSFont.systemFont(ofSize: CGFloat(size))
+            }
+
+        case "textAlign":
+            if let alignStr = value as? String {
+                switch alignStr {
+                case "left": textField.alignment = .left
+                case "center": textField.alignment = .center
+                case "right": textField.alignment = .right
+                default: textField.alignment = .natural
+                }
+            }
+
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: NSView, event: String, handler: @escaping (Any?) -> Void) {
+        guard let textField = view as? NSTextField else { return }
+
+        // Ensure we have a delegate proxy set up
+        let delegate = ensureDelegate(for: textField)
+
+        switch event {
+        case "changetext":
+            delegate.onChangeText = handler
+            objc_setAssociatedObject(
+                view,
+                &VInputFactory.changeTextHandlerKey,
+                handler as AnyObject,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+        case "focus":
+            delegate.onFocus = handler
+            objc_setAssociatedObject(
+                view,
+                &VInputFactory.focusHandlerKey,
+                handler as AnyObject,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+        case "blur":
+            delegate.onBlur = handler
+            objc_setAssociatedObject(
+                view,
+                &VInputFactory.blurHandlerKey,
+                handler as AnyObject,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+        case "submit":
+            delegate.onSubmit = handler
+            objc_setAssociatedObject(
+                view,
+                &VInputFactory.submitHandlerKey,
+                handler as AnyObject,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+        default:
+            break
+        }
+    }
+
+    func removeEventListener(view: NSView, event: String) {
+        guard let textField = view as? NSTextField else { return }
+        guard let delegate = objc_getAssociatedObject(textField, &VInputFactory.delegateKey) as? InputDelegateProxy else { return }
+
+        switch event {
+        case "changetext":
+            delegate.onChangeText = nil
+        case "focus":
+            delegate.onFocus = nil
+        case "blur":
+            delegate.onBlur = nil
+        case "submit":
+            delegate.onSubmit = nil
+        default:
+            break
+        }
+    }
+
+    // MARK: - Private helpers
+
+    private func ensureDelegate(for textField: NSTextField) -> InputDelegateProxy {
+        if let existing = objc_getAssociatedObject(textField, &VInputFactory.delegateKey) as? InputDelegateProxy {
+            return existing
+        }
+
+        let delegate = InputDelegateProxy()
+        delegate.maxLengthProvider = { [weak textField] in
+            guard let tf = textField else { return nil }
+            return self.storedMaxLength(on: tf)
+        }
+        textField.delegate = delegate
+        objc_setAssociatedObject(
+            textField,
+            &VInputFactory.delegateKey,
+            delegate,
+            .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+        )
+        return delegate
+    }
+
+    // MARK: - Max length storage
+
+    private func storeMaxLength(_ length: Int, on view: NSView) {
+        objc_setAssociatedObject(view, &VInputFactory.maxLengthKey, length, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+
+    private func storedMaxLength(on view: NSView) -> Int? {
+        return objc_getAssociatedObject(view, &VInputFactory.maxLengthKey) as? Int
+    }
+}
+
+// MARK: - InputDelegateProxy
+
+/// NSTextFieldDelegate proxy that routes text field events to closure-based handlers.
+/// Stored as an associated object on the NSTextField.
+final class InputDelegateProxy: NSObject, NSTextFieldDelegate {
+
+    var onChangeText: ((Any?) -> Void)?
+    var onFocus: ((Any?) -> Void)?
+    var onBlur: ((Any?) -> Void)?
+    var onSubmit: ((Any?) -> Void)?
+    var maxLengthProvider: (() -> Int?)?
+
+    // MARK: - NSTextFieldDelegate
+
+    func controlTextDidChange(_ obj: Notification) {
+        guard let textField = obj.object as? NSTextField else { return }
+        // Enforce max length
+        if let maxLength = maxLengthProvider?(), textField.stringValue.count > maxLength {
+            textField.stringValue = String(textField.stringValue.prefix(maxLength))
+        }
+        onChangeText?(textField.stringValue)
+    }
+
+    func controlTextDidBeginEditing(_ obj: Notification) {
+        onFocus?(nil)
+    }
+
+    func controlTextDidEndEditing(_ obj: Notification) {
+        onBlur?(nil)
+        // Check if editing ended due to Return key
+        if let textField = obj.object as? NSTextField,
+           let movement = obj.userInfo?["NSTextMovement"] as? Int,
+           movement == NSReturnTextMovement {
+            onSubmit?(textField.stringValue)
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+import AppKit
+
+/// Factory for VKeyboardAvoiding — pass-through container on macOS.
+/// macOS keyboards do not cover content (unlike iOS on-screen keyboards),
+/// so this component acts as a plain FlippedView container for API compatibility.
+final class VKeyboardAvoidingFactory: 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) {
+        // No-op — no keyboard avoidance on macOS
+    }
+}