@thelacanians/vue-native-cli 0.4.3 → 0.4.5

package/native/ios/VueNativeCore/Sources/VueNativeCore/Components/Factories/VModalFactory.swift

@@ -0,0 +1,109 @@
+#if canImport(UIKit)
+import UIKit
+import FlexLayout
+
+/// Factory for VModal — a window-level overlay component.
+/// The VModal view itself is a zero-size placeholder in the native view tree.
+/// Its children are rendered in a full-screen overlay view added to the key window.
+final class VModalFactory: NativeComponentFactory {
+
+    private static var overlayKey: UInt8 = 0
+    private static var visibleKey: UInt8 = 1
+
+    func createView() -> UIView {
+        // Zero-size placeholder in the tree
+        let placeholder = UIView()
+        placeholder.isHidden = true
+        _ = placeholder.flex.width(0).height(0)
+        return placeholder
+    }
+
+    func updateProp(view: UIView, key: String, value: Any?) {
+        switch key {
+        case "visible":
+            let visible = (value as? Bool) ?? (value as? NSNumber)?.boolValue ?? false
+            updateVisibility(view: view, visible: visible)
+        case "onDismiss":
+            break // handled via event
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    private func updateVisibility(view: UIView, visible: Bool) {
+        if visible {
+            showOverlay(for: view)
+        } else {
+            hideOverlay(for: view)
+        }
+    }
+
+    private func showOverlay(for placeholder: UIView) {
+        guard let window = UIApplication.shared.vn_keyWindow else { return }
+
+        // Get or create overlay
+        let overlay: UIView
+        if let existing = objc_getAssociatedObject(placeholder, &VModalFactory.overlayKey) as? UIView {
+            overlay = existing
+        } else {
+            overlay = UIView()
+            overlay.backgroundColor = UIColor(white: 0, alpha: 0.5)
+            objc_setAssociatedObject(
+                placeholder,
+                &VModalFactory.overlayKey,
+                overlay,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+        }
+
+        overlay.frame = window.bounds
+        window.addSubview(overlay)
+
+        // Run Yoga on overlay children
+        overlay.flex.layout(mode: .fitContainer)
+    }
+
+    private func hideOverlay(for placeholder: UIView) {
+        if let overlay = objc_getAssociatedObject(placeholder, &VModalFactory.overlayKey) as? UIView {
+            overlay.removeFromSuperview()
+        }
+    }
+
+    func addEventListener(view: UIView, event: String, handler: @escaping (Any?) -> Void) {
+        // dismiss event from tapping backdrop — no-op for now
+    }
+
+    func removeEventListener(view: UIView, event: String) {}
+
+    // Custom child management: route children to the overlay view
+    func insertChild(_ child: UIView, into parent: UIView, before anchor: UIView?) {
+        let overlay: UIView
+        if let existing = objc_getAssociatedObject(parent, &VModalFactory.overlayKey) as? UIView {
+            overlay = existing
+        } else {
+            // Create overlay early so children have somewhere to go
+            let newOverlay = UIView()
+            newOverlay.backgroundColor = UIColor(white: 0, alpha: 0.5)
+            _ = newOverlay.flex.grow(1)
+            objc_setAssociatedObject(
+                parent,
+                &VModalFactory.overlayKey,
+                newOverlay,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+            overlay = newOverlay
+        }
+
+        if let anchor = anchor, let idx = overlay.subviews.firstIndex(of: anchor) {
+            overlay.insertSubview(child, at: idx)
+        } else {
+            overlay.addSubview(child)
+        }
+        _ = child.flex
+    }
+
+    func removeChild(_ child: UIView, from parent: UIView) {
+        child.removeFromSuperview()
+    }
+}
+#endif

package/native/ios/VueNativeCore/Sources/VueNativeCore/Components/Factories/VPickerFactory.swift

@@ -0,0 +1,96 @@
+#if canImport(UIKit)
+import UIKit
+import FlexLayout
+import ObjectiveC
+
+private var pickerOnChangeKey: UInt8 = 0
+private var pickerItemsKey: UInt8 = 1
+private var pickerDelegateKey: UInt8 = 2
+
+/// Factory for VPicker.
+/// Modes: "selector" (UIPickerView), "date", "time", "datetime" (UIDatePicker)
+final class VPickerFactory: NativeComponentFactory {
+
+    func createView() -> UIView {
+        // Default: UIDatePicker (most common on mobile)
+        let picker = UIDatePicker()
+        picker.datePickerMode = .date
+        if #available(iOS 14.0, *) {
+            picker.preferredDatePickerStyle = .compact
+        }
+        _ = picker.flex
+        return picker
+    }
+
+    func updateProp(view: UIView, key: String, value: Any?) {
+        switch key {
+        case "mode":
+            guard let modeStr = value as? String else { return }
+            // If we have a UIDatePicker, set its mode
+            if let datePicker = view as? UIDatePicker {
+                switch modeStr {
+                case "date":     datePicker.datePickerMode = .date
+                case "time":     datePicker.datePickerMode = .time
+                case "datetime": datePicker.datePickerMode = .dateAndTime
+                default: break
+                }
+            }
+        case "value":
+            if let datePicker = view as? UIDatePicker {
+                if let ms = (value as? Double) ?? (value as? NSNumber)?.doubleValue {
+                    datePicker.date = Date(timeIntervalSince1970: ms / 1000.0)
+                }
+            }
+        case "minimumDate":
+            if let datePicker = view as? UIDatePicker,
+               let ms = (value as? Double) ?? (value as? NSNumber)?.doubleValue {
+                datePicker.minimumDate = Date(timeIntervalSince1970: ms / 1000.0)
+            }
+        case "maximumDate":
+            if let datePicker = view as? UIDatePicker,
+               let ms = (value as? Double) ?? (value as? NSNumber)?.doubleValue {
+                datePicker.maximumDate = Date(timeIntervalSince1970: ms / 1000.0)
+            }
+        case "minuteInterval":
+            if let datePicker = view as? UIDatePicker,
+               let interval = (value as? Int) ?? (value as? NSNumber)?.intValue {
+                datePicker.minuteInterval = interval
+            }
+        case "items":
+            // UIPickerView items — not using UIPickerView in this simplified version
+            objc_setAssociatedObject(view, &pickerItemsKey, value, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: UIView, event: String, handler: @escaping (Any?) -> Void) {
+        if event == "change" {
+            objc_setAssociatedObject(view, &pickerOnChangeKey, handler as AnyObject, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+            if let datePicker = view as? UIDatePicker {
+                let target = PickerChangeTarget(view: view)
+                objc_setAssociatedObject(view, &pickerDelegateKey, target, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+                datePicker.addTarget(target, action: #selector(PickerChangeTarget.handleChange(_:)), for: .valueChanged)
+            }
+        }
+    }
+
+    func removeEventListener(view: UIView, event: String) {
+        if event == "change" {
+            objc_setAssociatedObject(view, &pickerOnChangeKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+        }
+    }
+}
+
+private final class PickerChangeTarget: NSObject {
+    private weak var view: UIView?
+    init(view: UIView) { self.view = view }
+
+    @objc func handleChange(_ picker: UIDatePicker) {
+        guard let view = view else { return }
+        if let handler = objc_getAssociatedObject(view, &pickerOnChangeKey) as? ((Any?) -> Void) {
+            handler(["value": picker.date.timeIntervalSince1970 * 1000.0])
+        }
+    }
+}
+#endif

package/native/ios/VueNativeCore/Sources/VueNativeCore/Components/Factories/VPressableFactory.swift

@@ -0,0 +1,168 @@
+#if canImport(UIKit)
+import UIKit
+import ObjectiveC
+import FlexLayout
+
+/// Factory for VPressable — a generic pressable container component.
+///
+/// Like VButton but without built-in text/label support. Provides press,
+/// long press, pressIn, and pressOut events. Uses PressableView, a subclass
+/// of TouchableView that adds pressIn/pressOut callbacks.
+final class VPressableFactory: NativeComponentFactory {
+
+    // MARK: - Associated object keys for event handlers
+
+    private static var pressHandlerKey: UInt8 = 0
+    private static var longPressHandlerKey: UInt8 = 1
+    private static var pressInHandlerKey: UInt8 = 2
+    private static var pressOutHandlerKey: UInt8 = 3
+
+    // MARK: - NativeComponentFactory
+
+    func createView() -> UIView {
+        let pressable = PressableView()
+        // Accessing .flex automatically enables Yoga layout
+        _ = pressable.flex
+        return pressable
+    }
+
+    func updateProp(view: UIView, key: String, value: Any?) {
+        guard let pressable = view as? PressableView else {
+            StyleEngine.apply(key: key, value: value, to: view)
+            return
+        }
+
+        switch key {
+        case "disabled":
+            if let disabled = value as? Bool {
+                pressable.isDisabled = disabled
+            } else if let disabled = value as? Int {
+                pressable.isDisabled = disabled != 0
+            } else {
+                pressable.isDisabled = false
+            }
+
+        case "activeOpacity":
+            if let opacity = value as? Double {
+                pressable.activeOpacity = CGFloat(opacity)
+            } else if let opacity = value as? Int {
+                pressable.activeOpacity = CGFloat(opacity)
+            } else {
+                pressable.activeOpacity = 0.7
+            }
+
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: UIView, event: String, handler: @escaping (Any?) -> Void) {
+        guard let pressable = view as? PressableView else { return }
+
+        switch event {
+        case "press":
+            pressable.onPress = {
+                handler(nil)
+            }
+            objc_setAssociatedObject(
+                view,
+                &VPressableFactory.pressHandlerKey,
+                handler as AnyObject,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+        case "longpress":
+            pressable.onLongPress = {
+                handler(nil)
+            }
+            objc_setAssociatedObject(
+                view,
+                &VPressableFactory.longPressHandlerKey,
+                handler as AnyObject,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+        case "pressIn", "pressin":
+            pressable.onPressIn = {
+                handler(nil)
+            }
+            objc_setAssociatedObject(
+                view,
+                &VPressableFactory.pressInHandlerKey,
+                handler as AnyObject,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+        case "pressOut", "pressout":
+            pressable.onPressOut = {
+                handler(nil)
+            }
+            objc_setAssociatedObject(
+                view,
+                &VPressableFactory.pressOutHandlerKey,
+                handler as AnyObject,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+
+        default:
+            break
+        }
+    }
+
+    func removeEventListener(view: UIView, event: String) {
+        guard let pressable = view as? PressableView else { return }
+
+        switch event {
+        case "press":
+            pressable.onPress = nil
+            objc_setAssociatedObject(view, &VPressableFactory.pressHandlerKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+
+        case "longpress":
+            pressable.onLongPress = nil
+            objc_setAssociatedObject(view, &VPressableFactory.longPressHandlerKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+
+        case "pressIn", "pressin":
+            pressable.onPressIn = nil
+            objc_setAssociatedObject(view, &VPressableFactory.pressInHandlerKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+
+        case "pressOut", "pressout":
+            pressable.onPressOut = nil
+            objc_setAssociatedObject(view, &VPressableFactory.pressOutHandlerKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+
+        default:
+            break
+        }
+    }
+}
+
+// MARK: - PressableView
+
+/// Extension of TouchableView that adds pressIn and pressOut callbacks.
+/// Fires pressIn when a touch begins and pressOut when the touch ends or is cancelled.
+final class PressableView: TouchableView {
+
+    /// Called when a touch begins inside the view bounds.
+    var onPressIn: (() -> Void)?
+
+    /// Called when a touch ends or is cancelled.
+    var onPressOut: (() -> Void)?
+
+    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
+        super.touchesBegan(touches, with: event)
+        guard !isDisabled else { return }
+        onPressIn?()
+    }
+
+    override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {
+        super.touchesEnded(touches, with: event)
+        guard !isDisabled else { return }
+        onPressOut?()
+    }
+
+    override func touchesCancelled(_ touches: Set<UITouch>, with event: UIEvent?) {
+        super.touchesCancelled(touches, with: event)
+        guard !isDisabled else { return }
+        onPressOut?()
+    }
+}
+#endif

package/native/ios/VueNativeCore/Sources/VueNativeCore/Components/Factories/VProgressBarFactory.swift

@@ -0,0 +1,39 @@
+#if canImport(UIKit)
+import UIKit
+import FlexLayout
+
+/// Factory for VProgressBar — maps to UIProgressView.
+final class VProgressBarFactory: NativeComponentFactory {
+
+    func createView() -> UIView {
+        let bar = UIProgressView(progressViewStyle: .default)
+        bar.progress = 0
+        _ = bar.flex
+        return bar
+    }
+
+    func updateProp(view: UIView, key: String, value: Any?) {
+        guard let bar = view as? UIProgressView else {
+            StyleEngine.apply(key: key, value: value, to: view)
+            return
+        }
+        switch key {
+        case "progress":
+            let p = (value as? Double) ?? (value as? NSNumber)?.doubleValue ?? 0
+            bar.setProgress(Float(max(0, min(1, p))), animated: false)
+        case "progressTintColor":
+            if let str = value as? String { bar.progressTintColor = UIColor.fromHex(str) }
+        case "trackTintColor":
+            if let str = value as? String { bar.trackTintColor = UIColor.fromHex(str) }
+        case "animated":
+            // stored for use in future progress updates — no-op here
+            break
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: UIView, event: String, handler: @escaping (Any?) -> Void) {}
+    func removeEventListener(view: UIView, event: String) {}
+}
+#endif

package/native/ios/VueNativeCore/Sources/VueNativeCore/Components/Factories/VRadioFactory.swift

@@ -0,0 +1,167 @@
+#if canImport(UIKit)
+import UIKit
+import FlexLayout
+import ObjectiveC
+
+private var radioOnChangeKey: UInt8 = 0
+private var radioOptionsKey: UInt8 = 1
+private var radioSelectedKey: UInt8 = 2
+
+/// Factory for VRadio — a radio button group.
+/// Uses a vertical UIStackView with rows of custom radio circles and labels.
+final class VRadioFactory: NativeComponentFactory {
+
+    func createView() -> UIView {
+        let stack = UIStackView()
+        stack.axis = .vertical
+        stack.spacing = 12
+        stack.alignment = .leading
+        _ = stack.flex
+        return stack
+    }
+
+    func updateProp(view: UIView, key: String, value: Any?) {
+        guard let stack = view as? UIStackView else {
+            StyleEngine.apply(key: key, value: value, to: view)
+            return
+        }
+
+        switch key {
+        case "options":
+            guard let items = value as? [[String: Any]] else { return }
+            let options = items.compactMap { dict -> (label: String, value: String)? in
+                guard let label = dict["label"] as? String,
+                      let val = dict["value"] as? String else { return nil }
+                return (label, val)
+            }
+            objc_setAssociatedObject(view, &radioOptionsKey, options.map { $0.value }, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+
+            // Rebuild radio buttons
+            stack.arrangedSubviews.forEach { $0.removeFromSuperview() }
+            for (index, option) in options.enumerated() {
+                let row = createRadioRow(label: option.label, index: index, in: view)
+                stack.addArrangedSubview(row)
+            }
+
+            // Re-apply selection
+            if let selected = objc_getAssociatedObject(view, &radioSelectedKey) as? String {
+                applySelection(stack, selectedValue: selected)
+            }
+
+        case "selectedValue":
+            let selected = value as? String ?? ""
+            objc_setAssociatedObject(view, &radioSelectedKey, selected, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+            applySelection(stack, selectedValue: selected)
+
+        case "disabled":
+            let disabled = (value as? Bool) ?? false
+            stack.isUserInteractionEnabled = !disabled
+            stack.alpha = disabled ? 0.4 : 1.0
+
+        case "tintColor":
+            if let colorStr = value as? String {
+                let color = UIColor.fromHex(colorStr)
+                for subview in stack.arrangedSubviews {
+                    if let circle = subview.viewWithTag(2001) as? UIImageView {
+                        circle.tintColor = color
+                    }
+                }
+            }
+
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: UIView, event: String, handler: @escaping (Any?) -> Void) {
+        guard event == "change" else { return }
+        objc_setAssociatedObject(view, &radioOnChangeKey, handler as AnyObject, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+
+    func removeEventListener(view: UIView, event: String) {
+        if event == "change" {
+            objc_setAssociatedObject(view, &radioOnChangeKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+            // Remove RadioTapGesture recognizers from all radio row subviews
+            if let stack = view as? UIStackView {
+                for row in stack.arrangedSubviews {
+                    row.gestureRecognizers?.forEach { recognizer in
+                        if recognizer is RadioTapGesture {
+                            row.removeGestureRecognizer(recognizer)
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // MARK: - Helpers
+
+    private func createRadioRow(label: String, index: Int, in container: UIView) -> UIView {
+        let row = UIStackView()
+        row.axis = .horizontal
+        row.spacing = 8
+        row.alignment = .center
+
+        let circle = UIImageView()
+        circle.contentMode = .scaleAspectFit
+        circle.tag = 2001
+        circle.tintColor = .systemBlue
+        circle.translatesAutoresizingMaskIntoConstraints = false
+        NSLayoutConstraint.activate([
+            circle.widthAnchor.constraint(equalToConstant: 22),
+            circle.heightAnchor.constraint(equalToConstant: 22),
+        ])
+        updateRadioImage(circle, selected: false)
+
+        let textLabel = UILabel()
+        textLabel.text = label
+        textLabel.font = UIFont.systemFont(ofSize: 16)
+        textLabel.tag = 2002
+
+        row.addArrangedSubview(circle)
+        row.addArrangedSubview(textLabel)
+
+        row.tag = 3000 + index
+        row.isUserInteractionEnabled = true
+        let tap = RadioTapGesture(target: self, action: #selector(handleRadioTap(_:)))
+        tap.radioIndex = index
+        tap.containerView = container
+        row.addGestureRecognizer(tap)
+
+        return row
+    }
+
+    @objc private func handleRadioTap(_ sender: RadioTapGesture) {
+        guard let container = sender.containerView else { return }
+        let values = objc_getAssociatedObject(container, &radioOptionsKey) as? [String] ?? []
+        guard sender.radioIndex < values.count else { return }
+        let value = values[sender.radioIndex]
+
+        if let handler = objc_getAssociatedObject(container, &radioOnChangeKey) as? ((Any?) -> Void) {
+            handler(["value": value])
+        }
+    }
+
+    private func applySelection(_ stack: UIStackView, selectedValue: String) {
+        let values = objc_getAssociatedObject(stack, &radioOptionsKey) as? [String] ?? []
+        for (index, subview) in stack.arrangedSubviews.enumerated() {
+            if let circle = subview.viewWithTag(2001) as? UIImageView {
+                let isSelected = index < values.count && values[index] == selectedValue
+                updateRadioImage(circle, selected: isSelected)
+            }
+        }
+    }
+
+    private func updateRadioImage(_ imageView: UIImageView, selected: Bool) {
+        let symbolName = selected ? "circle.inset.filled" : "circle"
+        let config = UIImage.SymbolConfiguration(pointSize: 20, weight: .regular)
+        imageView.image = UIImage(systemName: symbolName, withConfiguration: config)
+    }
+}
+
+/// Custom UITapGestureRecognizer that carries the radio index and parent view.
+private final class RadioTapGesture: UITapGestureRecognizer {
+    var radioIndex: Int = 0
+    weak var containerView: UIView?
+}
+#endif