@thelacanians/vue-native-cli 0.4.3 → 0.4.4

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

@@ -0,0 +1,73 @@
+#if canImport(UIKit)
+import UIKit
+import FlexLayout
+import ObjectiveC
+
+private var segOnChangeKey: UInt8 = 0
+private var segTargetKey: UInt8 = 1
+
+final class VSegmentedControlFactory: NativeComponentFactory {
+
+    func createView() -> UIView {
+        let seg = UISegmentedControl()
+        _ = seg.flex
+        return seg
+    }
+
+    func updateProp(view: UIView, key: String, value: Any?) {
+        guard let seg = view as? UISegmentedControl else {
+            StyleEngine.apply(key: key, value: value, to: view)
+            return
+        }
+        switch key {
+        case "values":
+            guard let items = value as? [String] else { return }
+            seg.removeAllSegments()
+            for (i, item) in items.enumerated() {
+                seg.insertSegment(withTitle: item, at: i, animated: false)
+            }
+        case "selectedIndex":
+            let idx = (value as? Int) ?? (value as? NSNumber)?.intValue ?? 0
+            seg.selectedSegmentIndex = idx
+        case "tintColor":
+            if let str = value as? String { seg.selectedSegmentTintColor = UIColor.fromHex(str) }
+        case "enabled":
+            seg.isEnabled = (value as? Bool) ?? (value as? NSNumber)?.boolValue ?? true
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: UIView, event: String, handler: @escaping (Any?) -> Void) {
+        guard event == "change", let seg = view as? UISegmentedControl else { return }
+        objc_setAssociatedObject(view, &segOnChangeKey, handler as AnyObject, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+        let target = SegmentedTarget(view: view)
+        objc_setAssociatedObject(view, &segTargetKey, target, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+        seg.addTarget(target, action: #selector(SegmentedTarget.handleChange(_:)), for: .valueChanged)
+    }
+
+    func removeEventListener(view: UIView, event: String) {
+        if event == "change" {
+            // Remove the UIControl target before clearing the reference
+            if let target = objc_getAssociatedObject(view, &segTargetKey) as? SegmentedTarget,
+               let seg = view as? UISegmentedControl {
+                seg.removeTarget(target, action: #selector(SegmentedTarget.handleChange(_:)), for: .valueChanged)
+            }
+            objc_setAssociatedObject(view, &segOnChangeKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+            objc_setAssociatedObject(view, &segTargetKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+        }
+    }
+}
+
+private final class SegmentedTarget: NSObject {
+    private weak var view: UIView?
+    init(view: UIView) { self.view = view }
+
+    @objc func handleChange(_ seg: UISegmentedControl) {
+        guard let view = view else { return }
+        if let handler = objc_getAssociatedObject(view, &segOnChangeKey) as? ((Any?) -> Void) {
+            handler(["selectedIndex": seg.selectedSegmentIndex, "value": seg.titleForSegment(at: seg.selectedSegmentIndex) ?? ""])
+        }
+    }
+}
+#endif

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

@@ -0,0 +1,63 @@
+#if canImport(UIKit)
+import UIKit
+import FlexLayout
+import ObjectiveC
+
+/// Factory for VSlider — maps to UISlider.
+final class VSliderFactory: NativeComponentFactory {
+
+    private static var onChangeKey: UInt8 = 0
+
+    func createView() -> UIView {
+        let slider = UISlider()
+        slider.minimumValue = 0
+        slider.maximumValue = 1
+        _ = slider.flex
+        return slider
+    }
+
+    func updateProp(view: UIView, key: String, value: Any?) {
+        guard let slider = view as? UISlider else {
+            StyleEngine.apply(key: key, value: value, to: view)
+            return
+        }
+        switch key {
+        case "value":
+            slider.value = Float(value as? Double ?? Double(value as? Float ?? 0))
+        case "minimumValue", "min":
+            slider.minimumValue = Float(value as? Double ?? 0)
+        case "maximumValue", "max":
+            slider.maximumValue = Float(value as? Double ?? 1)
+        case "minimumTrackTintColor":
+            slider.minimumTrackTintColor = UIColor.fromHex(value as? String ?? "")
+        case "maximumTrackTintColor":
+            slider.maximumTrackTintColor = UIColor.fromHex(value as? String ?? "")
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: UIView, event: String, handler: @escaping (Any?) -> Void) {
+        guard event == "change", let slider = view as? UISlider else { return }
+        let target = SliderTarget(handler: handler)
+        slider.addTarget(target, action: #selector(SliderTarget.handleValueChanged(_:)), for: .valueChanged)
+        objc_setAssociatedObject(slider, &VSliderFactory.onChangeKey, target, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+
+    func removeEventListener(view: UIView, event: String) {
+        guard event == "change", let slider = view as? UISlider else { return }
+        if let target = objc_getAssociatedObject(slider, &VSliderFactory.onChangeKey) as? SliderTarget {
+            slider.removeTarget(target, action: #selector(SliderTarget.handleValueChanged(_:)), for: .valueChanged)
+        }
+        objc_setAssociatedObject(slider, &VSliderFactory.onChangeKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+}
+
+private final class SliderTarget: NSObject {
+    let handler: (Any?) -> Void
+    init(handler: @escaping (Any?) -> Void) { self.handler = handler }
+    @objc func handleValueChanged(_ slider: UISlider) {
+        handler(Double(slider.value))
+    }
+}
+#endif

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

@@ -0,0 +1,50 @@
+#if canImport(UIKit)
+import UIKit
+
+/// Factory for VStatusBar — a zero-size, hidden placeholder view that controls
+/// the system status bar appearance by posting notifications to the root
+/// view controller, which must observe them to update its `preferredStatusBarStyle`
+/// and `prefersStatusBarHidden` overrides.
+@MainActor
+final class VStatusBarFactory: NativeComponentFactory {
+
+    func createView() -> UIView {
+        let v = UIView()
+        v.isHidden = true
+        return v
+    }
+
+    func updateProp(view: UIView, key: String, value: Any?) {
+        switch key {
+        case "barStyle":
+            guard let style = value as? String else { return }
+            DispatchQueue.main.async {
+                NotificationCenter.default.post(
+                    name: Notification.Name("VueNativeStatusBarStyleChange"),
+                    object: nil,
+                    userInfo: ["style": style]
+                )
+            }
+        case "hidden":
+            let hidden = (value as? Bool) ?? (value as? NSNumber)?.boolValue ?? false
+            DispatchQueue.main.async {
+                NotificationCenter.default.post(
+                    name: Notification.Name("VueNativeStatusBarHiddenChange"),
+                    object: nil,
+                    userInfo: ["hidden": hidden]
+                )
+            }
+        default:
+            break
+        }
+    }
+
+    func addEventListener(view: UIView, event: String, handler: @escaping (Any?) -> Void) {
+        // VStatusBar emits no events
+    }
+
+    func removeEventListener(view: UIView, event: String) {
+        // VStatusBar emits no events
+    }
+}
+#endif

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

@@ -0,0 +1,108 @@
+#if canImport(UIKit)
+import UIKit
+import ObjectiveC
+import FlexLayout
+
+/// Factory for VSwitch — the boolean toggle switch component.
+/// Maps to UISwitch with FlexLayout enabled.
+/// Supports v-model via the `value` prop and `change` event.
+final class VSwitchFactory: NativeComponentFactory {
+
+    private static var changeHandlerKey: UInt8 = 0
+
+    // MARK: - NativeComponentFactory
+
+    func createView() -> UIView {
+        let sw = UISwitch()
+        _ = sw.flex
+        return sw
+    }
+
+    func updateProp(view: UIView, key: String, value: Any?) {
+        guard let sw = view as? UISwitch else {
+            StyleEngine.apply(key: key, value: value, to: view)
+            return
+        }
+
+        switch key {
+        case "value":
+            let newValue: Bool
+            if let val = value as? Bool {
+                newValue = val
+            } else if let val = value as? Int {
+                newValue = val != 0
+            } else {
+                newValue = false
+            }
+            if sw.isOn != newValue {
+                sw.setOn(newValue, animated: true)
+            }
+
+        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
+            }
+
+        case "onTintColor":
+            if let colorStr = value as? String {
+                sw.onTintColor = UIColor.fromHex(colorStr)
+            } else {
+                sw.onTintColor = nil
+            }
+
+        case "thumbTintColor":
+            if let colorStr = value as? String {
+                sw.thumbTintColor = UIColor.fromHex(colorStr)
+            } else {
+                sw.thumbTintColor = nil
+            }
+
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: UIView, event: String, handler: @escaping (Any?) -> Void) {
+        guard let sw = view as? UISwitch, event == "change" else { return }
+
+        let proxy = SwitchActionProxy(handler: handler)
+        sw.addTarget(proxy, action: #selector(SwitchActionProxy.valueChanged(_:)), for: .valueChanged)
+        objc_setAssociatedObject(
+            sw,
+            &VSwitchFactory.changeHandlerKey,
+            proxy,
+            .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+        )
+    }
+
+    func removeEventListener(view: UIView, event: String) {
+        guard let sw = view as? UISwitch, event == "change" else { return }
+
+        if let proxy = objc_getAssociatedObject(sw, &VSwitchFactory.changeHandlerKey) as? SwitchActionProxy {
+            sw.removeTarget(proxy, action: #selector(SwitchActionProxy.valueChanged(_:)), for: .valueChanged)
+        }
+        objc_setAssociatedObject(sw, &VSwitchFactory.changeHandlerKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+}
+
+// MARK: - SwitchActionProxy
+
+/// Target-action proxy that routes UISwitch.valueChanged to a closure handler.
+/// Stored as an associated object on the UISwitch.
+final class SwitchActionProxy: NSObject {
+
+    let handler: (Any?) -> Void
+
+    init(handler: @escaping (Any?) -> Void) {
+        self.handler = handler
+    }
+
+    @objc func valueChanged(_ sender: UISwitch) {
+        handler(sender.isOn)
+    }
+}
+#endif

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

@@ -0,0 +1,290 @@
+#if canImport(UIKit)
+import UIKit
+import FlexLayout
+
+/// Factory for VText — the text display component.
+/// Maps to a UILabel with FlexLayout enabled.
+/// After any text or font change, calls flex.markDirty() to trigger Yoga remeasurement.
+final class VTextFactory: NativeComponentFactory {
+
+    // MARK: - Font weight mapping
+
+    /// Maps CSS-like font weight strings to UIFont.Weight values.
+    static let fontWeightMap: [String: UIFont.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
+
+    // MARK: - NativeComponentFactory
+
+    func createView() -> UIView {
+        let label = UILabel()
+        // Multi-line by default
+        label.numberOfLines = 0
+        // Accessing .flex automatically enables Yoga layout
+        _ = label.flex
+        return label
+    }
+
+    func updateProp(view: UIView, key: String, value: Any?) {
+        guard let label = view as? UILabel else { return }
+
+        switch key {
+        case "text":
+            if let text = value as? String {
+                label.text = text
+            } else {
+                label.text = nil
+            }
+            label.flex.markDirty()
+
+        case "numberOfLines":
+            if let lines = value as? Int {
+                label.numberOfLines = lines
+            } else if let lines = value as? Double {
+                label.numberOfLines = Int(lines)
+            } else {
+                label.numberOfLines = 0
+            }
+            label.flex.markDirty()
+
+        case "color":
+            if let colorStr = value as? String {
+                label.textColor = UIColor.fromHex(colorStr)
+            } else {
+                label.textColor = .label
+            }
+
+        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 = 17.0 // System default
+            }
+            storeFontSize(size, on: label)
+            rebuildFont(for: label)
+            label.flex.markDirty()
+
+        case "fontWeight":
+            if let str = value as? String {
+                storeFontWeight(str, on: label)
+            } else {
+                storeFontWeight(nil, on: label)
+            }
+            rebuildFont(for: label)
+            label.flex.markDirty()
+
+        case "fontFamily":
+            if let family = value as? String {
+                storeFontFamily(family, on: label)
+            } else {
+                storeFontFamily(nil, on: label)
+            }
+            rebuildFont(for: label)
+            label.flex.markDirty()
+
+        case "textAlign":
+            if let alignStr = value as? String {
+                label.textAlignment = VTextFactory.textAlignMap[alignStr] ?? .natural
+            } else {
+                label.textAlignment = .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 currentSize = label.font.pointSize
+                if str == "italic" {
+                    let descriptor = label.font.fontDescriptor.withSymbolicTraits(.traitItalic) ?? label.font.fontDescriptor
+                    label.font = UIFont(descriptor: descriptor, size: currentSize)
+                } else {
+                    var traits = label.font.fontDescriptor.symbolicTraits
+                    traits.remove(.traitItalic)
+                    if let descriptor = label.font.fontDescriptor.withSymbolicTraits(traits) {
+                        label.font = UIFont(descriptor: descriptor, size: currentSize)
+                    }
+                }
+            }
+            label.flex.markDirty()
+
+        case "lineHeight":
+            if let num = value as? Double {
+                let paragraphStyle = NSMutableParagraphStyle()
+                paragraphStyle.minimumLineHeight = CGFloat(num)
+                paragraphStyle.maximumLineHeight = CGFloat(num)
+                paragraphStyle.alignment = label.textAlignment
+                let text = label.text ?? ""
+                let attrs: [NSAttributedString.Key: Any] = [
+                    .paragraphStyle: paragraphStyle,
+                    .font: label.font as Any
+                ]
+                label.attributedText = NSAttributedString(string: text, attributes: attrs)
+                label.flex.markDirty()
+            }
+
+        case "letterSpacing":
+            if let num = value as? Double {
+                let text = label.text ?? ""
+                let attrs: [NSAttributedString.Key: Any] = [
+                    .kern: CGFloat(num),
+                    .font: label.font as Any
+                ]
+                label.attributedText = NSAttributedString(string: text, attributes: attrs)
+                label.flex.markDirty()
+            }
+
+        case "textDecorationLine":
+            if let str = value as? String {
+                let text = label.text ?? ""
+                var attrs: [NSAttributedString.Key: Any] = [.font: label.font as Any]
+                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.attributedText = NSAttributedString(string: text, attributes: attrs)
+                label.flex.markDirty()
+            }
+
+        case "textTransform":
+            if let str = value as? String {
+                let original = label.text ?? ""
+                switch str {
+                case "uppercase": label.text = original.uppercased()
+                case "lowercase": label.text = original.lowercased()
+                case "capitalize": label.text = original.capitalized
+                default: break
+                }
+                label.flex.markDirty()
+            }
+
+        default:
+            // Delegate unknown props to StyleEngine for layout/visual styling
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: UIView, event: String, handler: @escaping (Any?) -> Void) {
+        // Tap/press support via gesture recognizer.
+        if event == "press" {
+            let wrapper = GestureWrapper(handler: handler)
+            let tap = UITapGestureRecognizer(
+                target: wrapper,
+                action: #selector(GestureWrapper.handleGesture(_:))
+            )
+            view.addGestureRecognizer(tap)
+            view.isUserInteractionEnabled = true
+            GestureStorage.store(wrapper, for: view, event: event)
+        }
+    }
+
+    func removeEventListener(view: UIView, event: String) {
+        if event == "press" {
+            GestureStorage.remove(for: view, event: event)
+            view.gestureRecognizers?.forEach { recognizer in
+                if recognizer is UITapGestureRecognizer {
+                    view.removeGestureRecognizer(recognizer)
+                }
+            }
+        }
+    }
+
+    // MARK: - Font rebuilding
+
+    /// Rebuild the UIFont from stored fontSize, fontWeight, and fontFamily.
+    private func rebuildFont(for label: UILabel) {
+        let size = storedFontSize(on: label) ?? 17.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 = UIFont(name: family, size: size) {
+                label.font = customFont
+            } else {
+                // Fallback: try as a font descriptor family
+                let descriptor = UIFontDescriptor()
+                    .withFamily(family)
+                    .addingAttributes([.traits: [UIFontDescriptor.TraitKey.weight: weight]])
+                label.font = UIFont(descriptor: descriptor, size: size)
+            }
+        } else {
+            label.font = UIFont.systemFont(ofSize: size, weight: weight)
+        }
+    }
+
+    // MARK: - Font state storage via associated objects
+
+    private func storeFontSize(_ size: CGFloat, on view: UIView) {
+        objc_setAssociatedObject(view, &VTextFactory.fontSizeKey, size, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+
+    private func storedFontSize(on view: UIView) -> CGFloat? {
+        return objc_getAssociatedObject(view, &VTextFactory.fontSizeKey) as? CGFloat
+    }
+
+    private func storeFontWeight(_ weight: String?, on view: UIView) {
+        objc_setAssociatedObject(view, &VTextFactory.fontWeightKey, weight, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+
+    private func storedFontWeight(on view: UIView) -> String? {
+        return objc_getAssociatedObject(view, &VTextFactory.fontWeightKey) as? String
+    }
+
+    private func storeFontFamily(_ family: String?, on view: UIView) {
+        objc_setAssociatedObject(view, &VTextFactory.fontFamilyKey, family, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+
+    private func storedFontFamily(on view: UIView) -> String? {
+        return objc_getAssociatedObject(view, &VTextFactory.fontFamilyKey) as? String
+    }
+}
+#endif