@clerk/expo-native-components 0.0.0-stage → 0.0.1

package/ios/ClerkNativeViewHost.swift

@@ -0,0 +1,204 @@
+import ExpoModulesCore
+import UIKit
+
+public class ClerkNativeViewHost: ExpoView {
+  private lazy var hostingCoordinator = ClerkNativeHostingCoordinator(containerView: self)
+  private var hasInitialized: Bool = false
+  private var configuredObserver: NSObjectProtocol?
+
+  public required init(appContext: AppContext? = nil) {
+    super.init(appContext: appContext)
+  }
+
+  @available(*, unavailable)
+  public required init?(coder: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  deinit {
+    removeConfiguredObserver()
+  }
+
+  override public func didMoveToWindow() {
+    super.didMoveToWindow()
+
+    guard window != nil else {
+      if hasInitialized {
+        hostedViewDidDetachFromWindow()
+      }
+      removeConfiguredObserver()
+      hostingCoordinator.detach()
+      hasInitialized = false
+      return
+    }
+
+    guard !hasInitialized else { return }
+    hasInitialized = true
+    addConfiguredObserver()
+    hostedViewDidAttachToWindow()
+    updateHostedView()
+  }
+
+  override public func layoutSubviews() {
+    super.layoutSubviews()
+    hostingCoordinator.layout()
+  }
+
+  func setNeedsHostedViewUpdate() {
+    guard hasInitialized else { return }
+    updateHostedView()
+  }
+
+  func makeHostedController() -> UIViewController? {
+    nil
+  }
+
+  // Subclasses can observe attach/detach without making this host know about their RN event props.
+  func hostedViewDidAttachToWindow() {}
+
+  func hostedViewDidDetachFromWindow() {}
+
+  private func addConfiguredObserver() {
+    guard configuredObserver == nil else { return }
+
+    configuredObserver = NotificationCenter.default.addObserver(
+      forName: .clerkNativeSDKDidConfigure,
+      object: nil,
+      queue: .main
+    ) { [weak self] _ in
+      guard let self, !hostingCoordinator.hasAttachedController else { return }
+      setNeedsHostedViewUpdate()
+    }
+  }
+
+  private func removeConfiguredObserver() {
+    guard let configuredObserver else { return }
+    NotificationCenter.default.removeObserver(configuredObserver)
+    self.configuredObserver = nil
+  }
+
+  private func updateHostedView() {
+    guard let controller = makeHostedController() else { return }
+    hostingCoordinator.attach(controller)
+  }
+}
+
+public class ClerkUserProfileCustomPageHost: ClerkNativeViewHost {
+  private var currentCustomPages: String = "[]"
+  let customPageState = ClerkUserProfileCustomPageState()
+
+  // Expo resolves event dispatchers through `Mirror(reflecting:).children`, which skips
+  // inherited properties, so subclasses must own the dispatcher and surface it here.
+  var customPageEventDispatcher: EventDispatcher? { nil }
+
+  public required init(appContext: AppContext? = nil) {
+    super.init(appContext: appContext)
+    customPageState.setPageEventHandler { [weak self] type, path in
+      self?.customPageEventDispatcher?(["type": type, "path": path])
+    }
+  }
+
+  func setCustomPages(_ customPages: String?) {
+    let newCustomPages = customPages ?? "[]"
+    guard newCustomPages != currentCustomPages else { return }
+    let validPaths = Set(decodeUserProfileCustomPages(newCustomPages).map(\.path))
+    customPageState.reconcileCustomPagePaths(validPaths)
+    currentCustomPages = newCustomPages
+    setNeedsHostedViewUpdate()
+  }
+
+  func navigateCustomPage(action: String, routeKey: String?) {
+    customPageState.navigate(action: action, routeKey: routeKey)
+  }
+
+  func customRows() -> [ClerkUserProfileCustomRowConfig] {
+    parseUserProfileCustomPages(currentCustomPages, pageCount: customPageState.views.count)
+  }
+
+#if RCT_NEW_ARCH_ENABLED
+  override public func mountChildComponentView(_ childComponentView: UIView, index: Int) {
+    customPageState.insertView(childComponentView, at: index)
+    setNeedsHostedViewUpdate()
+  }
+
+  override public func unmountChildComponentView(_ childComponentView: UIView, index: Int) {
+    customPageState.removeView(childComponentView)
+    setNeedsHostedViewUpdate()
+  }
+#else
+  override public func insertReactSubview(_ subview: UIView!, at atIndex: Int) {
+    super.insertReactSubview(subview, at: atIndex)
+    customPageState.insertView(subview, at: atIndex)
+    setNeedsHostedViewUpdate()
+  }
+
+  override public func removeReactSubview(_ subview: UIView!) {
+    customPageState.removeView(subview)
+    super.removeReactSubview(subview)
+    setNeedsHostedViewUpdate()
+  }
+
+  override public func didUpdateReactSubviews() {}
+#endif
+}
+
+private final class ClerkNativeHostingCoordinator {
+  private weak var containerView: UIView?
+  private var hostingController: UIViewController?
+
+  var hasAttachedController: Bool {
+    hostingController != nil
+  }
+
+  init(containerView: UIView) {
+    self.containerView = containerView
+  }
+
+  func attach(_ controller: UIViewController) {
+    detach()
+
+    guard let containerView else { return }
+
+    controller.view.frame = containerView.bounds
+    controller.view.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+
+    if let parentVC = findViewController(from: containerView) {
+      parentVC.addChild(controller)
+      containerView.addSubview(controller.view)
+      controller.didMove(toParent: parentVC)
+    } else {
+      containerView.addSubview(controller.view)
+    }
+
+    hostingController = controller
+  }
+
+  func detach() {
+    guard let controller = hostingController else { return }
+
+    if controller.parent != nil {
+      controller.willMove(toParent: nil)
+    }
+    controller.view.removeFromSuperview()
+    if controller.parent != nil {
+      controller.removeFromParent()
+    }
+    hostingController = nil
+  }
+
+  func layout() {
+    guard let containerView else { return }
+    hostingController?.view.frame = containerView.bounds
+  }
+
+  private func findViewController(from view: UIView) -> UIViewController? {
+    var responder: UIResponder? = view
+    while let nextResponder = responder?.next {
+      if let vc = nextResponder as? UIViewController {
+        return vc
+      }
+      responder = nextResponder
+    }
+    return nil
+  }
+}

package/ios/ClerkUserButtonNativeView.swift

@@ -0,0 +1,34 @@
+import ExpoModulesCore
+import UIKit
+
+public class ClerkUserButtonNativeView: ClerkUserProfileCustomPageHost {
+  let onCustomPageEvent = EventDispatcher()
+
+  override var customPageEventDispatcher: EventDispatcher? { onCustomPageEvent }
+
+  override func makeHostedController() -> UIViewController? {
+    return ClerkNativeBridge.shared.makeUserButtonViewController(
+      customRows: customRows(),
+      customPageState: customPageState
+    )
+  }
+}
+
+public class ClerkUserButtonViewModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("ClerkUserButtonView")
+
+    View(ClerkUserButtonNativeView.self) {
+      Events("onCustomPageEvent")
+
+      Prop("customPages") { (view: ClerkUserButtonNativeView, customPages: String?) in
+        view.setCustomPages(customPages)
+      }
+
+      AsyncFunction("navigateCustomPage") {
+        (view: ClerkUserButtonNativeView, action: String, routeKey: String?) in
+        view.navigateCustomPage(action: action, routeKey: routeKey)
+      }
+    }
+  }
+}

package/ios/ClerkUserProfileNativeView.swift

@@ -0,0 +1,92 @@
+import ExpoModulesCore
+import UIKit
+
+public class ClerkUserProfileNativeView: ClerkUserProfileCustomPageHost {
+  private var currentDismissible: Bool = true
+  private var currentHostBackButton: Bool = false
+  private var didSendDismiss = false
+
+  let onProfileEvent = EventDispatcher()
+  let onHostBack = EventDispatcher()
+  let onCustomPageEvent = EventDispatcher()
+
+  override var customPageEventDispatcher: EventDispatcher? { onCustomPageEvent }
+
+  func setDismissible(_ isDismissible: Bool?) {
+    let newDismissible = isDismissible ?? true
+    guard newDismissible != currentDismissible else { return }
+    currentDismissible = newDismissible
+    setNeedsHostedViewUpdate()
+  }
+
+  func setHostBackButton(_ hostBackButton: Bool?) {
+    let newHostBackButton = hostBackButton ?? false
+    guard newHostBackButton != currentHostBackButton else { return }
+    currentHostBackButton = newHostBackButton
+    setNeedsHostedViewUpdate()
+  }
+
+  private func sendProfileEvent(type: ClerkNativeViewEvent) {
+    onProfileEvent(["type": type.rawValue])
+  }
+
+  private func sendDismissIfNeeded() {
+    // SwiftUI dismissals detach the hosted view without calling UIKit dismiss().
+    guard currentDismissible, !didSendDismiss else { return }
+    didSendDismiss = true
+    sendProfileEvent(type: .dismissed)
+  }
+
+  override func hostedViewDidAttachToWindow() {
+    didSendDismiss = false
+  }
+
+  override func hostedViewDidDetachFromWindow() {
+    sendDismissIfNeeded()
+  }
+
+  override func makeHostedController() -> UIViewController? {
+    let hostBackAction: (() -> Void)? = currentHostBackButton
+      ? { [weak self] in self?.onHostBack([:]) }
+      : nil
+
+    return ClerkNativeBridge.shared.makeUserProfileViewController(
+      dismissible: currentDismissible,
+      customRows: customRows(),
+      customPageState: customPageState,
+      hostBackAction: hostBackAction,
+      onEvent: { [weak self] event, _ in
+        if event == .dismissed {
+          self?.sendDismissIfNeeded()
+        }
+      }
+    )
+  }
+}
+
+public class ClerkUserProfileViewModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("ClerkUserProfileView")
+
+    View(ClerkUserProfileNativeView.self) {
+      Events("onProfileEvent", "onCustomPageEvent", "onHostBack")
+
+      Prop("isDismissible") { (view: ClerkUserProfileNativeView, isDismissible: Bool?) in
+        view.setDismissible(isDismissible)
+      }
+
+      Prop("hostBackButton") { (view: ClerkUserProfileNativeView, hostBackButton: Bool?) in
+        view.setHostBackButton(hostBackButton)
+      }
+
+      Prop("customPages") { (view: ClerkUserProfileNativeView, customPages: String?) in
+        view.setCustomPages(customPages)
+      }
+
+      AsyncFunction("navigateCustomPage") {
+        (view: ClerkUserProfileNativeView, action: String, routeKey: String?) in
+        view.navigateCustomPage(action: action, routeKey: routeKey)
+      }
+    }
+  }
+}

package/ios/Tests/ClerkAuthNativeViewPaperTests.swift

@@ -0,0 +1,30 @@
+#if !RCT_NEW_ARCH_ENABLED
+import ExpoModulesCore
+import UIKit
+import XCTest
+import ClerkExpo
+
+final class ClerkAuthNativeViewPaperTests: XCTestCase {
+  @MainActor
+  func testAddingAndRemovingLogoAfterMountKeepsReactChildOutOfHostHierarchy() {
+    let window = UIWindow(frame: UIScreen.main.bounds)
+    let viewController = UIViewController()
+    let authView = ClerkAuthNativeView(appContext: nil)
+    window.rootViewController = viewController
+    viewController.view.addSubview(authView)
+    window.makeKeyAndVisible()
+
+    let logoView = UIView(frame: CGRect(x: 0, y: 0, width: 120, height: 40))
+    authView.insertReactSubview(logoView, at: 0)
+    authView.didUpdateReactSubviews()
+
+    XCTAssertFalse(logoView.superview === authView)
+
+    authView.removeReactSubview(logoView)
+    authView.didUpdateReactSubviews()
+
+    XCTAssertNil(logoView.superview)
+    window.isHidden = true
+  }
+}
+#endif

package/ios/Tests/ClerkNativeBridgeTests.swift

@@ -0,0 +1,185 @@
+import XCTest
+import ClerkKit
+@testable import ClerkExpo
+
+final class ClerkNativeBridgeTests: XCTestCase {
+  @MainActor
+  func testBiometricCredentialAvailabilityIsUnavailableBeforeConfiguration() async throws {
+    let availability = try await ClerkNativeBridge.shared.getBiometricCredentialAvailability(
+      id: nil,
+      identifierHint: nil
+    )
+
+    XCTAssertEqual(availability["isAvailable"] as? Bool, false)
+    XCTAssertEqual(availability["unavailableReason"] as? String, "environment_unavailable")
+  }
+
+  @MainActor
+  func testBiometricCredentialOperationsRejectBeforeConfiguration() async {
+    await assertEnvironmentUnavailable {
+      try await ClerkNativeBridge.shared.reverifyWithBiometrics(
+        sessionId: "sess_test", level: "multi_factor", reason: nil
+      )
+    }
+    await assertEnvironmentUnavailable {
+      try await ClerkNativeBridge.shared.listBiometricCredentials()
+    }
+    await assertEnvironmentUnavailable {
+      try await ClerkNativeBridge.shared.enrollBiometricCredential(
+        deviceName: nil,
+        identifierHint: nil,
+        reason: nil,
+        policy: "biometry_or_device_passcode"
+      )
+    }
+    await assertEnvironmentUnavailable {
+      try await ClerkNativeBridge.shared.revokeBiometricCredential(id: "td_test")
+    }
+    await assertEnvironmentUnavailable {
+      try await ClerkNativeBridge.shared.signInWithBiometrics(
+        id: nil,
+        identifierHint: nil,
+        reason: nil
+      )
+    }
+  }
+
+  func testBiometricReverificationLevels() throws {
+    XCTAssertEqual(try ClerkNativeBridge.biometricReverificationLevel("first_factor"), .firstFactor)
+    XCTAssertEqual(try ClerkNativeBridge.biometricReverificationLevel("second_factor"), .secondFactor)
+    XCTAssertEqual(try ClerkNativeBridge.biometricReverificationLevel("multi_factor"), .multiFactor)
+    XCTAssertThrowsError(try ClerkNativeBridge.biometricReverificationLevel("unknown"))
+  }
+
+  func testBiometricReverificationPayloadWithoutEmbeddedSession() {
+    let verification = SessionVerification(id: "stepup_test", status: .complete, level: .multiFactor)
+    let payload = ClerkNativeBridge.biometricReverificationPayload(verification, sessionId: "sess_test")
+    XCTAssertEqual(payload["id"] as? String, "stepup_test")
+    XCTAssertEqual(payload["status"] as? String, "complete")
+    XCTAssertEqual(payload["level"] as? String, "multi_factor")
+    XCTAssertEqual(payload["sessionId"] as? String, "sess_test")
+  }
+
+  @MainActor
+  func testBiometricReverificationContinuesToSecondFactor() async throws {
+    var factors: [Session.BiometricVerificationLevel] = []
+    let started = SessionVerification(id: "stepup_test", status: .needsFirstFactor, level: .multiFactor)
+    let result = try await ClerkNativeBridge.verifyBiometricReverification(started) { factor in
+      factors.append(factor)
+      return SessionVerification(id: started.id, status: factor == .firstFactor ? .needsSecondFactor : .complete,
+                                 level: .multiFactor)
+    }
+    XCTAssertEqual(factors, [.firstFactor, .secondFactor])
+    XCTAssertEqual(result.id, started.id)
+    XCTAssertEqual(result.status, .complete)
+  }
+
+  @MainActor
+  func testBiometricReverificationPromptsOnlyForRequiredFactors() async throws {
+    for status in [SessionVerification.Status.needsFirstFactor, .needsSecondFactor, .complete] {
+      var factors: [Session.BiometricVerificationLevel] = []
+      let started = SessionVerification(id: "stepup_test", status: status, level: .multiFactor)
+      let result = try await ClerkNativeBridge.verifyBiometricReverification(started) { factor in
+        factors.append(factor)
+        return SessionVerification(id: started.id, status: .complete, level: .multiFactor)
+      }
+      XCTAssertEqual(factors, status == .complete ? [] : [status == .needsFirstFactor ? .firstFactor : .secondFactor])
+      XCTAssertEqual(result.status, .complete)
+    }
+  }
+
+  @MainActor
+  func testBiometricReverificationDoesNotRetryAnIncompleteSecondFactor() async throws {
+    var factors: [Session.BiometricVerificationLevel] = []
+    let started = SessionVerification(status: .needsFirstFactor, level: .multiFactor)
+    let result = try await ClerkNativeBridge.verifyBiometricReverification(started) { factor in
+      factors.append(factor)
+      return SessionVerification(status: .needsSecondFactor, level: .multiFactor)
+    }
+    XCTAssertEqual(factors, [.firstFactor, .secondFactor])
+    XCTAssertEqual(result.status, .needsSecondFactor)
+  }
+
+  @MainActor
+  func testBiometricReverificationPreservesFactorFailures() async {
+    for failingFactor in [Session.BiometricVerificationLevel.firstFactor, .secondFactor] {
+      var factors: [Session.BiometricVerificationLevel] = []
+      let expected = NSError(domain: "biometric_authentication_canceled", code: 1)
+      do {
+        _ = try await ClerkNativeBridge.verifyBiometricReverification(
+          SessionVerification(status: .needsFirstFactor, level: .multiFactor)
+        ) { factor in
+          factors.append(factor)
+          if factor == failingFactor { throw expected }
+          return SessionVerification(status: .needsSecondFactor, level: .multiFactor)
+        }
+        XCTFail("Expected the factor failure to propagate.")
+      } catch {
+        XCTAssertEqual(error as NSError, expected)
+      }
+      XCTAssertEqual(factors, failingFactor == .firstFactor ? [.firstFactor] : [.firstFactor, .secondFactor])
+    }
+  }
+
+  @MainActor
+  func testCancellationBetweenBiometricFactorsStopsContinuation() async {
+    var factors: [Session.BiometricVerificationLevel] = []
+    let task = Task { @MainActor in
+      try await ClerkNativeBridge.verifyBiometricReverification(
+        SessionVerification(status: .needsFirstFactor, level: .multiFactor)
+      ) { factor in
+        factors.append(factor)
+        withUnsafeCurrentTask { $0?.cancel() }
+        return SessionVerification(status: .needsSecondFactor, level: .multiFactor)
+      }
+    }
+    do {
+      _ = try await task.value
+      XCTFail("Expected cancellation to stop the second factor.")
+    } catch {
+      XCTAssertTrue(error is CancellationError)
+    }
+    XCTAssertEqual(factors, [.firstFactor])
+  }
+
+  @MainActor
+  func testUnknownBiometricVerificationStatusDoesNotPrompt() async {
+    do {
+      _ = try await ClerkNativeBridge.verifyBiometricReverification(
+        SessionVerification(status: .unknown("future_status"), level: .multiFactor)
+      ) { _ in
+        XCTFail("An unknown status must not prompt.")
+        return SessionVerification(status: .complete, level: .multiFactor)
+      }
+      XCTFail("Expected an unsupported status error.")
+    } catch {
+      XCTAssertEqual(ClerkNativeBridge.biometricCredentialErrorDescriptor(error, fallbackCode: "unexpected").code,
+                     "E_BIOMETRIC_REVERIFICATION_FAILED")
+    }
+  }
+
+  func testBiometricReverificationPreservesNativePolicyError() {
+    let error = BiometricCredentialError.policyIncompatible
+    let result = ClerkNativeBridge.biometricCredentialErrorDescriptor(error, fallbackCode: "unexpected")
+    XCTAssertEqual(result.code, "biometric_credential_policy_incompatible")
+    XCTAssertEqual(result.message, error.localizedDescription)
+  }
+
+  @MainActor
+  private func assertEnvironmentUnavailable(
+    _ operation: @MainActor () async throws -> Any,
+    file: StaticString = #filePath,
+    line: UInt = #line
+  ) async {
+    do {
+      _ = try await operation()
+      XCTFail("Expected biometric-credential operation to reject before configuration.", file: file, line: line)
+    } catch {
+      let descriptor = ClerkNativeBridge.biometricCredentialErrorDescriptor(
+        error,
+        fallbackCode: "unexpected_error"
+      )
+      XCTAssertEqual(descriptor.code, "environment_unavailable", file: file, line: line)
+    }
+  }
+}

package/ios/Tests/ClerkNativeViewHostTests.swift

@@ -0,0 +1,66 @@
+import UIKit
+import XCTest
+@testable import ClerkExpo
+
+final class ClerkNativeViewHostTests: XCTestCase {
+  @MainActor
+  func testConfigureNotificationDoesNotReplaceAttachedController() {
+    let hostView = TestClerkNativeViewHost(appContext: nil)
+    let controller = UIViewController()
+    hostView.controller = controller
+    let window = mountInWindow(hostView)
+    let callsBeforeNotification = hostView.makeHostedControllerCallCount
+
+    NotificationCenter.default.post(name: .clerkNativeSDKDidConfigure, object: nil)
+
+    XCTAssertEqual(hostView.makeHostedControllerCallCount, callsBeforeNotification)
+    XCTAssertTrue(controller.view.superview === hostView)
+    unmount(hostView, from: window)
+  }
+
+  @MainActor
+  func testConfigureNotificationAttachesControllerWhenInitiallyUnavailable() {
+    let hostView = TestClerkNativeViewHost(appContext: nil)
+    let window = mountInWindow(hostView)
+    let callsBeforeConfiguration = hostView.makeHostedControllerCallCount
+    let controller = UIViewController()
+    hostView.controller = controller
+
+    NotificationCenter.default.post(name: .clerkNativeSDKDidConfigure, object: nil)
+
+    XCTAssertEqual(hostView.makeHostedControllerCallCount, callsBeforeConfiguration + 1)
+    XCTAssertTrue(controller.view.superview === hostView)
+
+    NotificationCenter.default.post(name: .clerkNativeSDKDidConfigure, object: nil)
+
+    XCTAssertEqual(hostView.makeHostedControllerCallCount, callsBeforeConfiguration + 1)
+    unmount(hostView, from: window)
+  }
+
+  @MainActor
+  private func mountInWindow(_ hostView: UIView) -> UIWindow {
+    let window = UIWindow(frame: UIScreen.main.bounds)
+    let viewController = UIViewController()
+    window.rootViewController = viewController
+    viewController.view.addSubview(hostView)
+    window.makeKeyAndVisible()
+    return window
+  }
+
+  @MainActor
+  private func unmount(_ hostView: UIView, from window: UIWindow) {
+    hostView.removeFromSuperview()
+    window.isHidden = true
+  }
+}
+
+@MainActor
+private final class TestClerkNativeViewHost: ClerkNativeViewHost {
+  var controller: UIViewController?
+  private(set) var makeHostedControllerCallCount = 0
+
+  override func makeHostedController() -> UIViewController? {
+    makeHostedControllerCallCount += 1
+    return controller
+  }
+}