feat: [DX-3212] extend provider API and fixed deprecated LocalAuthentication policies on macOS

Sources/LocalAuthenticationProvider/LAContext+Extensions.swift

@@ -10,20 +10,25 @@ import LocalAuthentication
 
 extension LAContext {
     internal func canEvaluate(policy: LocalAuthenticationPolicy, error: NSErrorPointer) -> Bool {
-        let localPolicy: LAPolicy
-        switch policy {
-        case .authentication:
-            localPolicy = .deviceOwnerAuthentication
-        case .biometrics:
-            localPolicy = .deviceOwnerAuthenticationWithBiometrics
-#if os(macOS)
-        case .watch:
-            localPolicy = .deviceOwnerAuthenticationWithWatch
-        case .biometricsOrWatch:
-            localPolicy = .deviceOwnerAuthenticationWithBiometricsOrWatch
-#endif
+        return self.canEvaluatePolicy(policy.laPolicy, error: error)
+    }
+
+    /// Resolves the biometric type supported by the current context.
+    var resolvedBiometricType: BiometricType {
+        if biometryType == .none {
+            return .none
         }
-
-        return self.canEvaluatePolicy(localPolicy, error: error)
+        if biometryType == .faceID {
+            return .faceID
+        }
+        if biometryType == .touchID {
+            return .touchID
+        }
+        if #available(iOS 17.0, macOS 14.0, *) {
+            if biometryType == .opticID {
+                return .opticID
+            }
+        }
+        return .none
     }
 }

Sources/LocalAuthenticationProvider/LocalAuthenticationPolicy+Extensions.swift

@@ -0,0 +1,25 @@
+//
+//  LocalAuthenticationPolicy+Extensions.swift
+//
+//
+//  Created by Artem Panasenko on 19.01.2026.
+//
+
+import LocalAuthentication
+
+extension LocalAuthenticationPolicy {
+    var laPolicy: LAPolicy {
+        switch self {
+        case .authentication:
+            return .deviceOwnerAuthentication
+        case .biometrics:
+            return .deviceOwnerAuthenticationWithBiometrics
+#if os(macOS)
+        case .watch:
+            return .deviceOwnerAuthentication
+        case .biometricsOrWatch:
+            return .deviceOwnerAuthentication
+#endif
+        }
+    }
+}

Sources/LocalAuthenticationProvider/LocalAuthenticationProvider.swift

@@ -76,7 +76,24 @@ public final class LocalAuthenticationProvider: LocalAuthenticationProviderProto
         _ = try await checkBiometricAvailable(with: .biometrics)
         do {
             return try await context.evaluatePolicy(
-                .deviceOwnerAuthenticationWithBiometrics, localizedReason: localizedReason
+                .deviceOwnerAuthenticationWithBiometrics,
+                localizedReason: localizedReason
+            )
+        } catch {
+            throw mapToLocalAuthenticationError(error, context: context)
+        }
+    }
+
+    /// Sets up authentication with biometry, Apple Watch, or the device passcode with the given localized reason, preparing for authentication but not initiating it immediately.
+    /// - Parameter localizedReason: A string explaining why authentication is being requested.
+    /// - Returns: `true` if  authentication was successfully set up, `false` otherwise.
+    /// - Throws: An appropriate `LocalAuthenticationError` if an error occurs during setup.
+    public func setOwnerAuthentication(localizedReason: String) async throws -> Bool {
+        _ = try await checkBiometricAvailable(with: .authentication)
+        do {
+            return try await context.evaluatePolicy(
+                .deviceOwnerAuthentication,
+                localizedReason: localizedReason
             )
         } catch {
             throw mapToLocalAuthenticationError(error, context: context)
@@ -103,26 +120,42 @@ public final class LocalAuthenticationProvider: LocalAuthenticationProviderProto
         return false
     }
 
+    /// Authenticates the user using policy authentication with given localized reason.
+    /// - Parameters:
+    ///   - police: `LocalAuthenticationPolicy`
+    ///   - localizedReason:  A string explaining why authentication is being requested.
+    /// - Returns: `true` if authentication was successful, `false` otherwise.
+    /// - Throws: An appropriate `LocalAuthenticationError` if an error occurs during authentication.
+    public func authenticate(with police: LocalAuthenticationPolicy, localizedReason: String) async throws -> Bool {
+        _ = try await checkBiometricAvailable(with: police)
+        guard context.biometryType != .none else {
+            logger.error("\(#function) User face or fingerprint were not recognized")
+            throw LocalAuthenticationError.biometricError
+        }
+        do {
+            if try await context.evaluatePolicy(police.laPolicy, localizedReason: localizedReason) {
+                return true
+            }
+        } catch {
+            throw mapToLocalAuthenticationError(error, context: context)
+        }
+        return false
+    }
+
     /// Retrieves the type of biometric authentication available on the device.
     /// - Returns: The available biometric type (.none, .touchID, .faceID, or .opticID if available).
     public func getBiometricType() async -> BiometricType {
         let result = context.canEvaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, error: nil)
         logger.log("\(#function) evaluated policy with result \(result)")
-        if context.biometryType == .none {
-            return .none
-        }
-        if context.biometryType == .faceID {
-            return .faceID
-        }
-        if context.biometryType == .touchID {
-            return .touchID
-        }
-        if #available(iOS 17.0, macOS 14.0, *) {
-            if context.biometryType == .opticID {
-                return .opticID
-            }
-        }
-        return .none
+        return context.resolvedBiometricType
+    }
+
+    /// Retrieves the type of  authentication for policy available on the device.
+    /// - Returns: The available biometric type (.none, .touchID, .faceID, or .opticID if available).
+    public func getBiometricType(for policy: LocalAuthenticationPolicy) async -> BiometricType {
+        let result = context.canEvaluatePolicy(policy.laPolicy, error: nil)
+        logger.log("\(#function) evaluated policy with result \(result)")
+        return context.resolvedBiometricType
     }
 
     /// Maps an `Error` to a corresponding `LocalAuthenticationError` for consistent error handling.

Sources/LocalAuthenticationProvider/LocalAuthenticationProviderProtocol.swift

@@ -40,15 +40,36 @@ public protocol LocalAuthenticationProviderProtocol {
     /// - Throws: An appropriate `LocalAuthenticationError` if an error occurs during setup.
     func setBiometricAuthentication(localizedReason: String) async throws -> Bool
 
+    /// Sets up authentication with biometry, Apple Watch, or the device passcode with the given localized reason, preparing for authentication but not initiating it immediately.
+    ///
+    /// - Parameter localizedReason: A string explaining why authentication is being requested.
+    /// - Returns: `true` if  authentication was successfully set up, `false` otherwise.
+    /// - Throws: An appropriate `LocalAuthenticationError` if an error occurs during setup.
+    func setOwnerAuthentication(localizedReason: String) async throws -> Bool
+
     /// Authenticates the user using biometric authentication with the given localized reason.
     ///
     /// - Parameter localizedReason: A string explaining why authentication is being requested.
     /// - Returns: `true` if authentication was successful, `false` otherwise.
     /// - Throws: An appropriate `LocalAuthenticationError` if an error occurs during authentication.
     func authenticate(localizedReason: String) async throws -> Bool
 
+    /// Authenticates the user using policy authentication with given localized reason.
+    ///
+    /// - Parameters:
+    ///   - police: `LocalAuthenticationPolicy`
+    ///   - localizedReason:  A string explaining why authentication is being requested.
+    /// - Returns: `true` if authentication was successful, `false` otherwise.
+    /// - Throws: An appropriate `LocalAuthenticationError` if an error occurs during authentication.
+    func authenticate(with police: LocalAuthenticationPolicy, localizedReason: String) async throws -> Bool
+
     /// Retrieves the type of biometric authentication available on the device.
     ///
     /// - Returns: The available biometric type (.none, .touchID, .faceID, or .opticID if available).
     func getBiometricType() async -> BiometricType
+
+    /// Retrieves the type of  authentication for policy available on the device.
+    ///
+    /// - Returns: The available biometric type (.none, .touchID, .faceID, or .opticID if available).
+    func getBiometricType(for policy: LocalAuthenticationPolicy) async -> BiometricType
 }

Tests/LocalAuthenticationProviderTests/LocalAuthProviderLAErrorCasesTests.swift

@@ -165,7 +165,7 @@ final class LocalAuthProviderLAErrorCasesTests: XCTestCase {
         } catch {
         }
     }
-#if compiler(>=6.0)
+#if compiler(>=6.0) && os(iOS)
     @available(iOS 18.0, *)
         func testMapToLocalAuthenticationErrorCompanionNotAvailable() async {
             let context = MockLAContext(

Tests/LocalAuthenticationProviderTests/LocalAuthenticationProviderTests.swift

@@ -148,6 +148,17 @@ final class LocalAuthenticationProviderTests: XCTestCase {
         }
     }
 
+    func testEvaluatePolicyWhenAuthenticationSetSuccessful() async throws {
+        let context = MockLAContext(
+            successEvaluatePolicies: [.deviceOwnerAuthentication],
+            canEvaluatePolicies: [.deviceOwnerAuthentication])
+        let provider = LocalAuthenticationProvider(context: context)
+        let successResult = try await provider.setOwnerAuthentication(
+            localizedReason: "Please authenticate yourself for activate Biometric authentication"
+        )
+        XCTAssert(successResult)
+    }
+
     func testEvaluatePolicyWhenBiometricsSetSuccessful() async throws {
         let context = MockLAContext(
             successEvaluatePolicies: [.deviceOwnerAuthenticationWithBiometrics],
@@ -194,6 +205,19 @@ final class LocalAuthenticationProviderTests: XCTestCase {
         }
     }
 
+    func testAuthenticationWhenSuccessCheckAuthenticationType() async throws {
+        let context = MockLAContext(
+            successEvaluatePolicies: [.deviceOwnerAuthentication],
+            canEvaluatePolicies: [.deviceOwnerAuthentication],
+            biometryType: .faceID)
+        let provider = LocalAuthenticationProvider(context: context)
+        let successResult = try await provider.authenticate(
+            with: .authentication,
+            localizedReason: "Please authenticate yourself for activate Biometric authentication"
+        )
+        XCTAssert(successResult)
+    }
+
     func testAuthenticationWhenSuccessCheckBiometryType() async throws {
         let context = MockLAContext(
             successEvaluatePolicies: [.deviceOwnerAuthenticationWithBiometrics],
@@ -217,6 +241,30 @@ final class LocalAuthenticationProviderTests: XCTestCase {
         XCTAssertFalse(failedResult)
     }
 
+    func testGetBiometryTypeWithWhenSuccess() async throws {
+        var context = MockLAContext(biometryType: .none)
+        var provider = LocalAuthenticationProvider(context: context)
+        let nonType = await provider.getBiometricType(for: .authentication)
+
+        XCTAssert(nonType == .none)
+
+        context = MockLAContext(biometryType: .faceID)
+        provider = LocalAuthenticationProvider(context: context)
+        let faceIDType = await provider.getBiometricType(for: .authentication)
+        XCTAssert(faceIDType == .faceID)
+
+        context = MockLAContext(biometryType: .touchID)
+        provider = LocalAuthenticationProvider(context: context)
+        let touchIDType = await provider.getBiometricType(for: .authentication)
+        XCTAssert(touchIDType == .touchID)
+        if #available(iOS 17.0, macOS 14.0, *) {
+            context = MockLAContext(biometryType: .opticID)
+            provider = LocalAuthenticationProvider(context: context)
+            let opticIDType = await provider.getBiometricType(for: .authentication)
+            XCTAssert(opticIDType == .opticID)
+        }
+    }
+
     func testGetBiometryTypeWhenSuccess() async throws {
         var context = MockLAContext(biometryType: .none)
         var provider = LocalAuthenticationProvider(context: context)
@@ -273,6 +321,7 @@ final class LocalAuthenticationProviderTests: XCTestCase {
             XCTFail("Unexpected error thrown: \(error)")
         }
     }
+
     func testMapToLocalAuthenticationError_WhenNSErrorIsCaught() async {
         class MockNSError: NSError, @unchecked Sendable {}
         let errorDomain = LAError.errorDomain