chore: update TCA to version 1.23.0

Package.swift

@@ -19,7 +19,7 @@ let package = Package(
       targets: ["Lockman"])
   ],
   dependencies: [
-    .package(url: "https://github.com/pointfreeco/swift-composable-architecture", exact: "1.22.3"),
+    .package(url: "https://github.com/pointfreeco/swift-composable-architecture", exact: "1.23.0"),
     .package(url: "https://github.com/swiftlang/swift-syntax", "509.0.0"..<"603.0.0"),
     .package(url: "https://github.com/pointfreeco/swift-macro-testing", from: "0.6.3"),
     .package(url: "https://github.com/apple/swift-collections.git", from: "1.1.0"),

Package@swift-6.0.swift

@@ -19,7 +19,7 @@ let package = Package(
       targets: ["Lockman"])
   ],
   dependencies: [
-    .package(url: "https://github.com/pointfreeco/swift-composable-architecture", exact: "1.22.3"),
+    .package(url: "https://github.com/pointfreeco/swift-composable-architecture", exact: "1.23.0"),
     .package(url: "https://github.com/swiftlang/swift-syntax", "509.0.0"..<"603.0.0"),
     .package(url: "https://github.com/pointfreeco/swift-macro-testing", from: "0.6.3"),
     .package(url: "https://github.com/apple/swift-collections.git", from: "1.1.0"),

Sources/Lockman/Composable/Effect+Lockman.swift

@@ -82,15 +82,18 @@ extension Effect {
       unlockOption: unlockOption,
       onSuccess: { action, unlock in
         let shouldBeCancellable = action.createLockmanInfo().isCancellationTarget
-        let cancellableEffect = shouldBeCancellable ? concatenatedEffect.cancellable(id: boundaryId) : concatenatedEffect
+        let cancellableEffect =
+          shouldBeCancellable ? concatenatedEffect.cancellable(id: boundaryId) : concatenatedEffect
         return Effect<Action>.concatenate([cancellableEffect, .run { _ in unlock() }])
       },
       onSuccessWithPrecedingCancellation: { action, error, unlock in
         let shouldBeCancellable = action.createLockmanInfo().isCancellationTarget
-        let cancellableEffect = shouldBeCancellable ? concatenatedEffect.cancellable(id: boundaryId) : concatenatedEffect
+        let cancellableEffect =
+          shouldBeCancellable ? concatenatedEffect.cancellable(id: boundaryId) : concatenatedEffect
         let completeEffect = Effect<Action>.concatenate([cancellableEffect, .run { _ in unlock() }])
-
-        let cancellationError = LockmanCancellationError(action: action, boundaryId: boundaryId, reason: error)
+
+        let cancellationError = LockmanCancellationError(
+          action: action, boundaryId: boundaryId, reason: error)
         if let lockFailure = lockFailure {
           return .concatenate([
             .run { send in await lockFailure(cancellationError, send) },
@@ -101,7 +104,8 @@ extension Effect {
         return .concatenate([.cancel(id: boundaryId), completeEffect])
       },
       onCancel: { action, error in
-        let cancellationError = LockmanCancellationError(action: action, boundaryId: boundaryId, reason: error)
+        let cancellationError = LockmanCancellationError(
+          action: action, boundaryId: boundaryId, reason: error)
         if let lockFailure = lockFailure {
           return .run { send in await lockFailure(cancellationError, send) }
         }
@@ -200,15 +204,18 @@ extension Effect {
       unlockOption: unlockOption,
       onSuccess: { action, unlock in
         let shouldBeCancellable = action.createLockmanInfo().isCancellationTarget
-        let cancellableEffect = shouldBeCancellable ? operation.cancellable(id: boundaryId) : operation
+        let cancellableEffect =
+          shouldBeCancellable ? operation.cancellable(id: boundaryId) : operation
         return Effect<Action>.concatenate([cancellableEffect, .run { _ in unlock() }])
       },
       onSuccessWithPrecedingCancellation: { action, error, unlock in
         let shouldBeCancellable = action.createLockmanInfo().isCancellationTarget
-        let cancellableEffect = shouldBeCancellable ? operation.cancellable(id: boundaryId) : operation
+        let cancellableEffect =
+          shouldBeCancellable ? operation.cancellable(id: boundaryId) : operation
         let completeEffect = Effect<Action>.concatenate([cancellableEffect, .run { _ in unlock() }])
-
-        let cancellationError = LockmanCancellationError(action: action, boundaryId: boundaryId, reason: error)
+
+        let cancellationError = LockmanCancellationError(
+          action: action, boundaryId: boundaryId, reason: error)
         if let lockFailure = lockFailure {
           return .concatenate([
             .run { send in await lockFailure(cancellationError, send) },
@@ -219,7 +226,8 @@ extension Effect {
         return .concatenate([.cancel(id: boundaryId), completeEffect])
       },
       onCancel: { action, error in
-        let cancellationError = LockmanCancellationError(action: action, boundaryId: boundaryId, reason: error)
+        let cancellationError = LockmanCancellationError(
+          action: action, boundaryId: boundaryId, reason: error)
         if let lockFailure = lockFailure {
           return .run { send in await lockFailure(cancellationError, send) }
         }

Sources/Lockman/Composable/LockmanReducer.swift

@@ -99,9 +99,12 @@ public struct LockmanReducer<Base: Reducer>: Reducer {
           let effect = self.base.reduce(into: &state, action: action)
           let shouldBeCancellable = lockmanAction.createLockmanInfo().isCancellationTarget
           let cancellableEffect = shouldBeCancellable ? effect.cancellable(id: boundaryId) : effect
-          let completeEffect = Effect<Action>.concatenate([cancellableEffect, .run { _ in unlock() }])
-
-          let cancellationError = LockmanCancellationError(action: lockmanAction, boundaryId: boundaryId, reason: error)
+          let completeEffect = Effect<Action>.concatenate([
+            cancellableEffect, .run { _ in unlock() },
+          ])
+
+          let cancellationError = LockmanCancellationError(
+            action: lockmanAction, boundaryId: boundaryId, reason: error)
           if let lockFailure = lockFailure {
             return .concatenate([
               .run { send in await lockFailure(cancellationError, send) },
@@ -112,7 +115,8 @@ public struct LockmanReducer<Base: Reducer>: Reducer {
           return .concatenate([.cancel(id: boundaryId), completeEffect])
         },
         onCancel: { _, error in
-          let cancellationError = LockmanCancellationError(action: lockmanAction, boundaryId: boundaryId, reason: error)
+          let cancellationError = LockmanCancellationError(
+            action: lockmanAction, boundaryId: boundaryId, reason: error)
           if let lockFailure = lockFailure {
             return .run { send in await lockFailure(cancellationError, send) }
           }

Sources/Lockman/Core/LockmanManager.swift

@@ -322,7 +322,7 @@ extension LockmanManager {
   ///   action: action,
   ///   boundaryId: boundaryId,
   ///   unlockOption: nil,
-  ///   onSuccess: { _, unlock in 
+  ///   onSuccess: { _, unlock in
   ///     defer { unlock() }
   ///     performWork()
   ///     return true
@@ -346,29 +346,31 @@ extension LockmanManager {
     boundaryId: B,
     unlockOption: LockmanUnlockOption?,
     onSuccess: (A, @escaping @Sendable () -> Void) -> T,
-    onSuccessWithPrecedingCancellation: (A, any LockmanPrecedingCancellationError, @escaping @Sendable () -> Void) -> T,
+    onSuccessWithPrecedingCancellation: (
+      A, any LockmanPrecedingCancellationError, @escaping @Sendable () -> Void
+    ) -> T,
     onCancel: (A, any LockmanError) -> T,
     onError: (A, any Error) -> T
   ) -> T {
     do {
       // Capture lockmanInfo once to ensure consistent uniqueId throughout lock lifecycle
       let lockmanInfo = action.createLockmanInfo()
-      
+
       // Acquire lock with integrated unlock token
       let result = try acquireLock(
         lockmanInfo: lockmanInfo,
         boundaryId: boundaryId,
         unlockOption: unlockOption ?? action.unlockOption
       )
-      
+
       // Handle lock result with callback execution
       switch result {
       case .success(let unlockToken):
         return onSuccess(action, unlockToken.callAsFunction)
-        
+
       case .successWithPrecedingCancellation(let unlockToken, let error):
         return onSuccessWithPrecedingCancellation(action, error, unlockToken.callAsFunction)
-        
+
       case .cancel(let error):
         return onCancel(action, error)
       }

Sources/Lockman/Core/LockmanResult.swift

@@ -1,4 +1,3 @@
-
 /// The result of attempting to acquire a lock with integrated unlock capability.
 ///
 /// This enum represents the possible outcomes when a strategy attempts

Sources/Lockman/Core/Strategies/Core/LockmanStrategyResult.swift

@@ -74,10 +74,13 @@ extension LockmanStrategyResult {
       return true
     case (.cancel(let lhsError), .cancel(let rhsError)):
       return String(describing: lhsError) == String(describing: rhsError)
-    case (.successWithPrecedingCancellation(let lhsError), .successWithPrecedingCancellation(let rhsError)):
+    case (
+      .successWithPrecedingCancellation(let lhsError),
+      .successWithPrecedingCancellation(let rhsError)
+    ):
       return String(describing: lhsError) == String(describing: rhsError)
     default:
       return false
     }
   }
-}
+}

Tests/LockmanTests/Supports/TestSupport.swift

@@ -167,7 +167,9 @@ public final class TestSingleExecutionStrategy: LockmanStrategy, @unchecked Send
     LockmanStrategyId(name: "TestSingleExecutionStrategy")
   }
 
-  public func canLock<B: LockmanBoundaryId>(boundaryId: B, info: TestLockmanInfo) -> LockmanStrategyResult {
+  public func canLock<B: LockmanBoundaryId>(boundaryId: B, info: TestLockmanInfo)
+    -> LockmanStrategyResult
+  {
     lock.withLock {
       if lockedActions.contains(info.actionId) {
         let error = LockmanCancellationError(