@thelacanians/vue-native-cli 0.4.3 → 0.4.4

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

@@ -0,0 +1,153 @@
+#if canImport(UIKit)
+import UIKit
+import ObjectiveC
+import FlexLayout
+
+/// Factory for VRefreshControl — the pull-to-refresh indicator component.
+///
+/// Creates a lightweight UIView wrapper. When this view is inserted as a child
+/// of a UIScrollView (via VScrollView or VList), the factory attaches a
+/// UIRefreshControl to the parent scroll view's `.refreshControl` property.
+final class VRefreshControlFactory: NativeComponentFactory {
+
+    // MARK: - Associated object keys
+
+    private static var refreshControlKey: UInt8 = 0
+    private static var refreshTargetKey: UInt8 = 1
+    private static var refreshHandlerKey: UInt8 = 2
+
+    // MARK: - NativeComponentFactory
+
+    func createView() -> UIView {
+        // The wrapper view is zero-sized and invisible.
+        // The actual UIRefreshControl is attached to the parent scroll view.
+        let wrapper = UIView()
+        wrapper.isHidden = true
+        wrapper.frame = .zero
+
+        // Create the UIRefreshControl and store it on the wrapper
+        let refreshControl = UIRefreshControl()
+        objc_setAssociatedObject(
+            wrapper,
+            &VRefreshControlFactory.refreshControlKey,
+            refreshControl,
+            .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+        )
+
+        return wrapper
+    }
+
+    func updateProp(view: UIView, key: String, value: Any?) {
+        guard let refreshControl = objc_getAssociatedObject(
+            view,
+            &VRefreshControlFactory.refreshControlKey
+        ) as? UIRefreshControl else { return }
+
+        switch key {
+        case "refreshing":
+            let refreshing: Bool
+            if let b = value as? Bool { refreshing = b }
+            else if let n = value as? NSNumber { refreshing = n.boolValue }
+            else if let n = value as? Int { refreshing = n != 0 }
+            else { refreshing = false }
+
+            if refreshing {
+                refreshControl.beginRefreshing()
+            } else {
+                refreshControl.endRefreshing()
+            }
+
+        case "tintColor":
+            if let hex = value as? String {
+                refreshControl.tintColor = UIColor.fromHex(hex)
+            } else {
+                refreshControl.tintColor = nil
+            }
+
+        case "title":
+            if let text = value as? String {
+                refreshControl.attributedTitle = NSAttributedString(string: text)
+            } else {
+                refreshControl.attributedTitle = nil
+            }
+
+        default:
+            break
+        }
+    }
+
+    func addEventListener(view: UIView, event: String, handler: @escaping (Any?) -> Void) {
+        guard event == "refresh" else { return }
+        guard let refreshControl = objc_getAssociatedObject(
+            view,
+            &VRefreshControlFactory.refreshControlKey
+        ) as? UIRefreshControl else { return }
+
+        // Store handler reference
+        objc_setAssociatedObject(
+            view,
+            &VRefreshControlFactory.refreshHandlerKey,
+            handler as AnyObject,
+            .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+        )
+
+        // Create ObjC-compatible target
+        let target = RefreshControlTarget(handler: handler)
+        objc_setAssociatedObject(
+            view,
+            &VRefreshControlFactory.refreshTargetKey,
+            target,
+            .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+        )
+        refreshControl.addTarget(target, action: #selector(RefreshControlTarget.handleRefresh), for: .valueChanged)
+    }
+
+    func removeEventListener(view: UIView, event: String) {
+        guard event == "refresh" else { return }
+        guard let refreshControl = objc_getAssociatedObject(
+            view,
+            &VRefreshControlFactory.refreshControlKey
+        ) as? UIRefreshControl else { return }
+
+        refreshControl.removeTarget(nil, action: nil, for: .valueChanged)
+        objc_setAssociatedObject(view, &VRefreshControlFactory.refreshTargetKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+        objc_setAssociatedObject(view, &VRefreshControlFactory.refreshHandlerKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+
+    // MARK: - Child management
+
+    /// When inserted into a parent, attach the UIRefreshControl to the
+    /// nearest UIScrollView ancestor.
+    func insertChild(_ child: UIView, into parent: UIView, before anchor: UIView?) {
+        // Default: just add as subview (hidden, zero-frame)
+        if let anchor = anchor, let idx = parent.subviews.firstIndex(of: anchor) {
+            parent.insertSubview(child, at: idx)
+        } else {
+            parent.addSubview(child)
+        }
+    }
+
+    // MARK: - Static helpers
+
+    /// Retrieve the UIRefreshControl stored on a VRefreshControl wrapper view.
+    static func refreshControl(for view: UIView) -> UIRefreshControl? {
+        return objc_getAssociatedObject(view, &refreshControlKey) as? UIRefreshControl
+    }
+}
+
+// MARK: - RefreshControlTarget
+
+/// ObjC-compatible target for UIRefreshControl .valueChanged action.
+private final class RefreshControlTarget: NSObject {
+    private let handler: (Any?) -> Void
+
+    init(handler: @escaping (Any?) -> Void) {
+        self.handler = handler
+        super.init()
+    }
+
+    @objc func handleRefresh() {
+        handler(nil)
+    }
+}
+#endif

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

@@ -0,0 +1,56 @@
+#if canImport(UIKit)
+import UIKit
+import FlexLayout
+
+/// Factory for VSafeArea — a container that automatically applies safe area insets as padding.
+/// Maps content insets to Yoga padding so children avoid the notch/home indicator.
+final class VSafeAreaFactory: NativeComponentFactory {
+
+    func createView() -> UIView {
+        let view = SafeAreaView()
+        _ = view.flex
+        return view
+    }
+
+    func updateProp(view: UIView, key: String, value: Any?) {
+        StyleEngine.apply(key: key, value: value, to: view)
+    }
+
+    func addEventListener(view: UIView, event: String, handler: @escaping (Any?) -> Void) {}
+    func removeEventListener(view: UIView, event: String) {}
+}
+
+/// UIView subclass that applies safeAreaInsets as Yoga padding on every layout pass.
+final class SafeAreaView: UIView {
+
+    override func safeAreaInsetsDidChange() {
+        super.safeAreaInsetsDidChange()
+        applyInsets()
+    }
+
+    override func didMoveToWindow() {
+        super.didMoveToWindow()
+        applyInsets()
+    }
+
+    private func applyInsets() {
+        let insets = safeAreaInsets
+        flex.paddingTop(insets.top)
+        flex.paddingBottom(insets.bottom)
+        flex.paddingLeft(insets.left)
+        flex.paddingRight(insets.right)
+        // Trigger layout recalculation
+        if let root = findFlexRoot() {
+            root.flex.layout(mode: .fitContainer)
+        }
+    }
+
+    private func findFlexRoot() -> UIView? {
+        var v: UIView? = self
+        while let parent = v?.superview {
+            v = parent
+        }
+        return v
+    }
+}
+#endif

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

@@ -0,0 +1,240 @@
+#if canImport(UIKit)
+import UIKit
+import ObjectiveC
+import FlexLayout
+
+/// Factory for VScrollView — the scrollable container component.
+///
+/// Maps to UIScrollView on iOS. An inner `contentView` UIView is created as
+/// a subview and managed separately from the scroll view's Yoga node. All
+/// children reported by the bridge are inserted into the contentView, not
+/// the scroll view itself.
+///
+/// After each main layout pass, NativeBridge calls `layoutContentView(for:)`
+/// to compute the contentView's natural height (unconstrained) and update
+/// the scroll view's contentSize.
+final class VScrollViewFactory: NativeComponentFactory {
+
+    // MARK: - Associated object keys
+
+    static var contentViewKey: UInt8 = 0
+    static var delegateProxyKey: UInt8 = 1
+    static var onRefreshKey: UInt8 = 5
+    static var refreshTargetKey: UInt8 = 6
+
+    // MARK: - NativeComponentFactory
+
+    func createView() -> UIView {
+        let scrollView = UIScrollView()
+        scrollView.showsVerticalScrollIndicator = true
+        scrollView.showsHorizontalScrollIndicator = false
+        scrollView.alwaysBounceVertical = true
+        scrollView.clipsToBounds = true
+        _ = scrollView.flex
+
+        // Content view: children are added here so Yoga can measure
+        // their natural size without being constrained by the scroll view's bounds.
+        let contentView = UIView()
+        _ = contentView.flex
+        scrollView.addSubview(contentView)
+
+        objc_setAssociatedObject(
+            scrollView,
+            &VScrollViewFactory.contentViewKey,
+            contentView,
+            .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+        )
+
+        return scrollView
+    }
+
+    func updateProp(view: UIView, key: String, value: Any?) {
+        guard let scrollView = view as? UIScrollView else {
+            StyleEngine.apply(key: key, value: value, to: view)
+            return
+        }
+
+        switch key {
+        case "horizontal":
+            let horizontal: Bool
+            if let h = value as? Bool { horizontal = h }
+            else if let h = value as? Int { horizontal = h != 0 }
+            else { horizontal = false }
+            scrollView.alwaysBounceHorizontal = horizontal
+            scrollView.alwaysBounceVertical = !horizontal
+
+        case "showsVerticalScrollIndicator":
+            if let shows = value as? Bool { scrollView.showsVerticalScrollIndicator = shows }
+
+        case "showsHorizontalScrollIndicator":
+            if let shows = value as? Bool { scrollView.showsHorizontalScrollIndicator = shows }
+
+        case "scrollEnabled":
+            if let enabled = value as? Bool { scrollView.isScrollEnabled = enabled }
+            else if let enabled = value as? Int { scrollView.isScrollEnabled = enabled != 0 }
+
+        case "bounces":
+            if let bounces = value as? Bool { scrollView.bounces = bounces }
+
+        case "pagingEnabled":
+            if let paging = value as? Bool { scrollView.isPagingEnabled = paging }
+
+        case "refreshing":
+            let refreshing: Bool
+            if let b = value as? Bool { refreshing = b }
+            else if let n = value as? NSNumber { refreshing = n.boolValue }
+            else { refreshing = false }
+
+            if refreshing {
+                // Add UIRefreshControl if not already present
+                if scrollView.refreshControl == nil {
+                    let control = UIRefreshControl()
+                    scrollView.refreshControl = control
+                }
+                scrollView.refreshControl?.beginRefreshing()
+            } else {
+                scrollView.refreshControl?.endRefreshing()
+            }
+
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: UIView, event: String, handler: @escaping (Any?) -> Void) {
+        guard let scrollView = view as? UIScrollView else { return }
+        switch event {
+        case "scroll":
+            let proxy = ScrollDelegateProxy(handler: handler)
+            objc_setAssociatedObject(
+                scrollView,
+                &VScrollViewFactory.delegateProxyKey,
+                proxy,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+            scrollView.delegate = proxy
+        case "refresh":
+            // Store the handler
+            objc_setAssociatedObject(
+                scrollView,
+                &VScrollViewFactory.onRefreshKey,
+                handler as AnyObject,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+            // Create UIRefreshControl if not already present
+            if scrollView.refreshControl == nil {
+                scrollView.refreshControl = UIRefreshControl()
+            }
+            guard let refreshControl = scrollView.refreshControl else { break }
+            // Create a target helper and store it
+            let target = RefreshTarget(handler: handler)
+            objc_setAssociatedObject(
+                scrollView,
+                &VScrollViewFactory.refreshTargetKey,
+                target,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+            refreshControl.addTarget(target, action: #selector(RefreshTarget.handleRefresh), for: .valueChanged)
+
+        default:
+            break
+        }
+    }
+
+    func removeEventListener(view: UIView, event: String) {
+        guard let scrollView = view as? UIScrollView, event == "scroll" else { return }
+        scrollView.delegate = nil
+        objc_setAssociatedObject(
+            scrollView,
+            &VScrollViewFactory.delegateProxyKey,
+            nil,
+            .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+        )
+    }
+
+    // MARK: - Child management
+
+    func insertChild(_ child: UIView, into parent: UIView, before anchor: UIView?) {
+        if let anchor = anchor, let idx = parent.subviews.firstIndex(of: anchor) {
+            parent.insertSubview(child, at: idx)
+        } else {
+            parent.addSubview(child)
+        }
+        // Ensure content size is recalculated after child insertion
+        if let scrollView = parent.superview as? UIScrollView {
+            scrollView.setNeedsLayout()
+        }
+    }
+
+    func removeChild(_ child: UIView, from parent: UIView) {
+        child.removeFromSuperview()
+        // Ensure content size is recalculated after child removal
+        if let scrollView = parent.superview as? UIScrollView {
+            scrollView.setNeedsLayout()
+        }
+    }
+
+    // MARK: - Static helpers
+
+    /// Retrieve the inner content UIView for a scroll view.
+    /// NativeBridge calls this to redirect child insertions.
+    static func contentView(for scrollView: UIScrollView) -> UIView? {
+        return objc_getAssociatedObject(scrollView, &contentViewKey) as? UIView
+    }
+
+    /// Recompute the content view's layout and update the scroll view's contentSize.
+    /// Call this after the main Yoga layout pass, once the scroll view's frame is set.
+    @MainActor
+    static func layoutContentView(for scrollView: UIScrollView) {
+        guard let contentView = contentView(for: scrollView) else { return }
+
+        let scrollWidth = scrollView.bounds.width
+        guard scrollWidth > 0 else { return }
+
+        // Pin the content view's origin and width
+        contentView.frame = CGRect(x: 0, y: 0, width: scrollWidth, height: 0)
+
+        // Compute natural height — adjustHeight mode grows height to fit children
+        contentView.flex.layout(mode: .adjustHeight)
+
+        // Update the scroll view's scrollable content size
+        scrollView.contentSize = contentView.frame.size
+    }
+}
+
+// MARK: - RefreshTarget
+
+/// ObjC-compatible target for UIRefreshControl value-changed actions.
+private final class RefreshTarget: NSObject {
+    private let handler: (Any?) -> Void
+
+    init(handler: @escaping (Any?) -> Void) {
+        self.handler = handler
+        super.init()
+    }
+
+    @objc func handleRefresh() {
+        handler(nil)
+    }
+}
+
+// MARK: - ScrollDelegateProxy
+
+/// UIScrollViewDelegate proxy that forwards scroll events to a JS handler.
+private final class ScrollDelegateProxy: NSObject, UIScrollViewDelegate {
+    private let handler: (Any?) -> Void
+
+    init(handler: @escaping (Any?) -> Void) {
+        self.handler = handler
+        super.init()
+    }
+
+    func scrollViewDidScroll(_ scrollView: UIScrollView) {
+        let payload: [String: Any] = [
+            "x": scrollView.contentOffset.x,
+            "y": scrollView.contentOffset.y
+        ]
+        handler(payload)
+    }
+}
+#endif

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

@@ -0,0 +1,248 @@
+#if canImport(UIKit)
+import UIKit
+import FlexLayout
+
+// MARK: - VSectionListFactory
+
+/// Factory for VSectionList — a sectioned list backed by UITableView with section support.
+/// Children with `__sectionHeader` prop are treated as section headers.
+/// All other children are treated as regular items, grouped under the preceding header.
+final class VSectionListFactory: NativeComponentFactory {
+
+    func createView() -> UIView {
+        let container = VSectionListContainerView()
+        _ = container.flex
+        return container
+    }
+
+    func updateProp(view: UIView, key: String, value: Any?) {
+        guard let container = view as? VSectionListContainerView else {
+            StyleEngine.apply(key: key, value: value, to: view)
+            return
+        }
+        switch key {
+        case "estimatedItemHeight":
+            container.estimatedItemHeight = CGFloat(value as? Double ?? 44)
+        case "stickySectionHeaders":
+            // plain style = sticky headers (default), grouped = non-sticky
+            // This is set at creation time; we store the preference for reference
+            container.stickySectionHeaders = value as? Bool ?? true
+        case "showsScrollIndicator":
+            container.tableView.showsVerticalScrollIndicator = value as? Bool ?? true
+        case "bounces":
+            container.tableView.bounces = value as? Bool ?? true
+        default:
+            StyleEngine.apply(key: key, value: value, to: view)
+        }
+    }
+
+    func addEventListener(view: UIView, event: String, handler: @escaping (Any?) -> Void) {
+        guard let container = view as? VSectionListContainerView else { return }
+        switch event {
+        case "scroll":
+            container.onScroll = handler
+        case "endReached":
+            container.onEndReached = handler
+        default:
+            break
+        }
+    }
+
+    func removeEventListener(view: UIView, event: String) {
+        guard let container = view as? VSectionListContainerView else { return }
+        switch event {
+        case "scroll": container.onScroll = nil
+        case "endReached": container.onEndReached = nil
+        default: break
+        }
+    }
+
+    // MARK: - Custom child management
+
+    func insertChild(_ child: UIView, into parent: UIView, before anchor: UIView?) {
+        guard let container = parent as? VSectionListContainerView else {
+            if let anchor = anchor, let idx = parent.subviews.firstIndex(of: anchor) {
+                parent.insertSubview(child, at: idx)
+            } else {
+                parent.addSubview(child)
+            }
+            return
+        }
+        container.allChildren.append(child)
+        container.rebuildSections()
+        container.tableView.reloadData()
+    }
+
+    func removeChild(_ child: UIView, from parent: UIView) {
+        guard let container = parent as? VSectionListContainerView else {
+            child.removeFromSuperview()
+            return
+        }
+        container.allChildren.removeAll { $0 === child }
+        child.removeFromSuperview()
+        container.rebuildSections()
+        container.tableView.reloadData()
+    }
+}
+
+// MARK: - SectionData
+
+/// Represents a section: an optional header view and an array of item views.
+private struct SectionData {
+    var headerView: UIView?
+    var itemViews: [UIView]
+}
+
+// MARK: - VSectionListContainerView
+
+/// Container view that hosts a UITableView with section support.
+final class VSectionListContainerView: UIView {
+
+    let tableView: UITableView
+    var allChildren: [UIView] = []
+    var estimatedItemHeight: CGFloat = 44
+    var stickySectionHeaders: Bool = true
+    var onScroll: ((Any?) -> Void)?
+    var onEndReached: ((Any?) -> Void)?
+    fileprivate var firedEndReached = false
+    fileprivate var sections: [SectionData] = []
+    private lazy var internalDelegate = VSectionListInternalDelegate(container: self)
+
+    init() {
+        tableView = UITableView(frame: .zero, style: .plain)
+        super.init(frame: .zero)
+        tableView.separatorStyle = .none
+        tableView.tableFooterView = UIView()
+        tableView.dataSource = internalDelegate
+        tableView.delegate = internalDelegate
+        tableView.register(VListCell.self, forCellReuseIdentifier: "VListCell")
+        super.addSubview(tableView)
+    }
+
+    required init?(coder: NSCoder) { fatalError() }
+
+    /// Rebuild section data from the flat allChildren array.
+    /// Children that had the `__sectionHeader: true` prop set via the bridge start a new section.
+    func rebuildSections() {
+        sections = []
+        var currentSection = SectionData(headerView: nil, itemViews: [])
+
+        for child in allChildren {
+            let isSectionHeader = StyleEngine.getInternalProp("__sectionHeader", from: child) as? Bool ?? false
+            if isSectionHeader {
+                // Finalize previous section if it has items or a header
+                if currentSection.headerView != nil || !currentSection.itemViews.isEmpty {
+                    sections.append(currentSection)
+                }
+                currentSection = SectionData(headerView: child, itemViews: [])
+            } else {
+                currentSection.itemViews.append(child)
+            }
+        }
+        // Finalize last section
+        if currentSection.headerView != nil || !currentSection.itemViews.isEmpty {
+            sections.append(currentSection)
+        }
+    }
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        tableView.frame = bounds
+
+        let width = bounds.width
+        guard width > 0 else { return }
+
+        // Lay out all child views for height calculation
+        for child in allChildren {
+            if abs(child.frame.size.width - width) > 0.5 {
+                child.frame.size.width = width
+                child.flex.layout(mode: .adjustHeight)
+            }
+        }
+        tableView.reloadData()
+    }
+}
+
+// MARK: - VSectionListInternalDelegate
+
+private final class VSectionListInternalDelegate: NSObject,
+    UITableViewDataSource, UITableViewDelegate
+{
+    private weak var container: VSectionListContainerView?
+
+    init(container: VSectionListContainerView) {
+        self.container = container
+    }
+
+    func numberOfSections(in tableView: UITableView) -> Int {
+        container?.sections.count ?? 0
+    }
+
+    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
+        guard let container = container, section < container.sections.count else { return 0 }
+        return container.sections[section].itemViews.count
+    }
+
+    func tableView(_ tableView: UITableView,
+                   cellForRowAt indexPath: IndexPath) -> UITableViewCell {
+        let cell = tableView.dequeueReusableCell(
+            withIdentifier: "VListCell", for: indexPath) as! VListCell
+        guard let container = container,
+              indexPath.section < container.sections.count,
+              indexPath.row < container.sections[indexPath.section].itemViews.count else { return cell }
+        cell.setItemView(container.sections[indexPath.section].itemViews[indexPath.row])
+        return cell
+    }
+
+    func tableView(_ tableView: UITableView,
+                   viewForHeaderInSection section: Int) -> UIView? {
+        guard let container = container, section < container.sections.count else { return nil }
+        return container.sections[section].headerView
+    }
+
+    func tableView(_ tableView: UITableView,
+                   heightForHeaderInSection section: Int) -> CGFloat {
+        guard let container = container, section < container.sections.count,
+              let header = container.sections[section].headerView else { return 0 }
+        let h = header.frame.size.height
+        return h > 1 ? h : container.estimatedItemHeight
+    }
+
+    func tableView(_ tableView: UITableView,
+                   estimatedHeightForRowAt indexPath: IndexPath) -> CGFloat {
+        container?.estimatedItemHeight ?? 44
+    }
+
+    func tableView(_ tableView: UITableView,
+                   heightForRowAt indexPath: IndexPath) -> CGFloat {
+        guard let container = container,
+              indexPath.section < container.sections.count,
+              indexPath.row < container.sections[indexPath.section].itemViews.count else {
+            return container?.estimatedItemHeight ?? 44
+        }
+        let h = container.sections[indexPath.section].itemViews[indexPath.row].frame.size.height
+        return h > 1 ? h : (container?.estimatedItemHeight ?? 44)
+    }
+
+    func scrollViewDidScroll(_ scrollView: UIScrollView) {
+        guard let container = container else { return }
+        let offset = scrollView.contentOffset
+        container.onScroll?(["x": Double(offset.x), "y": Double(offset.y)])
+
+        let contentH = scrollView.contentSize.height
+        let frameH = scrollView.frame.size.height
+        guard contentH > frameH else { return }
+        let distanceFromBottom = contentH - frameH - offset.y
+        let threshold = frameH * 0.2
+
+        if distanceFromBottom < threshold && !container.firedEndReached {
+            container.firedEndReached = true
+            container.onEndReached?(nil)
+        } else if distanceFromBottom >= threshold {
+            container.firedEndReached = false
+        }
+    }
+}
+
+// Reuses VListCell from VListFactory (same module)
+#endif