@thelacanians/vue-native-cli 0.4.15 → 0.6.0

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

@@ -0,0 +1,400 @@
+#if canImport(UIKit)
+import XCTest
+import UIKit
+@testable import VueNativeCore
+
+// NOTE: Not @MainActor — native modules dispatch callbacks via
+// DispatchQueue.main.async which deadlocks with @MainActor + waitForExpectations.
+final class NativeModuleTests: XCTestCase {
+
+    // MARK: - HapticsModule Tests
+
+    func testHapticsModuleName() {
+        let module = HapticsModule()
+        XCTAssertEqual(module.moduleName, "Haptics", "HapticsModule should be named 'Haptics'")
+    }
+
+    func testHapticsModuleVibrateDoesNotCrash() {
+        let module = HapticsModule()
+        let expectation = self.expectation(description: "vibrate callback")
+
+        module.invoke(method: "vibrate", args: ["medium"]) { result, error in
+            XCTAssertNil(error, "vibrate should not return an error")
+            expectation.fulfill()
+        }
+
+        waitForExpectations(timeout: 2.0)
+    }
+
+    func testHapticsModuleVibrateStyles() {
+        let module = HapticsModule()
+        let styles = ["light", "medium", "heavy", "rigid", "soft"]
+
+        for style in styles {
+            let expectation = self.expectation(description: "vibrate \(style)")
+            module.invoke(method: "vibrate", args: [style]) { _, error in
+                XCTAssertNil(error, "vibrate(\(style)) should not return an error")
+                expectation.fulfill()
+            }
+        }
+
+        waitForExpectations(timeout: 5.0)
+    }
+
+    func testHapticsModuleNotificationFeedback() {
+        let module = HapticsModule()
+        let types = ["success", "warning", "error"]
+
+        for type in types {
+            let expectation = self.expectation(description: "notificationFeedback \(type)")
+            module.invoke(method: "notificationFeedback", args: [type]) { _, error in
+                XCTAssertNil(error, "notificationFeedback(\(type)) should not return an error")
+                expectation.fulfill()
+            }
+        }
+
+        waitForExpectations(timeout: 5.0)
+    }
+
+    func testHapticsModuleSelectionChanged() {
+        let module = HapticsModule()
+        let expectation = self.expectation(description: "selectionChanged callback")
+
+        module.invoke(method: "selectionChanged", args: []) { _, error in
+            XCTAssertNil(error, "selectionChanged should not return an error")
+            expectation.fulfill()
+        }
+
+        waitForExpectations(timeout: 2.0)
+    }
+
+    func testHapticsModuleUnknownMethodReturnsError() {
+        let module = HapticsModule()
+        let expectation = self.expectation(description: "unknown method callback")
+
+        module.invoke(method: "nonexistent", args: []) { _, error in
+            XCTAssertNotNil(error, "Unknown method should return an error")
+            XCTAssertTrue(error!.contains("Unknown method"), "Error should mention 'Unknown method'")
+            expectation.fulfill()
+        }
+
+        waitForExpectations(timeout: 2.0)
+    }
+
+    // MARK: - ClipboardModule Tests
+
+    func testClipboardModuleName() {
+        let module = ClipboardModule()
+        XCTAssertEqual(module.moduleName, "Clipboard", "ClipboardModule should be named 'Clipboard'")
+    }
+
+    func testClipboardModuleCopy() {
+        let module = ClipboardModule()
+        let expectation = self.expectation(description: "copy callback")
+
+        module.invoke(method: "copy", args: ["test clipboard"]) { _, copyError in
+            XCTAssertNil(copyError, "copy should not return an error")
+            expectation.fulfill()
+        }
+
+        waitForExpectations(timeout: 5.0)
+    }
+
+    // NOTE: Clipboard paste test omitted — UIPasteboard.general.string (read)
+    // triggers iOS clipboard access permission dialog in the simulator,
+    // which blocks the test runner indefinitely.
+
+    func testClipboardModuleCopyMissingTextReturnsError() {
+        let module = ClipboardModule()
+        let expectation = self.expectation(description: "copy without text")
+
+        module.invoke(method: "copy", args: []) { _, error in
+            XCTAssertNotNil(error, "copy without text should return an error")
+            XCTAssertTrue(error!.contains("missing text"), "Error should indicate missing text")
+            expectation.fulfill()
+        }
+
+        waitForExpectations(timeout: 2.0)
+    }
+
+    func testClipboardModuleUnknownMethod() {
+        let module = ClipboardModule()
+        let expectation = self.expectation(description: "unknown method")
+
+        module.invoke(method: "nonexistent", args: []) { _, error in
+            XCTAssertNotNil(error, "Unknown method should return an error")
+            expectation.fulfill()
+        }
+
+        waitForExpectations(timeout: 2.0)
+    }
+
+    // MARK: - DeviceInfoModule Tests
+
+    func testDeviceInfoModuleName() {
+        let module = DeviceInfoModule()
+        XCTAssertEqual(module.moduleName, "DeviceInfo", "DeviceInfoModule should be named 'DeviceInfo'")
+    }
+
+    func testDeviceInfoModuleGetInfoReturnsDeviceData() {
+        let module = DeviceInfoModule()
+        let expectation = self.expectation(description: "getInfo callback")
+
+        module.invoke(method: "getInfo", args: []) { result, error in
+            XCTAssertNil(error, "getInfo should not return an error")
+            XCTAssertNotNil(result, "getInfo should return device info")
+
+            if let info = result as? [String: Any] {
+                XCTAssertNotNil(info["model"], "Should include model")
+                XCTAssertNotNil(info["systemVersion"], "Should include systemVersion")
+                XCTAssertNotNil(info["systemName"], "Should include systemName")
+                XCTAssertNotNil(info["screenWidth"], "Should include screenWidth")
+                XCTAssertNotNil(info["screenHeight"], "Should include screenHeight")
+                XCTAssertNotNil(info["scale"], "Should include scale")
+
+                // Verify screen dimensions are positive
+                let width = info["screenWidth"] as? CGFloat ?? 0
+                XCTAssertGreaterThan(width, 0, "screenWidth should be positive")
+                let height = info["screenHeight"] as? CGFloat ?? 0
+                XCTAssertGreaterThan(height, 0, "screenHeight should be positive")
+                let scale = info["scale"] as? CGFloat ?? 0
+                XCTAssertGreaterThan(scale, 0, "scale should be positive")
+            } else {
+                XCTFail("getInfo result should be a [String: Any] dictionary")
+            }
+
+            expectation.fulfill()
+        }
+
+        waitForExpectations(timeout: 2.0)
+    }
+
+    func testDeviceInfoModuleUnknownMethod() {
+        let module = DeviceInfoModule()
+        let expectation = self.expectation(description: "unknown method")
+
+        module.invoke(method: "nonexistent", args: []) { _, error in
+            XCTAssertNotNil(error, "Unknown method should return an error")
+            expectation.fulfill()
+        }
+
+        waitForExpectations(timeout: 2.0)
+    }
+
+    // MARK: - AsyncStorageModule Tests
+
+    func testAsyncStorageModuleName() {
+        let module = AsyncStorageModule()
+        XCTAssertEqual(module.moduleName, "AsyncStorage", "AsyncStorageModule should be named 'AsyncStorage'")
+    }
+
+    func testAsyncStorageSetAndGetItem() {
+        let module = AsyncStorageModule()
+        let testKey = "test_key_\(UUID().uuidString)"
+
+        // AsyncStorageModule dispatches to DispatchQueue.global, so we can
+        // chain set → get → remove within a single expectation to avoid
+        // multiple sequential waitForExpectations on @MainActor.
+        let expectation = self.expectation(description: "set, get, and remove")
+
+        module.invoke(method: "setItem", args: [testKey, "test_value"]) { _, setError in
+            XCTAssertNil(setError, "setItem should not return an error")
+
+            module.invoke(method: "getItem", args: [testKey]) { result, getError in
+                XCTAssertNil(getError, "getItem should not return an error")
+                XCTAssertEqual(result as? String, "test_value", "getItem should return the stored value")
+
+                // Clean up
+                module.invoke(method: "removeItem", args: [testKey]) { _, _ in
+                    expectation.fulfill()
+                }
+            }
+        }
+
+        waitForExpectations(timeout: 5.0)
+    }
+
+    func testAsyncStorageRemoveItem() {
+        let module = AsyncStorageModule()
+        let testKey = "remove_test_\(UUID().uuidString)"
+        let expectation = self.expectation(description: "set, remove, verify")
+
+        // Chain: set → remove → get (verify nil) in one expectation
+        module.invoke(method: "setItem", args: [testKey, "to_remove"]) { _, _ in
+            module.invoke(method: "removeItem", args: [testKey]) { _, removeError in
+                XCTAssertNil(removeError, "removeItem should not return an error")
+
+                module.invoke(method: "getItem", args: [testKey]) { result, getError in
+                    XCTAssertNil(getError, "getItem should not return an error")
+                    XCTAssertNil(result, "getItem should return nil after removal")
+                    expectation.fulfill()
+                }
+            }
+        }
+
+        waitForExpectations(timeout: 5.0)
+    }
+
+    func testAsyncStorageGetItemMissingKeyReturnsError() {
+        let module = AsyncStorageModule()
+        let expectation = self.expectation(description: "getItem missing key")
+
+        module.invoke(method: "getItem", args: []) { _, error in
+            XCTAssertNotNil(error, "getItem without key should return an error")
+            expectation.fulfill()
+        }
+
+        waitForExpectations(timeout: 2.0)
+    }
+
+    func testAsyncStorageSetItemMissingArgsReturnsError() {
+        let module = AsyncStorageModule()
+        let expectation = self.expectation(description: "setItem missing args")
+
+        module.invoke(method: "setItem", args: ["keyOnly"]) { _, error in
+            XCTAssertNotNil(error, "setItem with missing value should return an error")
+            expectation.fulfill()
+        }
+
+        waitForExpectations(timeout: 2.0)
+    }
+
+    func testAsyncStorageUnknownMethod() {
+        let module = AsyncStorageModule()
+        let expectation = self.expectation(description: "unknown method")
+
+        module.invoke(method: "nonexistent", args: []) { _, error in
+            XCTAssertNotNil(error, "Unknown method should return an error")
+            expectation.fulfill()
+        }
+
+        waitForExpectations(timeout: 2.0)
+    }
+
+    // MARK: - AnimationModule Tests
+
+    func testAnimationModuleName() {
+        let module = AnimationModule()
+        XCTAssertEqual(module.moduleName, "Animation", "AnimationModule should be named 'Animation'")
+    }
+
+    func testAnimationModuleInvokeSyncReturnsNil() {
+        let module = AnimationModule()
+        let result = module.invokeSync(method: "timing", args: [])
+        XCTAssertNil(result, "invokeSync should return nil for AnimationModule")
+    }
+
+    func testAnimationModuleUnknownMethodReturnsError() {
+        let module = AnimationModule()
+        let expectation = self.expectation(description: "unknown method")
+
+        module.invoke(method: "nonexistent", args: []) { _, error in
+            XCTAssertNotNil(error, "Unknown method should return an error")
+            XCTAssertTrue(error!.contains("unknown method"), "Error should mention unknown method")
+            expectation.fulfill()
+        }
+
+        waitForExpectations(timeout: 2.0)
+    }
+
+    // MARK: - NetworkModule Tests
+
+    func testNetworkModuleName() {
+        let module = NetworkModule(bridge: NativeBridge.shared)
+        XCTAssertEqual(module.moduleName, "Network", "NetworkModule should be named 'Network'")
+    }
+
+    func testNetworkModuleGetStatusReturnsInfo() {
+        let module = NetworkModule(bridge: NativeBridge.shared)
+        let expectation = self.expectation(description: "getStatus callback")
+
+        module.invoke(method: "getStatus", args: []) { result, error in
+            XCTAssertNil(error, "getStatus should not return an error")
+            XCTAssertNotNil(result, "getStatus should return connection info")
+
+            if let info = result as? [String: Any] {
+                XCTAssertNotNil(info["isConnected"], "Should include isConnected")
+                XCTAssertNotNil(info["connectionType"], "Should include connectionType")
+            }
+            expectation.fulfill()
+        }
+
+        waitForExpectations(timeout: 2.0)
+    }
+
+    func testNetworkModuleUnknownMethod() {
+        let module = NetworkModule(bridge: NativeBridge.shared)
+        let expectation = self.expectation(description: "unknown method")
+
+        module.invoke(method: "nonexistent", args: []) { _, error in
+            XCTAssertNotNil(error, "Unknown method should return an error")
+            expectation.fulfill()
+        }
+
+        waitForExpectations(timeout: 2.0)
+    }
+
+    func testNetworkModuleInvokeSyncReturnsNil() {
+        let module = NetworkModule(bridge: NativeBridge.shared)
+        let result = module.invokeSync(method: "getStatus", args: [])
+        XCTAssertNil(result, "invokeSync should return nil")
+    }
+
+    // MARK: - KeyboardModule Tests
+
+    func testKeyboardModuleName() {
+        let module = KeyboardModule()
+        XCTAssertEqual(module.moduleName, "Keyboard", "KeyboardModule should be named 'Keyboard'")
+    }
+
+    func testKeyboardModuleDismissDoesNotCrash() {
+        let module = KeyboardModule()
+        let expectation = self.expectation(description: "dismiss callback")
+
+        module.invoke(method: "dismiss", args: []) { _, error in
+            XCTAssertNil(error, "dismiss should not return an error")
+            expectation.fulfill()
+        }
+
+        waitForExpectations(timeout: 2.0)
+    }
+
+    func testKeyboardModuleGetHeight() {
+        let module = KeyboardModule()
+        let expectation = self.expectation(description: "getHeight callback")
+
+        module.invoke(method: "getHeight", args: []) { result, error in
+            XCTAssertNil(error, "getHeight should not return an error")
+            XCTAssertNotNil(result, "getHeight should return keyboard info")
+
+            if let info = result as? [String: Any] {
+                XCTAssertNotNil(info["height"], "Should include height")
+                XCTAssertNotNil(info["isVisible"], "Should include isVisible")
+            }
+            expectation.fulfill()
+        }
+
+        waitForExpectations(timeout: 2.0)
+    }
+
+    func testKeyboardModuleUnknownMethod() {
+        let module = KeyboardModule()
+        let expectation = self.expectation(description: "unknown method")
+
+        module.invoke(method: "nonexistent", args: []) { _, error in
+            XCTAssertNotNil(error, "Unknown method should return an error")
+            expectation.fulfill()
+        }
+
+        waitForExpectations(timeout: 2.0)
+    }
+
+    // MARK: - NativeModule Protocol Default Implementation
+
+    func testNativeModuleDefaultInvokeSyncReturnsNil() {
+        let module = HapticsModule()
+        let result = module.invokeSync(method: "vibrate", args: ["light"])
+        XCTAssertNil(result, "Default invokeSync should return nil")
+    }
+}
+#endif

package/native/macos/VueNativeMacOS/Package.swift

@@ -0,0 +1,34 @@
+// swift-tools-version: 6.0
+import PackageDescription
+
+let package = Package(
+    name: "VueNativeMacOS",
+    platforms: [.macOS(.v15)],
+    products: [
+        .library(name: "VueNativeMacOS", targets: ["VueNativeMacOS"])
+    ],
+    dependencies: [
+        .package(path: "../../shared/VueNativeShared"),
+    ],
+    targets: [
+        .target(
+            name: "VueNativeMacOS",
+            dependencies: ["VueNativeShared"],
+            path: "Sources/VueNativeMacOS",
+            resources: [
+                .copy("Resources/vue-native-placeholder.js")
+            ],
+            swiftSettings: [
+                .swiftLanguageMode(.v5)
+            ]
+        ),
+        .testTarget(
+            name: "VueNativeMacOSTests",
+            dependencies: ["VueNativeMacOS"],
+            path: "Tests/VueNativeMacOSTests",
+            swiftSettings: [
+                .swiftLanguageMode(.v5)
+            ]
+        )
+    ]
+)

package/native/macos/VueNativeMacOS/Sources/VueNativeMacOS/Bridge/ErrorOverlayView.swift

@@ -0,0 +1,112 @@
+import AppKit
+
+/// Full-window red error overlay shown in dev mode when a JS exception occurs.
+/// macOS version using NSView instead of UIView.
+@MainActor
+final class ErrorOverlayView: FlippedView {
+
+    private let titleLabel = NSTextField(labelWithString: "JavaScript Error")
+    private let messageLabel = NSTextField(wrappingLabelWithString: "")
+    private let dismissButton = NSButton(title: "Dismiss", target: nil, action: nil)
+    private let scrollView = NSScrollView()
+
+    override init(frame: NSRect) {
+        super.init(frame: frame)
+        setupUI()
+    }
+
+    required init?(coder: NSCoder) { fatalError() }
+
+    private func setupUI() {
+        layer?.backgroundColor = NSColor(red: 0.8, green: 0.1, blue: 0.1, alpha: 0.95).cgColor
+
+        titleLabel.textColor = .white
+        titleLabel.font = .systemFont(ofSize: 20, weight: .bold)
+        titleLabel.alignment = .center
+        titleLabel.isBordered = false
+        titleLabel.isEditable = false
+        titleLabel.drawsBackground = false
+
+        messageLabel.textColor = .white
+        messageLabel.font = .monospacedSystemFont(ofSize: 13, weight: .regular)
+        messageLabel.isEditable = false
+        messageLabel.isBordered = false
+        messageLabel.drawsBackground = false
+        messageLabel.maximumNumberOfLines = 0
+        messageLabel.lineBreakMode = .byWordWrapping
+
+        dismissButton.target = self
+        dismissButton.action = #selector(dismissOverlay)
+        dismissButton.bezelStyle = .rounded
+
+        scrollView.documentView = messageLabel
+        scrollView.hasVerticalScroller = true
+        scrollView.hasHorizontalScroller = false
+        scrollView.drawsBackground = false
+        scrollView.borderType = .noBorder
+
+        addSubview(titleLabel)
+        addSubview(scrollView)
+        addSubview(dismissButton)
+    }
+
+    override func layout() {
+        super.layout()
+
+        let padding: CGFloat = 20
+        let topPadding: CGFloat = 20
+
+        titleLabel.frame = CGRect(x: padding, y: topPadding, width: bounds.width - padding * 2, height: 30)
+
+        let buttonHeight: CGFloat = 30
+        dismissButton.frame = CGRect(
+            x: padding,
+            y: bounds.height - buttonHeight - padding,
+            width: bounds.width - padding * 2,
+            height: buttonHeight
+        )
+
+        scrollView.frame = CGRect(
+            x: padding,
+            y: topPadding + 40,
+            width: bounds.width - padding * 2,
+            height: dismissButton.frame.minY - topPadding - 50
+        )
+
+        // Size the message label to fill scroll view width
+        messageLabel.frame = CGRect(
+            x: 0, y: 0,
+            width: scrollView.contentSize.width,
+            height: 0
+        )
+        messageLabel.sizeToFit()
+    }
+
+    func show(error: String, in window: NSWindow) {
+        messageLabel.stringValue = error
+        guard let contentView = window.contentView else { return }
+
+        frame = contentView.bounds
+        autoresizingMask = [.width, .height]
+        contentView.addSubview(self)
+        needsLayout = true
+    }
+
+    @objc private func dismissOverlay() {
+        removeFromSuperview()
+    }
+
+    static func show(error: String) {
+        DispatchQueue.main.async {
+            guard let window = NSApp.mainWindow ?? NSApp.windows.first else { return }
+
+            // Remove any existing overlay
+            window.contentView?.subviews
+                .compactMap { $0 as? ErrorOverlayView }
+                .forEach { $0.removeFromSuperview() }
+
+            let overlay = ErrorOverlayView(frame: window.contentView?.bounds ?? .zero)
+            overlay.show(error: error, in: window)
+        }
+    }
+}

package/native/macos/VueNativeMacOS/Sources/VueNativeMacOS/Bridge/EventThrottle.swift

@@ -0,0 +1,58 @@
+import Foundation
+import QuartzCore
+
+/// Throttles high-frequency event handlers to avoid flooding the JS bridge.
+///
+/// When a high-frequency event (scroll, slider drag, text input) fires many
+/// times per frame, each invocation becomes a bridge round-trip. This utility
+/// ensures at most one call per `interval` seconds, with a trailing call
+/// to deliver the latest value.
+///
+/// Default interval: 16ms (~60 FPS).
+final class EventThrottle {
+
+    let interval: TimeInterval
+    private let handler: (Any?) -> Void
+    private var lastFireTime: CFTimeInterval = 0
+    private var pendingTrailing = false
+    private var latestPayload: Any?
+    private var trailingTimer: DispatchSourceTimer?
+
+    init(interval: TimeInterval = 0.016, handler: @escaping (Any?) -> Void) {
+        self.interval = interval
+        self.handler = handler
+    }
+
+    deinit {
+        trailingTimer?.cancel()
+    }
+
+    func fire(_ payload: Any?) {
+        let now = CACurrentMediaTime()
+        let elapsed = now - lastFireTime
+
+        latestPayload = payload
+
+        if elapsed >= interval {
+            lastFireTime = now
+            pendingTrailing = false
+            trailingTimer?.cancel()
+            trailingTimer = nil
+            handler(payload)
+        } else if !pendingTrailing {
+            pendingTrailing = true
+            let remaining = interval - elapsed
+            let timer = DispatchSource.makeTimerSource(queue: .main)
+            timer.schedule(deadline: .now() + remaining)
+            timer.setEventHandler { [weak self] in
+                guard let self = self else { return }
+                self.lastFireTime = CACurrentMediaTime()
+                self.pendingTrailing = false
+                self.trailingTimer = nil
+                self.handler(self.latestPayload)
+            }
+            trailingTimer = timer
+            timer.resume()
+        }
+    }
+}