catalyst-core 0.3.0-beta.5 → 0.3.0-canary.2

package/dist/native/iosnativeWebView/CoreLogic/Tests/CatalystCoreLogicTests/NotificationHandlerProviderTests.swift

@@ -0,0 +1,59 @@
+import XCTest
+@testable import CatalystCoreLogic
+
+/// A minimal, test-local stub used only to prove NotificationHandlerProvider
+/// actually stores and returns whatever is injected — distinct from
+/// NullNotificationHandler so identity comparison is meaningful.
+private final class StubNotificationHandler: NotificationHandlerProtocol {
+    func requestPermission() async -> Bool { true }
+    func getPermissionStatusString() async -> String { "GRANTED" }
+    func scheduleLocal(_ config: NotificationConfig) -> String { "stub-id" }
+    func cancelLocal(_ notificationId: String) -> Bool { true }
+    func cancelAllLocal() {}
+    func initializePush() async -> (token: String?, error: String?) { ("stub-token", nil) }
+    func subscribeToTopic(_ topic: String) async -> Bool { true }
+    func unsubscribeFromTopic(_ topic: String) async -> Bool { true }
+    func getSubscribedTopics() async -> [String] { ["stub-topic"] }
+    func updateBadge(_ count: Int) {}
+    func setNavigationHandler(_ handler: @escaping (URL) -> Void) {}
+}
+
+/**
+ * Unit tests for NotificationHandlerProvider
+ *
+ * Covers the default (NullNotificationHandler) value and inject() replacing
+ * it — the two lines of real logic in this 3-line file.
+ */
+final class NotificationHandlerProviderTests: XCTestCase {
+
+    override func tearDown() {
+        // Restore the default so other tests / files aren't affected by
+        // this file's injection (NotificationHandlerProvider.shared is
+        // process-global mutable state).
+        NotificationHandlerProvider.shared = NullNotificationHandler.shared
+        super.tearDown()
+    }
+
+    func testDefaultShared_IsNullNotificationHandler() {
+        NotificationHandlerProvider.shared = NullNotificationHandler.shared
+        XCTAssertTrue(NotificationHandlerProvider.shared as AnyObject === NullNotificationHandler.shared)
+    }
+
+    func testInject_ReplacesSharedHandler() {
+        let stub = StubNotificationHandler()
+
+        NotificationHandlerProvider.inject(stub)
+
+        XCTAssertTrue(NotificationHandlerProvider.shared as AnyObject === stub)
+        XCTAssertFalse(NotificationHandlerProvider.shared as AnyObject === NullNotificationHandler.shared)
+    }
+
+    func testInject_InjectedHandlerBehavesAsProvided() async {
+        let stub = StubNotificationHandler()
+        NotificationHandlerProvider.inject(stub)
+
+        let granted = await NotificationHandlerProvider.shared.requestPermission()
+
+        XCTAssertTrue(granted)
+    }
+}

package/dist/native/iosnativeWebView/{iosnativeWebViewTests → CoreLogic/Tests/CatalystCoreLogicTests}/NotificationHandlerTests.swift

@@ -1,6 +1,6 @@
 import XCTest
 import Foundation
-@testable import CatalystCore
+@testable import CatalystCoreLogic
 
 /**
  * Unit tests for NotificationHandler

package/dist/native/iosnativeWebView/{iosnativeWebViewTests → CoreLogic/Tests/CatalystCoreLogicTests}/URLWhitelistManagerTests.swift

@@ -1,5 +1,5 @@
 import XCTest
-@testable import CatalystCore
+@testable import CatalystCoreLogic
 
 /// Unit tests for URLWhitelistManager
 /// Tests pattern matching, access control, URL cleaning, and thread safety

package/dist/native/iosnativeWebView/CoreLogic/Tests/CatalystCoreLogicTests/VideoStreamStateMachineTests.swift

@@ -0,0 +1,171 @@
+import XCTest
+@testable import CatalystCoreLogic
+
+/// A test-local listener that records every callback it receives, and can
+/// be used to exercise both the notification path and the weak-reference
+/// compaction path (by letting it deallocate while still registered).
+private final class RecordingListener: VideoStreamStateListener {
+    struct Event: Equatable {
+        let prev: String
+        let next: String
+    }
+
+    private(set) var events: [Event] = []
+
+    func onStateChanged(prev: VideoStreamState, next: VideoStreamState) {
+        events.append(Event(prev: describe(prev), next: describe(next)))
+    }
+
+    private func describe(_ state: VideoStreamState) -> String {
+        switch state {
+        case .idle: return "idle"
+        case .starting: return "starting"
+        case .streaming: return "streaming"
+        case .hold: return "hold"
+        case .flipping: return "flipping"
+        case .stopping: return "stopping"
+        }
+    }
+}
+
+/**
+ * Unit tests for VideoStreamStateMachine
+ *
+ * Covers: initial state, valid/invalid transitions, isActive derivation,
+ * listener add/remove/notify, and weak-listener compaction on dealloc.
+ */
+final class VideoStreamStateMachineTests: XCTestCase {
+
+    func testInitialState_IsIdle() {
+        let machine = VideoStreamStateMachine()
+        XCTAssertEqual(machine.state, .idle)
+        XCTAssertFalse(machine.isActive)
+    }
+
+    func testValidTransition_UpdatesStateAndReturnsTrue() {
+        let machine = VideoStreamStateMachine()
+
+        let result = machine.transition(to: .starting)
+
+        XCTAssertTrue(result)
+        XCTAssertEqual(machine.state, .starting)
+    }
+
+    func testInvalidTransition_LeavesStateUnchangedAndReturnsFalse() {
+        let machine = VideoStreamStateMachine()
+
+        // idle -> streaming is not a valid direct transition
+        let result = machine.transition(to: .streaming)
+
+        XCTAssertFalse(result)
+        XCTAssertEqual(machine.state, .idle)
+    }
+
+    func testIsActive_TrueWhileStreamingHoldOrFlipping() {
+        let machine = VideoStreamStateMachine()
+
+        machine.transition(to: .starting)
+        machine.transition(to: .streaming)
+        XCTAssertTrue(machine.isActive)
+
+        machine.transition(to: .hold)
+        XCTAssertTrue(machine.isActive)
+
+        machine.transition(to: .streaming)
+        machine.transition(to: .flipping)
+        XCTAssertTrue(machine.isActive)
+    }
+
+    func testIsActive_FalseOnceStopped() {
+        let machine = VideoStreamStateMachine()
+
+        machine.transition(to: .starting)
+        machine.transition(to: .streaming)
+        machine.transition(to: .stopping)
+        XCTAssertFalse(machine.isActive)
+
+        machine.transition(to: .idle)
+        XCTAssertFalse(machine.isActive)
+    }
+
+    func testListener_ReceivesNotificationOnValidTransition() {
+        let machine = VideoStreamStateMachine()
+        let listener = RecordingListener()
+        machine.addListener(listener)
+
+        machine.transition(to: .starting)
+
+        XCTAssertEqual(listener.events, [.init(prev: "idle", next: "starting")])
+    }
+
+    func testListener_DoesNotFireOnInvalidTransition() {
+        let machine = VideoStreamStateMachine()
+        let listener = RecordingListener()
+        machine.addListener(listener)
+
+        let result = machine.transition(to: .streaming) // idle -> streaming is invalid
+
+        XCTAssertFalse(result)
+        XCTAssertTrue(listener.events.isEmpty)
+    }
+
+    func testListener_ReceivesMultipleSequentialTransitions() {
+        let machine = VideoStreamStateMachine()
+        let listener = RecordingListener()
+        machine.addListener(listener)
+
+        machine.transition(to: .starting)
+        machine.transition(to: .streaming)
+        machine.transition(to: .stopping)
+        machine.transition(to: .idle)
+
+        XCTAssertEqual(listener.events, [
+            .init(prev: "idle", next: "starting"),
+            .init(prev: "starting", next: "streaming"),
+            .init(prev: "streaming", next: "stopping"),
+            .init(prev: "stopping", next: "idle"),
+        ])
+    }
+
+    func testRemoveListener_StopsFurtherNotifications() {
+        let machine = VideoStreamStateMachine()
+        let listener = RecordingListener()
+        machine.addListener(listener)
+
+        machine.transition(to: .starting)
+        machine.removeListener(listener)
+        machine.transition(to: .streaming)
+
+        XCTAssertEqual(listener.events, [.init(prev: "idle", next: "starting")])
+    }
+
+    func testWeakListener_DeallocatedListenerDoesNotCrashOnNextTransition() {
+        let machine = VideoStreamStateMachine()
+
+        // Register a listener that immediately goes out of scope; the
+        // WeakListenerBox holding it should be compacted away on the next
+        // transition rather than crash on a dangling reference.
+        autoreleasepool {
+            let shortLived = RecordingListener()
+            machine.addListener(shortLived)
+        }
+
+        // Should not crash, and should still perform the transition normally.
+        let result = machine.transition(to: .starting)
+        XCTAssertTrue(result)
+        XCTAssertEqual(machine.state, .starting)
+    }
+
+    func testMultipleListeners_AllReceiveNotification() {
+        let machine = VideoStreamStateMachine()
+        let listenerA = RecordingListener()
+        let listenerB = RecordingListener()
+        machine.addListener(listenerA)
+        machine.addListener(listenerB)
+
+        machine.transition(to: .starting)
+
+        XCTAssertEqual(listenerA.events, [.init(prev: "idle", next: "starting")])
+        XCTAssertEqual(listenerB.events, [.init(prev: "idle", next: "starting")])
+    }
+}

package/dist/native/iosnativeWebView/CoreLogic/Tests/CatalystCoreLogicTests/VideoStreamStateTests.swift

@@ -0,0 +1,91 @@
+import XCTest
+@testable import CatalystCoreLogic
+
+/**
+ * Unit tests for VideoStreamState
+ *
+ * Exhaustive truth-table coverage of the state transition rules documented
+ * directly in VideoStreamState.swift:
+ *
+ *   IDLE      → STARTING  (start() called)
+ *   STARTING  → STREAMING (session running)
+ *   STARTING  → IDLE      (permission denied or bind failure)
+ *   STREAMING → HOLD      (QR detected)
+ *   HOLD      → STREAMING (hold expired)
+ *   STREAMING → FLIPPING  (flip() called)
+ *   FLIPPING  → STREAMING (rebind complete)
+ *   STREAMING → STOPPING  (stop() called)
+ *   FLIPPING  → STOPPING  (stop() called mid-flip)
+ *   HOLD      → STOPPING  (stop() called during hold)
+ *   STOPPING  → IDLE      (session torn down)
+ *
+ * Every other (from, to) pair among the 6 states must be rejected.
+ */
+final class VideoStreamStateTests: XCTestCase {
+
+    private static let allStates: [VideoStreamState] = [
+        .idle, .starting, .streaming, .hold, .flipping, .stopping,
+    ]
+
+    /// The exact set of valid transitions, mirroring the doc comment above.
+    private static let validTransitions: Set<[String]> = [
+        ["idle", "starting"],
+        ["starting", "streaming"],
+        ["starting", "idle"],
+        ["streaming", "hold"],
+        ["hold", "streaming"],
+        ["streaming", "flipping"],
+        ["flipping", "streaming"],
+        ["streaming", "stopping"],
+        ["flipping", "stopping"],
+        ["hold", "stopping"],
+        ["stopping", "idle"],
+    ]
+
+    private func name(_ state: VideoStreamState) -> String {
+        switch state {
+        case .idle: return "idle"
+        case .starting: return "starting"
+        case .streaming: return "streaming"
+        case .hold: return "hold"
+        case .flipping: return "flipping"
+        case .stopping: return "stopping"
+        }
+    }
+
+    func testCanTransitionTo_ExhaustiveTruthTable() {
+        for from in Self.allStates {
+            for to in Self.allStates {
+                let expected = Self.validTransitions.contains([name(from), name(to)])
+                let actual = from.canTransitionTo(to)
+                XCTAssertEqual(
+                    actual, expected,
+                    "canTransitionTo mismatch: \(name(from)) -> \(name(to)), expected \(expected), got \(actual)"
+                )
+            }
+        }
+    }
+
+    func testIsActive_StreamingHoldFlippingAreActive() {
+        XCTAssertTrue(VideoStreamState.streaming.isActive)
+        XCTAssertTrue(VideoStreamState.hold.isActive)
+        XCTAssertTrue(VideoStreamState.flipping.isActive)
+    }
+
+    func testIsActive_IdleStartingStoppingAreNotActive() {
+        XCTAssertFalse(VideoStreamState.idle.isActive)
+        XCTAssertFalse(VideoStreamState.starting.isActive)
+        XCTAssertFalse(VideoStreamState.stopping.isActive)
+    }
+
+    func testIsActive_AllStatesCoveredExactlyOnce() {
+        // Sanity check that the two tests above between them cover every
+        // case in the enum — guards against silently missing a case if the
+        // enum ever grows.
+        let activeCount = Self.allStates.filter { $0.isActive }.count
+        let inactiveCount = Self.allStates.filter { !$0.isActive }.count
+        XCTAssertEqual(activeCount, 3)
+        XCTAssertEqual(inactiveCount, 3)
+        XCTAssertEqual(activeCount + inactiveCount, Self.allStates.count)
+    }
+}

package/dist/native/iosnativeWebView/Package.swift

@@ -6,11 +6,12 @@ import PackageDescription
 // TODO: haven't made this conditional yet
 let package = Package(
     name: "iosnativeWebView",
-    platforms: [.iOS(.v17)],
+    platforms: [.iOS(.v17), .macOS(.v13)],
     products: [
         .library(name: "CatalystCore", targets: ["CatalystCore"])
     ],
     dependencies: [
+        .package(path: "CoreLogic"),
         .package(url: "https://github.com/kylef/JSONSchema.swift", from: "0.6.0"),
         .package(url: "https://github.com/google/GoogleSignIn-iOS", from: "7.0.0")
     ],
@@ -20,18 +21,18 @@ let package = Package(
         .target(
             name: "CatalystCore",
             dependencies: [
+                .product(name: "CatalystCoreLogic", package: "CoreLogic"),
                 .product(name: "JSONSchema", package: "JSONSchema.swift"),
                 .product(name: "GoogleSignIn", package: "GoogleSignIn-iOS")
             ],
             path: "Sources/Core"
-        ),
-        // Test target for CatalystCore
-        // Tests are excluded from npm package via .npmignore
-        // Run with: swift test (from iosnativeWebView directory)
-        .testTarget(
-            name: "CatalystCoreTests",
-            dependencies: ["CatalystCore"],
-            path: "Tests/CatalystCoreTests"
         )
+        // Note: no .testTarget here for CatalystCore's own simulator-based tests
+        // (iosnativeWebViewTests) — those are declared and run via the Xcode
+        // project/scheme, not `swift test` at this package root. The
+        // CatalystCoreLogicTests test target lives in the nested CoreLogic/
+        // package (see CoreLogic/Package.swift) so `swift test --package-path
+        // CoreLogic` can run with zero simulator, zero remote dependency
+        // resolution.
     ]
 )

package/dist/native/iosnativeWebView/Sources/CatalystNotifications/LocalNotificationHandler.swift

@@ -3,6 +3,7 @@ import UserNotifications
 import UIKit
 import os
 import CatalystCore
+import CatalystCoreLogic
 
 private let logger = Logger(subsystem: Bundle.main.bundleIdentifier ?? "com.app", category: "LocalNotificationHandler")
 
@@ -194,7 +195,11 @@ class LocalNotificationHandler: NSObject, UNUserNotificationCenterDelegate {
         completionHandler()
     }
 
-    func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification, withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
+    func userNotificationCenter(
+        _ center: UNUserNotificationCenter,
+        willPresent notification: UNNotification,
+        withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void
+    ) {
 
         // Show notification even when app is in foreground
         // Check if notification has sound (vibrate enabled)
@@ -290,4 +295,4 @@ class LocalNotificationHandler: NSObject, UNUserNotificationCenterDelegate {
         return url
     }
 
-}
+}

package/dist/native/iosnativeWebView/Sources/CatalystNotifications/NotificationManager.swift

@@ -3,6 +3,7 @@ import UserNotifications
 import UIKit
 import os
 import CatalystCore
+import CatalystCoreLogic
 import FirebaseCore
 import FirebaseMessaging
 
@@ -16,7 +17,6 @@ public final class NotificationManager: ObservableObject, NotificationHandlerPro
     private var navigationHandler: ((URL) -> Void)?
     private var baseURL: String = ""
 
-
     private init() {
         self.localHandler = LocalNotificationHandler(baseURL: "")
         self.pushHandler = PushNotificationHandler()
@@ -62,7 +62,6 @@ public final class NotificationManager: ObservableObject, NotificationHandlerPro
         NotificationChannelManager.setupChannels()
     }
 
-
     // MARK: - Permission Management
 
     public func requestPermission() async -> Bool {

package/dist/native/iosnativeWebView/Sources/CatalystNotifications/PushNotificationHandler.swift

@@ -2,6 +2,7 @@ import Foundation
 import UIKit
 import os
 import CatalystCore
+import CatalystCoreLogic
 import FirebaseMessaging
 import FirebaseCore
 
@@ -66,19 +67,19 @@ class PushNotificationHandler: NSObject {
                     }
                 }
             }
-            
+
             // Task 2: Timeout after 30 seconds
             group.addTask {
                 try? await Task.sleep(nanoseconds: 30_000_000_000) // 30 seconds
                 return (nil, "FCM token request timed out after 30 seconds. Check network connectivity and Firebase configuration.")
             }
-            
+
             // Return the first result (either token or timeout)
             if let result = await group.next() {
                 group.cancelAll()
                 return result
             }
-            
+
             return (nil, "Unknown error getting FCM token")
         }
         #endif
@@ -196,4 +197,4 @@ extension PushNotificationHandler: MessagingDelegate {
         self.fcmToken = fcmToken
         onTokenRefresh?(fcmToken)
     }
-}
+}

package/dist/native/iosnativeWebView/Sources/Core/Camera/CameraSessionManager.swift

@@ -2,6 +2,7 @@ import Foundation
 import AVFoundation
 import UIKit
 import os
+import CatalystCoreLogic
 
 private let logger = Logger(subsystem: Bundle.main.bundleIdentifier ?? "com.app", category: "CameraSessionManager")
 

package/dist/native/iosnativeWebView/Sources/Core/Camera/HoldController.swift

@@ -1,5 +1,6 @@
 import Foundation
 import os
+import CatalystCoreLogic
 
 private let logger = Logger(subsystem: Bundle.main.bundleIdentifier ?? "com.app", category: "HoldController")
 

package/dist/native/iosnativeWebView/Sources/Core/Camera/NativeCameraManager.swift

@@ -2,6 +2,7 @@ import Foundation
 import AVFoundation
 import UIKit
 import os
+import CatalystCoreLogic
 
 private let logger = Logger(subsystem: Bundle.main.bundleIdentifier ?? "com.app", category: "NativeCameraManager")
 
@@ -76,8 +77,8 @@ public class NativeCameraManager: ObservableObject {
             onZoomChanged: { zoomLevel, minZoom, maxZoom in
                 let payload: [String: Any] = [
                     "zoomLevel": round(Double(zoomLevel) * 10) / 10,
-                    "minZoom":   round(Double(minZoom)   * 10) / 10,
-                    "maxZoom":   round(Double(maxZoom)   * 10) / 10
+                    "minZoom": round(Double(minZoom)   * 10) / 10,
+                    "maxZoom": round(Double(maxZoom)   * 10) / 10
                 ]
                 eBox.call("ON_ZOOM_CHANGED", payload)
             }
@@ -96,15 +97,15 @@ public class NativeCameraManager: ObservableObject {
             zoomController: zoomController,
             torchController: torchController,
             barcodeDetector: barcodeDetector,
-            onReady:   { eBox.call("ON_VIDEO_STREAM_READY",   nil) },
+            onReady: { eBox.call("ON_VIDEO_STREAM_READY", nil) },
             onStopped: { eBox.call("ON_VIDEO_STREAM_STOPPED", nil) },
-            onError:   { msg in errBox.call(msg) }
+            onError: { msg in errBox.call(msg) }
         )
 
         holdController = HoldController(stateMachine: sm, barcodeDetector: barcodeDetector)
 
         // Wire detection handler now that holdController exists
-        barcodeDetector.detectionHandler = { [weak holdController, weak sm] value, type, bounds in
+        barcodeDetector.detectionHandler = { [weak holdController, weak sm] value, type, _ in
             guard sm?.state != .hold else { return }
             guard let hc = holdController else { return }
             if hc.isNewValue(value) {

package/dist/native/iosnativeWebView/Sources/Core/Camera/ZoomController.swift

@@ -2,6 +2,7 @@ import Foundation
 import AVFoundation
 import UIKit
 import os
+import CatalystCoreLogic
 
 private let logger = Logger(subsystem: Bundle.main.bundleIdentifier ?? "com.app", category: "ZoomController")
 

package/dist/native/iosnativeWebView/Sources/Core/Plugins/PluginBridge.swift

@@ -2,6 +2,7 @@ import Foundation
 import WebKit
 import UIKit
 import os
+import CatalystCoreLogic
 
 private let pluginBridgeLogger = Logger(subsystem: Bundle.main.bundleIdentifier ?? "com.app", category: "PluginBridge")