@thelacanians/vue-native-cli 0.4.3 → 0.4.5

package/native/ios/VueNativeCore/Sources/VueNativeCore/Helpers/GestureWrapper.swift

@@ -0,0 +1,107 @@
+#if canImport(UIKit)
+import UIKit
+
+/// ObjC-compatible wrapper for gesture recognizer action handlers.
+/// Allows attaching Swift closure-based event handlers to UIGestureRecognizers
+/// that require an @objc selector target.
+@objc final class GestureWrapper: NSObject {
+
+    private let handler: (Any?) -> Void
+
+    init(handler: @escaping (Any?) -> Void) {
+        self.handler = handler
+        super.init()
+    }
+
+    @objc func handleGesture(_ gesture: UIGestureRecognizer) {
+        handler(nil)
+    }
+
+    @objc func handleGestureWithState(_ gesture: UIGestureRecognizer) {
+        let payload: [String: Any] = [
+            "state": gesture.state.rawValue,
+            "locationX": gesture.location(in: gesture.view).x,
+            "locationY": gesture.location(in: gesture.view).y
+        ]
+        handler(payload)
+    }
+}
+
+// MARK: - PanWrapper
+
+/// ObjC-compatible wrapper for UIPanGestureRecognizer action handlers.
+@objc final class PanWrapper: NSObject {
+    private let handler: (Any?) -> Void
+
+    init(handler: @escaping (Any?) -> Void) {
+        self.handler = handler
+        super.init()
+    }
+
+    @objc func handle(_ recognizer: UIPanGestureRecognizer) {
+        guard let view = recognizer.view else { return }
+        let translation = recognizer.translation(in: view.superview)
+        let velocity = recognizer.velocity(in: view.superview)
+        let stateStr: String
+        switch recognizer.state {
+        case .began:            stateStr = "began"
+        case .changed:          stateStr = "changed"
+        case .ended:            stateStr = "ended"
+        case .cancelled, .failed: stateStr = "cancelled"
+        default:                stateStr = "unknown"
+        }
+        handler([
+            "translationX": translation.x,
+            "translationY": translation.y,
+            "velocityX": velocity.x,
+            "velocityY": velocity.y,
+            "state": stateStr
+        ] as [String: Any])
+    }
+}
+
+// MARK: - SwipeWrapper
+
+/// ObjC-compatible wrapper for UISwipeGestureRecognizer action handlers.
+@objc final class SwipeWrapper: NSObject {
+    private let handler: (Any?) -> Void
+    private let direction: String
+
+    init(handler: @escaping (Any?) -> Void, direction: String) {
+        self.handler = handler
+        self.direction = direction
+        super.init()
+    }
+
+    @objc func handle(_ recognizer: UISwipeGestureRecognizer) {
+        handler(["direction": direction] as [String: Any])
+    }
+}
+
+// MARK: - PinchWrapper
+
+/// ObjC-compatible wrapper for UIPinchGestureRecognizer action handlers.
+@objc final class PinchWrapper: NSObject {
+    private let handler: (Any?) -> Void
+
+    init(handler: @escaping (Any?) -> Void) {
+        self.handler = handler
+        super.init()
+    }
+
+    @objc func handle(_ recognizer: UIPinchGestureRecognizer) {
+        let stateStr: String
+        switch recognizer.state {
+        case .began:    stateStr = "began"
+        case .changed:  stateStr = "changed"
+        case .ended:    stateStr = "ended"
+        default:        stateStr = "cancelled"
+        }
+        handler([
+            "scale": recognizer.scale,
+            "velocity": recognizer.velocity,
+            "state": stateStr
+        ] as [String: Any])
+    }
+}
+#endif

package/native/ios/VueNativeCore/Sources/VueNativeCore/Helpers/TouchableView.swift

@@ -0,0 +1,136 @@
+#if canImport(UIKit)
+import UIKit
+
+/// Custom UIView subclass that provides button-like touch behavior
+/// with configurable active opacity and support for press and long press events.
+class TouchableView: UIView {
+
+    // MARK: - Public properties
+
+    /// The opacity to apply when the user is pressing the view.
+    var activeOpacity: CGFloat = 0.7
+
+    /// Called when a tap completes within the view bounds.
+    var onPress: (() -> Void)?
+
+    /// Called when a long press gesture is recognized.
+    var onLongPress: (() -> Void)?
+
+    /// Whether touch interactions are disabled.
+    var isDisabled: Bool = false {
+        didSet {
+            isUserInteractionEnabled = !isDisabled
+            alpha = isDisabled ? 0.4 : 1.0
+        }
+    }
+
+    // MARK: - Private properties
+
+    private var longPressRecognizer: UILongPressGestureRecognizer?
+    private var isTouchInside: Bool = false
+
+    // MARK: - Initialization
+
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        setupLongPressRecognizer()
+    }
+
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        setupLongPressRecognizer()
+    }
+
+    // MARK: - Touch handling
+
+    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
+        super.touchesBegan(touches, with: event)
+        guard !isDisabled else { return }
+
+        isTouchInside = true
+        UIView.animate(
+            withDuration: 0.1,
+            delay: 0,
+            options: [.beginFromCurrentState, .allowUserInteraction],
+            animations: { [weak self] in
+                guard let self = self else { return }
+                self.alpha = self.activeOpacity
+            }
+        )
+    }
+
+    override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {
+        super.touchesMoved(touches, with: event)
+        guard !isDisabled, let touch = touches.first else { return }
+
+        let location = touch.location(in: self)
+        let wasInside = isTouchInside
+        isTouchInside = bounds.contains(location)
+
+        if wasInside != isTouchInside {
+            UIView.animate(
+                withDuration: 0.1,
+                delay: 0,
+                options: [.beginFromCurrentState, .allowUserInteraction],
+                animations: { [weak self] in
+                    guard let self = self else { return }
+                    self.alpha = self.isTouchInside ? self.activeOpacity : 1.0
+                }
+            )
+        }
+    }
+
+    override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {
+        super.touchesEnded(touches, with: event)
+        guard !isDisabled else { return }
+
+        UIView.animate(
+            withDuration: 0.15,
+            delay: 0,
+            options: [.beginFromCurrentState, .allowUserInteraction],
+            animations: { [weak self] in
+                self?.alpha = 1.0
+            }
+        )
+
+        if isTouchInside {
+            onPress?()
+        }
+        isTouchInside = false
+    }
+
+    override func touchesCancelled(_ touches: Set<UITouch>, with event: UIEvent?) {
+        super.touchesCancelled(touches, with: event)
+        guard !isDisabled else { return }
+
+        UIView.animate(
+            withDuration: 0.15,
+            delay: 0,
+            options: [.beginFromCurrentState, .allowUserInteraction],
+            animations: { [weak self] in
+                self?.alpha = 1.0
+            }
+        )
+        isTouchInside = false
+    }
+
+    // MARK: - Long press
+
+    private func setupLongPressRecognizer() {
+        let recognizer = UILongPressGestureRecognizer(
+            target: self,
+            action: #selector(handleLongPress(_:))
+        )
+        recognizer.minimumPressDuration = 0.5
+        addGestureRecognizer(recognizer)
+        longPressRecognizer = recognizer
+    }
+
+    @objc private func handleLongPress(_ recognizer: UILongPressGestureRecognizer) {
+        guard !isDisabled else { return }
+        if recognizer.state == .began {
+            onLongPress?()
+        }
+    }
+}
+#endif

package/native/ios/VueNativeCore/Sources/VueNativeCore/Helpers/UIColor+Hex.swift

@@ -0,0 +1,80 @@
+#if canImport(UIKit)
+import UIKit
+
+extension UIColor {
+
+    // MARK: - Named color lookup
+
+    private static let namedColors: [String: UIColor] = [
+        "transparent": .clear,
+        "black": .black,
+        "white": .white,
+        "red": .red,
+        "green": .green,
+        "blue": .blue,
+        "gray": .gray,
+        "grey": .gray,
+        "orange": .orange,
+        "yellow": .yellow,
+        "purple": .purple,
+        "cyan": .cyan,
+        "magenta": .magenta,
+        "brown": .brown
+    ]
+
+    // MARK: - Hex initializer
+
+    /// Creates a UIColor from a hex string.
+    /// Supports formats: "#RGB", "#RRGGBB", "#RRGGBBAA"
+    /// Also supports named colors: "transparent", "black", "white", "red", "green", "blue", "gray"
+    /// Returns .clear for invalid input.
+    static func fromHex(_ hex: String) -> UIColor {
+        let trimmed = hex.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+
+        // Check named colors first
+        if let named = namedColors[trimmed] {
+            return named
+        }
+
+        // Must start with '#'
+        guard trimmed.hasPrefix("#") else {
+            return .clear
+        }
+
+        let hexString = String(trimmed.dropFirst())
+        let scanner = Scanner(string: hexString)
+        var hexNumber: UInt64 = 0
+
+        guard scanner.scanHexInt64(&hexNumber) else {
+            return .clear
+        }
+
+        switch hexString.count {
+        case 3:
+            // #RGB -> #RRGGBB
+            let r = CGFloat((hexNumber & 0xF00) >> 8) / 15.0
+            let g = CGFloat((hexNumber & 0x0F0) >> 4) / 15.0
+            let b = CGFloat(hexNumber & 0x00F) / 15.0
+            return UIColor(red: r, green: g, blue: b, alpha: 1.0)
+
+        case 6:
+            // #RRGGBB
+            let r = CGFloat((hexNumber & 0xFF0000) >> 16) / 255.0
+            let g = CGFloat((hexNumber & 0x00FF00) >> 8) / 255.0
+            let b = CGFloat(hexNumber & 0x0000FF) / 255.0
+            return UIColor(red: r, green: g, blue: b, alpha: 1.0)
+
+        case 8:
+            // #RRGGBBAA
+            let r = CGFloat((hexNumber & 0xFF000000) >> 24) / 255.0
+            let g = CGFloat((hexNumber & 0x00FF0000) >> 16) / 255.0
+            let b = CGFloat((hexNumber & 0x0000FF00) >> 8) / 255.0
+            let a = CGFloat(hexNumber & 0x000000FF) / 255.0
+            return UIColor(red: r, green: g, blue: b, alpha: a)
+
+        default:
+            return .clear
+        }
+    }
+}
+#endif

package/native/ios/VueNativeCore/Sources/VueNativeCore/Modules/AnimationModule.swift

@@ -0,0 +1,283 @@
+#if canImport(UIKit)
+import UIKit
+
+/// Native module for UIView animations.
+/// Exposes timing, spring, keyframe, sequence, and parallel animations to JS composables.
+final class AnimationModule: NativeModule {
+
+    let moduleName = "Animation"
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        switch method {
+        case "timing":
+            handleTiming(args: args, callback: callback)
+        case "spring":
+            handleSpring(args: args, callback: callback)
+        case "keyframe":
+            guard let viewId = args[safe: 0] as? Int,
+                  let keyframesData = args[safe: 1] as? [[String: Any]],
+                  let options = args[safe: 2] as? [String: Any] else {
+                callback(nil, "Invalid args"); return
+            }
+            let duration = options["duration"] as? Double ?? 300
+            animateKeyframes(viewId: viewId, keyframes: keyframesData, duration: duration / 1000.0, callback: callback)
+        case "sequence":
+            guard let animationsData = args[safe: 0] as? [[String: Any]] else {
+                callback(nil, "Invalid args"); return
+            }
+            runSequence(animationsData: animationsData, index: 0, callback: callback)
+        case "parallel":
+            guard let animationsData = args[safe: 0] as? [[String: Any]] else {
+                callback(nil, "Invalid args"); return
+            }
+            runParallel(animationsData: animationsData, callback: callback)
+        default:
+            callback(nil, "AnimationModule: unknown method '\(method)'")
+        }
+    }
+
+    func invokeSync(method: String, args: [Any]) -> Any? {
+        return nil
+    }
+
+    // MARK: - timing(viewId, styles, options)
+    // args[0]: Int (viewId)
+    // args[1]: [String: Any] (target styles, only numeric values like opacity, transform offsets)
+    // args[2]: [String: Any] (options: duration, delay, easing)
+
+    private func handleTiming(args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        guard let viewId = args.first.flatMap({ $0 as? Int ?? ($0 as? Double).map(Int.init) }),
+              let styles = args.count > 1 ? args[1] as? [String: Any] : [:] else {
+            callback(nil, "timing: invalid arguments")
+            return
+        }
+
+        let options = args.count > 2 ? (args[2] as? [String: Any] ?? [:]) : [:]
+        let duration = (options["duration"] as? Double ?? 300) / 1000.0
+        let delay = (options["delay"] as? Double ?? 0) / 1000.0
+        let easing = options["easing"] as? String ?? "ease"
+
+        let curve: UIView.AnimationOptions
+        switch easing {
+        case "linear": curve = .curveLinear
+        case "ease-in", "easeIn": curve = .curveEaseIn
+        case "ease-out", "easeOut": curve = .curveEaseOut
+        default: curve = .curveEaseInOut
+        }
+
+        DispatchQueue.main.async {
+            MainActor.assumeIsolated {
+                guard let view = NativeBridge.shared.view(forId: viewId) else {
+                    callback(nil, "timing: view \(viewId) not found")
+                    return
+                }
+
+                UIView.animate(
+                    withDuration: duration,
+                    delay: delay,
+                    options: [curve],
+                    animations: { [styles] in
+                        MainActor.assumeIsolated {
+                            for (key, value) in styles {
+                                StyleEngine.apply(key: key, value: value, to: view)
+                            }
+                        }
+                    },
+                    completion: { _ in
+                        callback(true, nil)
+                    }
+                )
+            }
+        }
+    }
+
+    // MARK: - spring(viewId, styles, options)
+    // args[0]: Int (viewId)
+    // args[1]: [String: Any] (target styles)
+    // args[2]: [String: Any] (options: damping, stiffness/duration, mass)
+
+    private func handleSpring(args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        guard let viewId = args.first.flatMap({ $0 as? Int ?? ($0 as? Double).map(Int.init) }),
+              let styles = args.count > 1 ? args[1] as? [String: Any] : [:] else {
+            callback(nil, "spring: invalid arguments")
+            return
+        }
+
+        let options = args.count > 2 ? (args[2] as? [String: Any] ?? [:]) : [:]
+        let damping = CGFloat(options["damping"] as? Double ?? 0.7)
+        let duration = (options["duration"] as? Double ?? 500) / 1000.0
+        let delay = (options["delay"] as? Double ?? 0) / 1000.0
+
+        DispatchQueue.main.async {
+            MainActor.assumeIsolated {
+                guard let view = NativeBridge.shared.view(forId: viewId) else {
+                    callback(nil, "spring: view \(viewId) not found")
+                    return
+                }
+
+                UIView.animate(
+                    withDuration: duration,
+                    delay: delay,
+                    usingSpringWithDamping: damping,
+                    initialSpringVelocity: 0,
+                    options: [],
+                    animations: { [styles] in
+                        MainActor.assumeIsolated {
+                            for (key, value) in styles {
+                                StyleEngine.apply(key: key, value: value, to: view)
+                            }
+                        }
+                    },
+                    completion: { _ in
+                        callback(true, nil)
+                    }
+                )
+            }
+        }
+    }
+
+    // MARK: - keyframe(viewId, keyframes, options)
+
+    private func animateKeyframes(viewId: Int, keyframes: [[String: Any]], duration: TimeInterval, callback: @escaping (Any?, String?) -> Void) {
+        DispatchQueue.main.async {
+            guard let view = NativeBridge.shared.view(forId: viewId) else {
+                callback(nil, "View not found for id \(viewId)"); return
+            }
+
+            // Build CAKeyframeAnimation for each animated property
+            // Group them with CAAnimationGroup
+            let group = CAAnimationGroup()
+            group.duration = duration
+            group.fillMode = .forwards
+            group.isRemovedOnCompletion = false
+
+            var animations: [CAAnimation] = []
+
+            // Collect all property names from keyframes
+            var propertyKeys = Set<String>()
+            for kf in keyframes { propertyKeys.formUnion(kf.keys.filter { $0 != "offset" }) }
+
+            for propKey in propertyKeys {
+                let keyPath: String
+                var values: [Any] = []
+                var keyTimes: [NSNumber] = []
+
+                switch propKey {
+                case "opacity":
+                    keyPath = "opacity"
+                    for kf in keyframes {
+                        if let v = kf[propKey] as? Double {
+                            values.append(v)
+                            keyTimes.append(NSNumber(value: kf["offset"] as? Double ?? 0))
+                        }
+                    }
+                case "translateX":
+                    keyPath = "transform.translation.x"
+                    for kf in keyframes {
+                        if let v = kf[propKey] as? Double {
+                            values.append(v)
+                            keyTimes.append(NSNumber(value: kf["offset"] as? Double ?? 0))
+                        }
+                    }
+                case "translateY":
+                    keyPath = "transform.translation.y"
+                    for kf in keyframes {
+                        if let v = kf[propKey] as? Double {
+                            values.append(v)
+                            keyTimes.append(NSNumber(value: kf["offset"] as? Double ?? 0))
+                        }
+                    }
+                case "scale", "scaleX":
+                    keyPath = "transform.scale.x"
+                    for kf in keyframes {
+                        if let v = kf[propKey] as? Double {
+                            values.append(v)
+                            keyTimes.append(NSNumber(value: kf["offset"] as? Double ?? 0))
+                        }
+                    }
+                case "scaleY":
+                    keyPath = "transform.scale.y"
+                    for kf in keyframes {
+                        if let v = kf[propKey] as? Double {
+                            values.append(v)
+                            keyTimes.append(NSNumber(value: kf["offset"] as? Double ?? 0))
+                        }
+                    }
+                default:
+                    continue
+                }
+
+                if !values.isEmpty {
+                    let anim = CAKeyframeAnimation(keyPath: keyPath)
+                    anim.values = values
+                    anim.keyTimes = keyTimes
+                    anim.duration = duration
+                    animations.append(anim)
+                }
+            }
+
+            if animations.isEmpty { callback(nil, nil); return }
+            group.animations = animations
+
+            CATransaction.begin()
+            CATransaction.setCompletionBlock { callback(nil, nil) }
+            view.layer.add(group, forKey: "keyframeAnimation")
+            CATransaction.commit()
+        }
+    }
+
+    // MARK: - sequence([animData])
+
+    private func runSequence(animationsData: [[String: Any]], index: Int, callback: @escaping (Any?, String?) -> Void) {
+        guard index < animationsData.count else { callback(nil, nil); return }
+        let animData = animationsData[index]
+        let method = animData["type"] as? String ?? "timing"
+        let viewId = animData["viewId"] as? Int ?? 0
+        let toStyles = animData["toStyles"] as? [String: Any] ?? [:]
+        let options = animData["options"] as? [String: Any] ?? [:]
+
+        runSingleAnimation(method: method, viewId: viewId, toStyles: toStyles, options: options) { [weak self] _, error in
+            if let error = error { callback(nil, error); return }
+            self?.runSequence(animationsData: animationsData, index: index + 1, callback: callback)
+        }
+    }
+
+    private func runSingleAnimation(method: String, viewId: Int, toStyles: [String: Any], options: [String: Any], callback: @escaping (Any?, String?) -> Void) {
+        switch method {
+        case "timing":
+            let argsArr: [Any] = [viewId, toStyles, options]
+            invoke(method: "timing", args: argsArr, callback: callback)
+        case "spring":
+            let argsArr: [Any] = [viewId, toStyles, options]
+            invoke(method: "spring", args: argsArr, callback: callback)
+        default:
+            callback(nil, "Unknown animation type: \(method)")
+        }
+    }
+
+    // MARK: - parallel([animData])
+
+    private func runParallel(animationsData: [[String: Any]], callback: @escaping (Any?, String?) -> Void) {
+        guard !animationsData.isEmpty else { callback(nil, nil); return }
+        let total = animationsData.count
+        var completed = 0
+        let lock = NSLock()
+
+        for animData in animationsData {
+            let method = animData["type"] as? String ?? "timing"
+            let viewId = animData["viewId"] as? Int ?? 0
+            let toStyles = animData["toStyles"] as? [String: Any] ?? [:]
+            let options = animData["options"] as? [String: Any] ?? [:]
+
+            runSingleAnimation(method: method, viewId: viewId, toStyles: toStyles, options: options) { _, _ in
+                lock.lock()
+                completed += 1
+                let allDone = completed == total
+                lock.unlock()
+                if allDone { callback(nil, nil) }
+            }
+        }
+    }
+}
+
+#endif

package/native/ios/VueNativeCore/Sources/VueNativeCore/Modules/AppStateModule.swift

@@ -0,0 +1,59 @@
+#if canImport(UIKit)
+import UIKit
+
+final class AppStateModule: NSObject, NativeModule {
+    var moduleName: String { "AppState" }
+    private weak var bridge: NativeBridge?
+    private var observers: [NSObjectProtocol] = []
+
+    init(bridge: NativeBridge) {
+        self.bridge = bridge
+        super.init()
+        setupObservers()
+    }
+
+    private func setupObservers() {
+        observers.append(NotificationCenter.default.addObserver(
+            forName: UIApplication.didBecomeActiveNotification, object: nil, queue: .main
+        ) { [weak self] _ in
+            self?.bridge?.dispatchGlobalEvent("appState:change", payload: ["state": "active"])
+        })
+        observers.append(NotificationCenter.default.addObserver(
+            forName: UIApplication.willResignActiveNotification, object: nil, queue: .main
+        ) { [weak self] _ in
+            self?.bridge?.dispatchGlobalEvent("appState:change", payload: ["state": "inactive"])
+        })
+        observers.append(NotificationCenter.default.addObserver(
+            forName: UIApplication.didEnterBackgroundNotification, object: nil, queue: .main
+        ) { [weak self] _ in
+            self?.bridge?.dispatchGlobalEvent("appState:change", payload: ["state": "background"])
+        })
+    }
+
+    deinit {
+        observers.forEach { NotificationCenter.default.removeObserver($0) }
+    }
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        switch method {
+        case "getState":
+            let bridge = bridge
+            DispatchQueue.main.async {
+                let state: String
+                switch UIApplication.shared.applicationState {
+                case .active: state = "active"
+                case .inactive: state = "inactive"
+                case .background: state = "background"
+                @unknown default: state = "unknown"
+                }
+                bridge?.dispatchGlobalEvent("appState:change", payload: ["state": state])
+                callback(state, nil)
+            }
+        default:
+            callback(nil, "Unknown method: \(method)")
+        }
+    }
+
+    func invokeSync(method: String, args: [Any]) -> Any? { nil }
+}
+#endif