@thelacanians/vue-native-cli 0.4.15 → 0.6.0

package/native/macos/VueNativeMacOS/Tests/VueNativeMacOSTests/ComponentFactoryTests.swift

@@ -0,0 +1,80 @@
+import AppKit
+import XCTest
+@testable import VueNativeMacOS
+
+@MainActor
+final class ComponentFactoryTests: XCTestCase {
+
+    func testVListFactoryAppliesPublicProps() {
+        let factory = VListFactory()
+        guard let container = factory.createView() as? VListContainerView else {
+            return XCTFail("Expected VListContainerView")
+        }
+
+        factory.updateProp(view: container, key: "estimatedItemHeight", value: 72)
+        factory.updateProp(view: container, key: "showsScrollIndicator", value: false)
+        factory.updateProp(view: container, key: "bounces", value: false)
+
+        XCTAssertEqual(container.estimatedItemHeight, 72)
+        XCTAssertFalse(container.scrollView.hasVerticalScroller)
+        XCTAssertEqual(container.scrollView.verticalScrollElasticity, .none)
+        XCTAssertEqual(container.scrollView.horizontalScrollElasticity, .none)
+    }
+
+    func testVSectionListFactoryBuildsRowsFromInsertedChildren() {
+        let factory = VSectionListFactory()
+        guard let container = factory.createView() as? VSectionListContainerView else {
+            return XCTFail("Expected VSectionListContainerView")
+        }
+
+        let header = FlippedView(frame: NSRect(x: 0, y: 0, width: 200, height: 28))
+        header.ensureLayoutNode()
+        StyleEngine.setInternalPropDirect("__sectionHeader", value: true, on: header)
+
+        let item1 = FlippedView(frame: NSRect(x: 0, y: 0, width: 200, height: 44))
+        item1.ensureLayoutNode()
+        let item2 = FlippedView(frame: NSRect(x: 0, y: 0, width: 200, height: 44))
+        item2.ensureLayoutNode()
+
+        factory.insertChild(header, into: container, before: nil)
+        factory.insertChild(item1, into: container, before: nil)
+        factory.insertChild(item2, into: container, before: nil)
+
+        XCTAssertEqual(container.numberOfRows(in: container.tableView), 3)
+        XCTAssertTrue(container.tableView(container.tableView, isGroupRow: 0))
+        XCTAssertFalse(container.tableView(container.tableView, isGroupRow: 1))
+    }
+
+    func testVSectionListFactoryEmitsFlatScrollPayload() {
+        let factory = VSectionListFactory()
+        guard let container = factory.createView() as? VSectionListContainerView else {
+            return XCTFail("Expected VSectionListContainerView")
+        }
+
+        var payload: [String: Any]?
+        factory.addEventListener(view: container, event: "scroll") { eventPayload in
+            payload = eventPayload as? [String: Any]
+        }
+
+        container.scrollView.frame = NSRect(x: 0, y: 0, width: 120, height: 240)
+        container.tableView.frame = NSRect(x: 0, y: 0, width: 240, height: 960)
+        container.scrollView.contentView.scroll(to: NSPoint(x: 12, y: 34))
+        NotificationCenter.default.post(
+            name: NSView.boundsDidChangeNotification,
+            object: container.scrollView.contentView
+        )
+
+        guard let payload else {
+            return XCTFail("Expected scroll payload")
+        }
+
+        XCTAssertEqual(payload["x"] as? CGFloat, 12)
+        XCTAssertEqual(payload["y"] as? CGFloat, 34)
+        XCTAssertEqual(payload["contentWidth"] as? CGFloat, 240)
+        XCTAssertEqual(payload["contentHeight"] as? CGFloat, 960)
+        XCTAssertEqual(payload["layoutWidth"] as? CGFloat, 120)
+        XCTAssertEqual(payload["layoutHeight"] as? CGFloat, 240)
+        XCTAssertNil(payload["contentOffset"])
+        XCTAssertNil(payload["layoutMeasurement"])
+    }
+}

package/native/macos/VueNativeMacOS/Tests/VueNativeMacOSTests/VueNativeMacOSTests.swift

@@ -0,0 +1,149 @@
+import XCTest
+@testable import VueNativeMacOS
+
+@MainActor
+final class VueNativeMacOSTests: XCTestCase {
+
+    // MARK: - FlippedView
+
+    func testFlippedViewIsFlipped() {
+        let view = FlippedView()
+        XCTAssertTrue(view.isFlipped, "FlippedView must have isFlipped = true")
+        XCTAssertTrue(view.wantsLayer, "FlippedView must be layer-backed")
+    }
+
+    // MARK: - LayoutNode
+
+    func testLayoutNodeDefaults() {
+        let node = LayoutNode()
+        XCTAssertEqual(node.flexDirection, .column)
+        XCTAssertEqual(node.justifyContent, .flexStart)
+        XCTAssertEqual(node.alignItems, .stretch)
+        XCTAssertEqual(node.flexGrow, 0)
+        XCTAssertEqual(node.flexShrink, 1)
+        XCTAssertEqual(node.positionType, .relative)
+        XCTAssertEqual(node.display, .flex)
+    }
+
+    func testLayoutValueResolvePoints() {
+        let value = LayoutValue.points(50)
+        XCTAssertEqual(value.resolve(relativeTo: 200), 50)
+    }
+
+    func testLayoutValueResolvePercent() {
+        let value = LayoutValue.percent(50)
+        XCTAssertEqual(value.resolve(relativeTo: 200), 100)
+    }
+
+    func testLayoutValueResolveAuto() {
+        let value = LayoutValue.auto
+        XCTAssertNil(value.resolve(relativeTo: 200))
+    }
+
+    func testLayoutValueResolveUndefined() {
+        let value = LayoutValue.undefined
+        XCTAssertNil(value.resolve(relativeTo: 200))
+        XCTAssertTrue(value.isUndefined)
+    }
+
+    func testEdgeInsetsZero() {
+        let insets = EdgeInsets.zero
+        XCTAssertEqual(insets.horizontal, 0)
+        XCTAssertEqual(insets.vertical, 0)
+    }
+
+    // MARK: - NSView LayoutNode Extension
+
+    func testNSViewLayoutNodeAssociation() {
+        let view = FlippedView()
+        XCTAssertNil(view.layoutNode)
+
+        let node = view.ensureLayoutNode()
+        XCTAssertNotNil(view.layoutNode)
+        XCTAssertTrue(node === view.layoutNode)
+    }
+
+    // MARK: - Percentage Operator
+
+    func testPercentageOperator() {
+        let value: LayoutValue = 50%
+        XCTAssertEqual(value, .percent(50))
+    }
+
+    // MARK: - Basic Layout
+
+    func testSimpleColumnLayout() {
+        let parent = FlippedView(frame: NSRect(x: 0, y: 0, width: 200, height: 400))
+        let parentNode = parent.ensureLayoutNode()
+        parentNode.flexDirection = .column
+        parentNode.width = .points(200)
+        parentNode.height = .points(400)
+
+        let child1 = FlippedView()
+        let child1Node = child1.ensureLayoutNode()
+        child1Node.height = .points(100)
+        child1Node.width = .points(200)
+        parent.addSubview(child1)
+
+        let child2 = FlippedView()
+        let child2Node = child2.ensureLayoutNode()
+        child2Node.height = .points(100)
+        child2Node.width = .points(200)
+        parent.addSubview(child2)
+
+        parentNode.layout(availableWidth: 200, availableHeight: 400)
+
+        XCTAssertEqual(child1.frame.origin.y, 0)
+        XCTAssertEqual(child2.frame.origin.y, 100)
+    }
+
+    func testFlexGrow() {
+        let parent = FlippedView(frame: NSRect(x: 0, y: 0, width: 200, height: 400))
+        let parentNode = parent.ensureLayoutNode()
+        parentNode.flexDirection = .column
+        parentNode.width = .points(200)
+        parentNode.height = .points(400)
+
+        let child1 = FlippedView()
+        let child1Node = child1.ensureLayoutNode()
+        child1Node.flexGrow = 1
+        parent.addSubview(child1)
+
+        let child2 = FlippedView()
+        let child2Node = child2.ensureLayoutNode()
+        child2Node.flexGrow = 1
+        parent.addSubview(child2)
+
+        parentNode.layout(availableWidth: 200, availableHeight: 400)
+
+        // Both children should share space equally
+        XCTAssertEqual(child1.frame.size.height, 200, accuracy: 1)
+        XCTAssertEqual(child2.frame.size.height, 200, accuracy: 1)
+    }
+
+    // MARK: - NSColor+Hex
+
+    func testColorFromHex6() {
+        let color = NSColor.fromHex("#FF0000")
+        XCTAssertNotNil(color)
+        // Should be red
+        var r: CGFloat = 0, g: CGFloat = 0, b: CGFloat = 0, a: CGFloat = 0
+        color.usingColorSpace(.sRGB)?.getRed(&r, green: &g, blue: &b, alpha: &a)
+        XCTAssertEqual(r, 1.0, accuracy: 0.01)
+        XCTAssertEqual(g, 0.0, accuracy: 0.01)
+        XCTAssertEqual(b, 0.0, accuracy: 0.01)
+    }
+
+    func testColorFromHexNamed() {
+        let transparent = NSColor.fromHex("transparent")
+        XCTAssertEqual(transparent, .clear)
+
+        let white = NSColor.fromHex("white")
+        XCTAssertEqual(white, .white)
+    }
+
+    func testColorFromHexInvalid() {
+        let color = NSColor.fromHex("notacolor")
+        XCTAssertEqual(color, .clear)
+    }
+}

package/native/shared/VueNativeShared/AGENTS.md

@@ -0,0 +1,129 @@
+# AGENTS.md — VueNativeShared
+
+Guidelines for AI agents working on the shared Swift package.
+
+---
+
+## What this package is
+
+VueNativeShared is a cross-platform Swift package containing code shared between iOS (`VueNativeCore`) and macOS (`VueNativeMacOS`). It provides the JS engine interface, infrastructure protocols, and platform-agnostic native modules.
+
+**Platforms:** iOS 16+, macOS 13+
+**Swift:** 5.9+, no SwiftUI
+
+---
+
+## Package structure
+
+```
+Sources/VueNativeShared/
+  JSRuntime.swift              JSContext wrapper on serial DispatchQueue
+  SharedJSPolyfills.swift      JSON encoding helpers for polyfill strings
+  EventThrottle.swift          Throttle events to ~60fps (DispatchSourceTimer)
+  HotReloadManager.swift       WebSocket-based hot reload (URLSessionWebSocketTask)
+  CertificatePinning.swift     TLS certificate pinning (URLSession + Security)
+  NativeModule.swift           Protocol — all native modules conform to this
+  NativeModuleRegistry.swift   Singleton registry mapping module names → instances
+  NativeEventDispatcher.swift  Protocol for cross-platform event dispatch
+  Modules/
+    AsyncStorageModule.swift   UserDefaults key-value storage
+    NetworkModule.swift        NWPathMonitor network connectivity
+    FileSystemModule.swift     FileManager file operations
+    SecureStorageModule.swift   Keychain secure storage
+    AudioModule.swift          AVAudioPlayer audio playback
+    GeolocationModule.swift    CLLocationManager location services
+    DatabaseModule.swift       SQLite database operations
+    WebSocketModule.swift      URLSession WebSocket client
+    PerformanceModule.swift    ProcessInfo performance metrics
+Tests/VueNativeSharedTests/
+  VueNativeSharedTests.swift   XCTest suite (6 tests)
+```
+
+---
+
+## Build & test
+
+```bash
+swift build    # Must compile without errors
+swift test     # All tests must pass (currently 6)
+```
+
+Or from the monorepo root:
+```bash
+bun run test:shared
+```
+
+---
+
+## Architecture rules
+
+### NativeModule protocol
+- All native modules conform to `public protocol NativeModule: AnyObject`
+- Required: `var moduleName: String` and `func invoke(method:args:callback:)`
+- Optional: `func invokeSync(method:args:) -> Any?` (default returns nil)
+- Modules are registered in `NativeModuleRegistry.shared`
+- **Do NOT redefine this protocol in platform packages** — import VueNativeShared instead
+
+### JSRuntime
+- JSContext runs on a dedicated serial `DispatchQueue` (`jsQueue`)
+- **Never pass JSValue across threads** — extract primitives first
+- Always use `[weak self]` in closures registered with JSContext
+- JSC has native Promise support (iOS 13+ / macOS 10.15+)
+
+### EventThrottle
+- Uses `CACurrentMediaTime()` for high-precision timing
+- `DispatchSourceTimer` for deferred firing — NOT `Timer` or `RunLoop`
+- Thread-safe: can be created and fired from any queue
+
+### Thread safety
+- `NativeModuleRegistry` is **not** thread-safe — access from main thread only
+- `CertificatePinning` uses a serial queue internally
+- `HotReloadManager` runs WebSocket on a background queue, dispatches UI updates to main
+
+---
+
+## Coding conventions
+
+- All public API types must be marked `public`
+- Use `guard let` / `if let` — no force-unwraps (`!`) in production code
+- Modules should handle errors gracefully: call `callback(nil, errorMessage)` on failure
+- Keep modules platform-agnostic — use only Foundation, Security, CoreLocation, and similar frameworks available on both iOS and macOS
+- Do NOT import UIKit or AppKit in this package
+
+---
+
+## How to add a shared module
+
+1. Create `Sources/VueNativeShared/Modules/<Name>Module.swift`
+2. Conform to `NativeModule` protocol
+3. Implement `moduleName`, `invoke(method:args:callback:)`, and optionally `invokeSync`
+4. Register in both platform packages' `NativeModuleRegistry.registerDefaults()`
+5. Add tests in `Tests/VueNativeSharedTests/`
+6. Only use frameworks available on both iOS 16+ and macOS 13+
+
+---
+
+## Common pitfalls
+
+| Mistake | Why it breaks | Fix |
+|---------|---------------|-----|
+| Importing UIKit or AppKit | Package must be platform-agnostic | Use Foundation, CoreLocation, etc. |
+| Force-unwrapping module args | Crashes if JS passes unexpected types | Use `as?` with guard/if-let |
+| Accessing JSValue off jsQueue | JSContext is not thread-safe | Extract primitives on jsQueue first |
+| Redefining NativeModule in platform package | Creates shadowing, type mismatches | Import VueNativeShared instead |
+| Forgetting to register module | Module exists but is unreachable from JS | Add to registerDefaults() in both platforms |
+
+---
+
+## Key file locations
+
+| What | Path |
+|------|------|
+| NativeModule protocol | `Sources/VueNativeShared/NativeModule.swift` |
+| Module registry | `Sources/VueNativeShared/NativeModuleRegistry.swift` |
+| JS runtime | `Sources/VueNativeShared/JSRuntime.swift` |
+| Event throttle | `Sources/VueNativeShared/EventThrottle.swift` |
+| Hot reload | `Sources/VueNativeShared/HotReloadManager.swift` |
+| Certificate pinning | `Sources/VueNativeShared/CertificatePinning.swift` |
+| Tests | `Tests/VueNativeSharedTests/VueNativeSharedTests.swift` |
+| Package manifest | `Package.swift` |

package/native/shared/VueNativeShared/Package.swift

@@ -0,0 +1,14 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "VueNativeShared",
+    platforms: [.iOS(.v16), .macOS(.v13)],
+    products: [
+        .library(name: "VueNativeShared", targets: ["VueNativeShared"])
+    ],
+    targets: [
+        .target(name: "VueNativeShared", path: "Sources/VueNativeShared"),
+        .testTarget(name: "VueNativeSharedTests", dependencies: ["VueNativeShared"], path: "Tests/VueNativeSharedTests")
+    ]
+)

package/native/shared/VueNativeShared/Sources/VueNativeShared/CertificatePinning.swift

@@ -0,0 +1,134 @@
+import Foundation
+import CommonCrypto
+
+/// Manages certificate pinning for network requests.
+/// Stores SHA-256 pin hashes per domain and provides a URLSession with
+/// a delegate that validates server certificates against the pinned hashes.
+///
+/// Usage from JS (via the bridge):
+///   __VN_configurePins({ "api.example.com": ["sha256/BBBBBBB..."] })
+///
+/// The fetch polyfill uses `CertificatePinning.shared.session` instead of
+/// `URLSession.shared` when pins are configured for the request's host.
+public final class CertificatePinning: NSObject, URLSessionDelegate {
+
+    public static let shared = CertificatePinning()
+
+    /// Maps lowercase domain to an array of base64-encoded SHA-256 hashes of the
+    /// Subject Public Key Info (SPKI).
+    private var pins: [String: [String]] = [:]
+
+    /// A URLSession configured with this object as its delegate for TLS validation.
+    /// Lazily created so we don't pay the cost if pinning is never configured.
+    public private(set) lazy var session: URLSession = {
+        let config = URLSessionConfiguration.default
+        config.timeoutIntervalForRequest = 30
+        config.timeoutIntervalForResource = 60
+        return URLSession(configuration: config, delegate: self, delegateQueue: nil)
+    }()
+
+    private override init() {
+        super.init()
+    }
+
+    // MARK: - Configuration
+
+    /// Configure certificate pins for one or more domains.
+    /// Each pin string must be in the format "sha256/<base64-encoded-hash>".
+    ///
+    /// - Parameter domainPins: Dictionary mapping domain names to arrays of pin strings.
+    public func configurePins(_ domainPins: [String: [String]]) {
+        for (domain, pinList) in domainPins {
+            let hashes = pinList.compactMap { pin -> String? in
+                // Accept "sha256/XXXXX" format — strip the prefix
+                if pin.hasPrefix("sha256/") {
+                    return String(pin.dropFirst(7))
+                }
+                return nil
+            }
+            if !hashes.isEmpty {
+                pins[domain.lowercased()] = hashes
+            }
+        }
+    }
+
+    /// Returns true if there are pins configured for the given host.
+    public func hasPins(for host: String) -> Bool {
+        return pins[host.lowercased()] != nil
+    }
+
+    /// Remove all configured pins.
+    public func clearPins() {
+        pins.removeAll()
+    }
+
+    // MARK: - URLSessionDelegate
+
+    public func urlSession(
+        _ session: URLSession,
+        didReceive challenge: URLAuthenticationChallenge,
+        completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void
+    ) {
+        guard challenge.protectionSpace.authenticationMethod == NSURLAuthenticationMethodServerTrust,
+              let serverTrust = challenge.protectionSpace.serverTrust else {
+            completionHandler(.performDefaultHandling, nil)
+            return
+        }
+
+        let host = challenge.protectionSpace.host.lowercased()
+
+        // If no pins configured for this host, use default handling
+        guard let expectedPins = pins[host] else {
+            completionHandler(.performDefaultHandling, nil)
+            return
+        }
+
+        // Evaluate the server trust
+        var error: CFError?
+        guard SecTrustEvaluateWithError(serverTrust, &error) else {
+            NSLog("[VueNative CertPin] Trust evaluation failed for %@: %@", host, error?.localizedDescription ?? "unknown")
+            completionHandler(.cancelAuthenticationChallenge, nil)
+            return
+        }
+
+        // Check each certificate in the chain against our pins
+        let certCount = SecTrustGetCertificateCount(serverTrust)
+        guard let certChain = SecTrustCopyCertificateChain(serverTrust) as? [SecCertificate] else {
+            completionHandler(.cancelAuthenticationChallenge, nil)
+            return
+        }
+        for i in 0..<certCount {
+            guard i < certChain.count else { continue }
+            let certificate = certChain[i]
+            let spkiHash = sha256OfSPKI(for: certificate)
+            if expectedPins.contains(spkiHash) {
+                completionHandler(.useCredential, URLCredential(trust: serverTrust))
+                return
+            }
+        }
+
+        // No pin matched — reject the connection
+        NSLog("[VueNative CertPin] Pin validation failed for %@. No matching pin found.", host)
+        completionHandler(.cancelAuthenticationChallenge, nil)
+    }
+
+    // MARK: - SPKI Hashing
+
+    /// Compute the base64-encoded SHA-256 hash of a certificate's Subject Public Key Info.
+    private func sha256OfSPKI(for certificate: SecCertificate) -> String {
+        guard let publicKey = SecCertificateCopyKey(certificate) else { return "" }
+
+        var error: Unmanaged<CFError>?
+        guard let publicKeyData = SecKeyCopyExternalRepresentation(publicKey, &error) as Data? else {
+            return ""
+        }
+
+        // Hash the raw public key data with SHA-256
+        var hash = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))
+        publicKeyData.withUnsafeBytes { bytes in
+            _ = CC_SHA256(bytes.baseAddress, CC_LONG(publicKeyData.count), &hash)
+        }
+
+        return Data(hash).base64EncodedString()
+    }
+}

package/native/shared/VueNativeShared/Sources/VueNativeShared/EventThrottle.swift

@@ -0,0 +1,78 @@
+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). Callers can customize via `interval`.
+public final class EventThrottle {
+
+    /// Minimum time between handler invocations (seconds).
+    public let interval: TimeInterval
+
+    /// The throttled handler to call.
+    private let handler: (Any?) -> Void
+
+    /// Timestamp of the last invocation.
+    private var lastFireTime: CFTimeInterval = 0
+
+    /// Whether a trailing call is pending.
+    private var pendingTrailing = false
+
+    /// The most recent payload, used for the trailing call.
+    private var latestPayload: Any?
+
+    /// Timer for delivering the trailing call.
+    private var trailingTimer: DispatchSourceTimer?
+
+    /// Create a throttled event handler.
+    /// - Parameters:
+    ///   - interval: Minimum seconds between invocations. Default 0.016 (~60fps).
+    ///   - handler: The closure to invoke with the event payload.
+    public init(interval: TimeInterval = 0.016, handler: @escaping (Any?) -> Void) {
+        self.interval = interval
+        self.handler = handler
+    }
+
+    deinit {
+        trailingTimer?.cancel()
+    }
+
+    /// Call this from the native event callback instead of the original handler.
+    /// Fires immediately if enough time has elapsed, otherwise schedules a trailing call.
+    public func fire(_ payload: Any?) {
+        let now = CACurrentMediaTime()
+        let elapsed = now - lastFireTime
+
+        latestPayload = payload
+
+        if elapsed >= interval {
+            // Enough time has passed — fire immediately
+            lastFireTime = now
+            pendingTrailing = false
+            trailingTimer?.cancel()
+            trailingTimer = nil
+            handler(payload)
+        } else if !pendingTrailing {
+            // Schedule a trailing call for the remaining time
+            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()
+        }
+        // If a trailing call is already pending, just update latestPayload (done above)
+    }
+}