@thelacanians/vue-native-cli 0.4.14 → 0.6.0

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

@@ -87,6 +87,51 @@ final class VViewFactory: NativeComponentFactory {
             view.isUserInteractionEnabled = true
             GestureStorage.storeObject(pinchWrapper, for: view, event: event)
 
+        // MARK: Rotation
+        case "rotate":
+            let rotationWrapper = RotationWrapper(handler: handler)
+            let rotation = UIRotationGestureRecognizer(
+                target: rotationWrapper,
+                action: #selector(RotationWrapper.handle(_:))
+            )
+            view.addGestureRecognizer(rotation)
+            view.isUserInteractionEnabled = true
+            GestureStorage.storeObject(rotationWrapper, for: view, event: event)
+
+        // MARK: Double Tap
+        case "doubleTap":
+            let wrapper = DoubleTapWrapper(handler: handler)
+            let tapRecognizer = UITapGestureRecognizer(
+                target: wrapper,
+                action: #selector(DoubleTapWrapper.handleGesture(_:))
+            )
+            tapRecognizer.numberOfTapsRequired = 2
+            view.addGestureRecognizer(tapRecognizer)
+            view.isUserInteractionEnabled = true
+            GestureStorage.storeObject(wrapper, for: view, event: event)
+
+        // MARK: Force Touch (3D Touch)
+        case "forceTouch":
+            let wrapper = ForceTouchWrapper(handler: handler)
+            // Force touch is handled via touch events, not gesture recognizers
+            // We store the wrapper and will handle it in a custom touch handler
+            GestureStorage.storeObject(wrapper, for: view, event: event)
+            // Enable force touch on the view
+            view.isUserInteractionEnabled = true
+            attachForceTouchHandler(to: view, wrapper: wrapper)
+
+        // MARK: Hover (iOS 13+)
+        case "hover":
+            if #available(iOS 13.0, *) {
+                let hoverWrapper = HoverWrapper(handler: handler)
+                let hover = UIHoverGestureRecognizer(
+                    target: hoverWrapper,
+                    action: #selector(HoverWrapper.handleGesture(_:))
+                )
+                view.addGestureRecognizer(hover)
+                GestureStorage.storeObject(hoverWrapper, for: view, event: event)
+            }
+
         default:
             break
         }
@@ -97,24 +142,91 @@ final class VViewFactory: NativeComponentFactory {
         // Remove matching gesture recognizers
         view.gestureRecognizers?.forEach { recognizer in
             switch event {
-            case "press"      where recognizer is UITapGestureRecognizer:
-                view.removeGestureRecognizer(recognizer)
+            case "press":
+                if let tap = recognizer as? UITapGestureRecognizer, tap.numberOfTapsRequired == 1 {
+                    view.removeGestureRecognizer(recognizer)
+                }
             case "longpress"  where recognizer is UILongPressGestureRecognizer:
                 view.removeGestureRecognizer(recognizer)
             case "pan"        where recognizer is UIPanGestureRecognizer:
                 view.removeGestureRecognizer(recognizer)
-            case "swipeLeft", "swipeRight", "swipeUp", "swipeDown"
-                              where recognizer is UISwipeGestureRecognizer:
+            case "swipeLeft"   where recognizer is UISwipeGestureRecognizer:
+                view.removeGestureRecognizer(recognizer)
+            case "swipeRight"  where recognizer is UISwipeGestureRecognizer:
+                view.removeGestureRecognizer(recognizer)
+            case "swipeUp"     where recognizer is UISwipeGestureRecognizer:
+                view.removeGestureRecognizer(recognizer)
+            case "swipeDown"   where recognizer is UISwipeGestureRecognizer:
                 view.removeGestureRecognizer(recognizer)
             case "pinch"      where recognizer is UIPinchGestureRecognizer:
                 view.removeGestureRecognizer(recognizer)
+            case "rotate"     where recognizer is UIRotationGestureRecognizer:
+                view.removeGestureRecognizer(recognizer)
+            case "doubleTap":
+                if let tap = recognizer as? UITapGestureRecognizer, tap.numberOfTapsRequired == 2 {
+                    view.removeGestureRecognizer(recognizer)
+                }
+            case "hover":
+                if #available(iOS 13.0, *) {
+                    if recognizer is UIHoverGestureRecognizer {
+                        view.removeGestureRecognizer(recognizer)
+                    }
+                }
             default:
                 break
             }
         }
     }
+
+    // MARK: - Force Touch Helper
+
+    private func attachForceTouchHandler(to view: UIView, wrapper: ForceTouchWrapper) {
+        // ForceTouchHandler is attached via associated object
+        let handler = ForceTouchHandlerView(wrapper: wrapper)
+        objc_setAssociatedObject(view, &forceTouchHandlerKey, handler, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+        handler.attach(to: view)
+    }
 }
 
+// MARK: - ForceTouchHandlerView
+
+/// Custom UIView subclass that monitors force touch events
+private class ForceTouchHandlerView: UIView {
+    private let wrapper: ForceTouchWrapper
+    private weak var targetView: UIView?
+
+    init(wrapper: ForceTouchWrapper) {
+        self.wrapper = wrapper
+        super.init(frame: .zero)
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    func attach(to view: UIView) {
+        targetView = view
+    }
+
+    override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {
+        super.touchesMoved(touches, with: event)
+        guard let touch = touches.first else { return }
+        let force = touch.force
+        let location = touch.location(in: targetView)
+        wrapper.handleTouch(force: force, location: location)
+    }
+
+    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
+        super.touchesBegan(touches, with: event)
+        guard let touch = touches.first else { return }
+        let force = touch.force
+        let location = touch.location(in: targetView)
+        wrapper.handleTouch(force: force, location: location)
+    }
+}
+
+private var forceTouchHandlerKey: UInt8 = 0
+
 // MARK: - GestureStorage
 
 /// Stores gesture wrapper references as associated objects on views to prevent deallocation.

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

@@ -104,4 +104,104 @@ import UIKit
         ] as [String: Any])
     }
 }
+
+// MARK: - RotationWrapper
+
+/// ObjC-compatible wrapper for UIRotationGestureRecognizer action handlers.
+@objc final class RotationWrapper: NSObject {
+    private let handler: (Any?) -> Void
+
+    init(handler: @escaping (Any?) -> Void) {
+        self.handler = handler
+        super.init()
+    }
+
+    @objc func handle(_ recognizer: UIRotationGestureRecognizer) {
+        let stateStr: String
+        switch recognizer.state {
+        case .began:    stateStr = "began"
+        case .changed:  stateStr = "changed"
+        case .ended:    stateStr = "ended"
+        default:        stateStr = "cancelled"
+        }
+        handler([
+            "rotation": recognizer.rotation,
+            "velocity": recognizer.velocity,
+            "state": stateStr
+        ] as [String: Any])
+    }
+}
+
+// MARK: - ForceTouchWrapper
+
+/// Wrapper for 3D Touch / Force Touch gesture handlers.
+@objc final class ForceTouchWrapper: NSObject {
+    private let handler: (Any?) -> Void
+    private var lastForce: CGFloat = 0
+
+    init(handler: @escaping (Any?) -> Void) {
+        self.handler = handler
+        super.init()
+    }
+
+    func handleTouch(force: CGFloat, location: CGPoint) {
+        let payload: [String: Any] = [
+            "force": force,
+            "locationX": location.x,
+            "locationY": location.y
+        ]
+        handler(payload)
+    }
+}
+
+// MARK: - DoubleTapWrapper
+
+/// ObjC-compatible wrapper for double-tap gesture handlers.
+@objc final class DoubleTapWrapper: NSObject {
+    private let handler: (Any?) -> Void
+
+    init(handler: @escaping (Any?) -> Void) {
+        self.handler = handler
+        super.init()
+    }
+
+    @objc func handleGesture(_ gesture: UITapGestureRecognizer) {
+        let location = gesture.location(in: gesture.view)
+        let payload: [String: Any] = [
+            "locationX": location.x,
+            "locationY": location.y
+        ]
+        handler(payload)
+    }
+}
+
+// MARK: - HoverWrapper
+
+/// Wrapper for hover gesture handlers (iOS 13+).
+@objc final class HoverWrapper: NSObject {
+    private let handler: (Any?) -> Void
+
+    init(handler: @escaping (Any?) -> Void) {
+        self.handler = handler
+        super.init()
+    }
+
+    @objc func handleGesture(_ gesture: UIHoverGestureRecognizer) {
+        guard let view = gesture.view else { return }
+        let location = gesture.location(in: view)
+        let stateStr: String
+        switch gesture.state {
+        case .began:    stateStr = "began"
+        case .changed:  stateStr = "changed"
+        case .ended:    stateStr = "ended"
+        default:        stateStr = "cancelled"
+        }
+        let payload: [String: Any] = [
+            "locationX": location.x,
+            "locationY": location.y,
+            "state": stateStr
+        ]
+        handler(payload)
+    }
+}
 #endif

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

@@ -0,0 +1,28 @@
+// ────────────────────────────────────────────────────────────────────────────────
+//  Auto-Generated Module Registration
+// ────────────────────────────────────────────────────────────────────────────────
+//
+//  ⚠️  WARNING: This file is auto-generated. DO NOT EDIT MANUALLY.
+//      Changes will be overwritten by the vue-native-codegen tool.
+//
+//  Generated: {{GENERATED_DATE}}
+//
+//  This file registers all native modules generated from <native> blocks
+//  in Vue SFC files.
+//
+// ────────────────────────────────────────────────────────────────────────────────
+
+import Foundation
+
+@MainActor
+extension NativeModuleRegistry {
+    /// Register all generated native modules from <native> blocks
+    func registerGeneratedModules() {
+        // Generated modules will be registered here
+        // Example:
+        // register(HapticsModule())
+        // register(CameraModule())
+        
+        // This function is called automatically after registerDefaults()
+    }
+}

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

@@ -55,6 +55,9 @@ final class NativeModuleRegistry {
         register(BluetoothModule(bridge: bridge))
         register(CalendarModule())
         register(ContactsModule())
+        
+        // Register generated modules from <native> blocks
+        registerGeneratedModules()
     }
 
     // MARK: - Invocation

package/native/ios/VueNativeCore/Tests/VueNativeCoreTests/CertificatePinningTests.swift

@@ -0,0 +1,190 @@
+#if canImport(UIKit)
+import XCTest
+import UIKit
+@testable import VueNativeCore
+
+@MainActor
+final class CertificatePinningTests: XCTestCase {
+
+    // MARK: - Properties
+
+    private var pinning: CertificatePinning!
+
+    // MARK: - Setup / Teardown
+
+    override func setUp() {
+        super.setUp()
+        pinning = CertificatePinning.shared
+        pinning.clearPins()
+    }
+
+    override func tearDown() {
+        pinning.clearPins()
+        pinning = nil
+        super.tearDown()
+    }
+
+    // MARK: - Singleton Tests
+
+    func testSharedInstanceIsSingleton() {
+        let instance1 = CertificatePinning.shared
+        let instance2 = CertificatePinning.shared
+        XCTAssertTrue(instance1 === instance2, "CertificatePinning.shared should always return the same instance")
+    }
+
+    // MARK: - configurePins Tests
+
+    func testConfigurePinsStoresHashesForDomain() {
+        pinning.configurePins([
+            "api.example.com": ["sha256/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="]
+        ])
+
+        XCTAssertTrue(pinning.hasPins(for: "api.example.com"), "Should have pins for configured domain")
+    }
+
+    func testConfigurePinsMultipleDomains() {
+        pinning.configurePins([
+            "api.example.com": ["sha256/AAA="],
+            "cdn.example.com": ["sha256/BBB="]
+        ])
+
+        XCTAssertTrue(pinning.hasPins(for: "api.example.com"), "Should have pins for api.example.com")
+        XCTAssertTrue(pinning.hasPins(for: "cdn.example.com"), "Should have pins for cdn.example.com")
+    }
+
+    func testConfigurePinsMultipleHashesPerDomain() {
+        pinning.configurePins([
+            "api.example.com": ["sha256/PrimaryHash=", "sha256/BackupHash="]
+        ])
+
+        XCTAssertTrue(pinning.hasPins(for: "api.example.com"),
+                      "Should have pins with multiple hashes")
+    }
+
+    func testConfigurePinsIgnoresMalformedPins() {
+        // Pins without "sha256/" prefix should be ignored
+        pinning.configurePins([
+            "api.example.com": ["md5/NotSupported"]
+        ])
+
+        XCTAssertFalse(pinning.hasPins(for: "api.example.com"),
+                       "Malformed pins (without sha256/ prefix) should not register")
+    }
+
+    func testConfigurePinsIsCaseInsensitiveForDomain() {
+        pinning.configurePins([
+            "API.Example.COM": ["sha256/TestHash="]
+        ])
+
+        XCTAssertTrue(pinning.hasPins(for: "api.example.com"),
+                      "Domain lookup should be case-insensitive")
+    }
+
+    // MARK: - hasPins Tests
+
+    func testHasPinsReturnsFalseForUnconfiguredDomain() {
+        XCTAssertFalse(pinning.hasPins(for: "unknown.com"),
+                       "Should return false for domains without pins")
+    }
+
+    func testHasPinsReturnsTrueForConfiguredDomain() {
+        pinning.configurePins([
+            "example.com": ["sha256/TestHash="]
+        ])
+
+        XCTAssertTrue(pinning.hasPins(for: "example.com"),
+                      "Should return true for configured domain")
+    }
+
+    func testHasPinsIsCaseInsensitive() {
+        pinning.configurePins([
+            "example.com": ["sha256/TestHash="]
+        ])
+
+        XCTAssertTrue(pinning.hasPins(for: "EXAMPLE.COM"),
+                      "hasPins lookup should be case-insensitive")
+    }
+
+    // MARK: - clearPins Tests
+
+    func testClearPinsRemovesAllPins() {
+        pinning.configurePins([
+            "api.example.com": ["sha256/AAA="],
+            "cdn.example.com": ["sha256/BBB="]
+        ])
+
+        pinning.clearPins()
+
+        XCTAssertFalse(pinning.hasPins(for: "api.example.com"),
+                       "clearPins should remove all configured pins")
+        XCTAssertFalse(pinning.hasPins(for: "cdn.example.com"),
+                       "clearPins should remove all configured pins")
+    }
+
+    func testClearPinsOnEmptyDoesNotCrash() {
+        // Should not crash when called with no pins configured
+        pinning.clearPins()
+    }
+
+    // MARK: - Session Tests
+
+    func testSessionIsURLSession() {
+        let session = pinning.session
+        XCTAssertNotNil(session, "session should return a valid URLSession")
+    }
+
+    func testSessionIsSameInstance() {
+        let session1 = pinning.session
+        let session2 = pinning.session
+        XCTAssertTrue(session1 === session2, "session should return the same URLSession instance")
+    }
+
+    // MARK: - URLSessionDelegate Conformance
+
+    func testConformsToURLSessionDelegate() {
+        XCTAssertTrue(pinning is URLSessionDelegate,
+                      "CertificatePinning should conform to URLSessionDelegate")
+    }
+
+    // MARK: - Empty Pins Allows Default Handling
+
+    func testNoPinsConfiguredAllowsDefaultHandling() {
+        // With no pins configured, hasPins should return false for any domain
+        XCTAssertFalse(pinning.hasPins(for: "anything.com"),
+                       "Without pins configured, all domains should use default handling")
+    }
+
+    // MARK: - Backup Pin Support
+
+    func testBackupPinConfigured() {
+        // Configure primary + backup pins for a domain
+        pinning.configurePins([
+            "api.example.com": ["sha256/PrimaryHash=", "sha256/BackupHash="]
+        ])
+
+        // Both pins should be stored
+        XCTAssertTrue(pinning.hasPins(for: "api.example.com"),
+                      "Domain should have pins configured including backup")
+    }
+
+    // MARK: - Additive Configuration
+
+    func testConfigurePinsIsAdditive() {
+        pinning.configurePins(["api.example.com": ["sha256/AAA="]])
+        pinning.configurePins(["cdn.example.com": ["sha256/BBB="]])
+
+        // First domain's pins may be overwritten or preserved depending on implementation.
+        // At minimum, the second domain should be configured.
+        XCTAssertTrue(pinning.hasPins(for: "cdn.example.com"),
+                      "Adding pins for a new domain should work")
+    }
+
+    func testConfigurePinsSameDomainOverwrites() {
+        pinning.configurePins(["api.example.com": ["sha256/OldHash="]])
+        pinning.configurePins(["api.example.com": ["sha256/NewHash="]])
+
+        XCTAssertTrue(pinning.hasPins(for: "api.example.com"),
+                      "Reconfiguring the same domain should still have pins")
+    }
+}
+#endif