├── .spi.yml
├── .gitignore
├── Sources
    └── AsyncButton
    │   ├── UnlocalizedError.swift
    │   ├── AnyLocalizedError.swift
    │   ├── AsyncButtonOperations.swift
    │   ├── AsyncButtonOptions.swift
    │   └── AsyncButton.swift
├── .swiftpm
    └── xcode
    │   └── package.xcworkspace
    │       └── xcshareddata
    │           └── IDEWorkspaceChecks.plist
├── Package.swift
└── README.md


/.spi.yml:
--------------------------------------------------------------------------------
1 | version: 1
2 | builder:
3 |   configs:
4 |     - documentation_targets: ["AsyncButton"]
5 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | .DS_Store
 2 | /.build
 3 | /Packages
 4 | /*.xcodeproj
 5 | xcuserdata/
 6 | DerivedData/
 7 | .swiftpm/config/registries.json
 8 | .swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
 9 | .netrc
10 | 


--------------------------------------------------------------------------------
/Sources/AsyncButton/UnlocalizedError.swift:
--------------------------------------------------------------------------------
 1 | import Foundation
 2 | 
 3 | struct UnlocalizedError: LocalizedError {
 4 |     
 5 |     let errorDescription: String?
 6 |     
 7 |     init(error: Error) {
 8 |         self.errorDescription = error.localizedDescription
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/.swiftpm/xcode/package.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
3 | <plist version="1.0">
4 | <dict>
5 | 	<key>IDEDidComputeMac32BitWarning</key>
6 | 	<true/>
7 | </dict>
8 | </plist>
9 | 


--------------------------------------------------------------------------------
/Sources/AsyncButton/AnyLocalizedError.swift:
--------------------------------------------------------------------------------
 1 | import Foundation
 2 | 
 3 | struct AnyLocalizedError: LocalizedError {
 4 |     
 5 |     let errorDescription: String?
 6 |     
 7 |     let failureReason: String?
 8 |     
 9 |     let recoverySuggestion: String?
10 |     
11 |     let helpAnchor: String?
12 |     
13 |     init(erasing localizedError: LocalizedError) {
14 |         errorDescription = localizedError.errorDescription
15 |         failureReason = localizedError.failureReason
16 |         recoverySuggestion = localizedError.recoverySuggestion
17 |         helpAnchor = localizedError.helpAnchor
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/Package.swift:
--------------------------------------------------------------------------------
 1 | // swift-tools-version: 5.7
 2 | 
 3 | import PackageDescription
 4 | 
 5 | let package = Package(
 6 |     name: "swiftui-async-button",
 7 |     platforms: [
 8 |         .iOS(.v16),
 9 |         .macOS(.v13),
10 |         .tvOS(.v16),
11 |         .watchOS(.v9)
12 |     ],
13 |     products: [
14 |         .library(
15 |             name: "AsyncButton",
16 |             targets: ["AsyncButton"]),
17 |     ],
18 |     targets: [
19 |         .target(
20 |             name: "AsyncButton",
21 |             dependencies: [],
22 |             path: "Sources")
23 |     ]
24 | )
25 | 
26 | #if swift(>=5.6)
27 | // Add the documentation compiler plugin if possible
28 | package.dependencies.append(
29 |     .package(url: "https://github.com/apple/swift-docc-plugin", from: "1.0.0")
30 | )
31 | #endif
32 | 


--------------------------------------------------------------------------------
/Sources/AsyncButton/AsyncButtonOperations.swift:
--------------------------------------------------------------------------------
 1 | public enum AsyncButtonOperation {
 2 |     
 3 |     case loading(Task<Void, Error>)
 4 |     case completed(Task<Void, Error>, Result<Void, Error>)
 5 |     
 6 |     var task: Task<Void, Error> {
 7 |         switch self {
 8 |         case .loading(let task):
 9 |             return task
10 |         case .completed(let task, _):
11 |             return task
12 |         }
13 |     }
14 | }
15 | 
16 | extension AsyncButtonOperation: Equatable {
17 |     
18 |     public static func == (lhs: AsyncButtonOperation, rhs: AsyncButtonOperation) -> Bool {
19 |         if case .loading(let lhsTask) = lhs, case .loading(let rhsTask) = rhs  {
20 |             return lhsTask == rhsTask
21 |         } else if case .completed(let lhsTask, _) = lhs, case .completed(let rhsTask, _) = rhs  {
22 |             return lhsTask == rhsTask
23 |         } else {
24 |             return false
25 |         }
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/Sources/AsyncButton/AsyncButtonOptions.swift:
--------------------------------------------------------------------------------
 1 | //
 2 | //  File.swift
 3 | //  
 4 | //
 5 | //  Created by Lorenzo Fiamingo on 27/06/22.
 6 | //
 7 | 
 8 | import Foundation
 9 | 
10 | public struct AsyncButtonOptions: OptionSet {
11 |     
12 |     public let rawValue: Int
13 |     
14 |     public static let disableButtonOnLoading       = AsyncButtonOptions(rawValue: 1 << 0)
15 |     public static let showProgressViewOnLoading    = AsyncButtonOptions(rawValue: 1 << 1)
16 |     public static let showAlertOnError             = AsyncButtonOptions(rawValue: 1 << 2)
17 |     public static let disallowParallelOperations   = AsyncButtonOptions(rawValue: 1 << 3)
18 |     public static let enableNotificationFeedback   = AsyncButtonOptions(rawValue: 1 << 4)
19 |     public static let enableTintFeedback           = AsyncButtonOptions(rawValue: 1 << 5)
20 |     
21 |     public static let all: AsyncButtonOptions = [.disableButtonOnLoading, .showProgressViewOnLoading, .showAlertOnError, .disallowParallelOperations, .enableNotificationFeedback, .enableTintFeedback]
22 |     public static let automatic: AsyncButtonOptions = [.disableButtonOnLoading, .showProgressViewOnLoading, .showAlertOnError, .disallowParallelOperations, .enableNotificationFeedback]
23 |     
24 |     public init(rawValue: Int) {
25 |         self.rawValue = rawValue
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # SwiftUI AsyncButton 🖲️
 2 | 
 3 | `AsyncButton` is a `Button` capable of running concurrent code. 
 4 | 
 5 | 
 6 | ## Usage
 7 | 
 8 | `AsyncButton` has the exact same API as `Button`, so you just have to change this:
 9 | ```swift
10 | Button("Run") { run() }
11 | ```
12 | to this:
13 | ```swift
14 | AsyncButton("Run") { try await run() }
15 | ```
16 | 
17 | In addition to `Button` initializers, you have the possibilities to specify special behaviours via `AsyncButtonOptions`:
18 | ```swift
19 | AsyncButton("Ciao", options: [.showProgressViewOnLoading, .showAlertOnError], transaction: Transaction(animation: .default)) {
20 |     try await run()
21 | }
22 | ```
23 | 
24 | For heavy customizations you can have access to the `AsyncButtonOperation`s:
25 | 
26 | ```swift
27 | AsyncButton {
28 |     try await run()
29 | } label: { operations in
30 |     if operations.contains { operation in
31 |         if case .loading = operation {
32 |             return true
33 |         } else {
34 |             return false
35 |         }
36 |     } {
37 |         Text("Loading")
38 |     } else if
39 |         let last = operations.last,
40 |         case .completed(_, let result) = last
41 |     {
42 |         switch result {
43 |         case .failure:
44 |             Text("Try again")
45 |         case .success:
46 |             Text("Run again")
47 |         }
48 |     } else {
49 |         Text("Run")
50 |     }
51 | }
52 | ```
53 | 
54 | ## Installation
55 | 
56 | 1. In Xcode, open your project and navigate to **File** → **Swift Packages** → **Add Package Dependency...**
57 | 2. Paste the repository URL (`https://github.com/lorenzofiamingo/swiftui-async-button`) and click **Next**.
58 | 3. Click **Finish**.
59 | 
60 | 
61 | ## Other projects
62 | 
63 | [SwiftUI VariadicViews 🥞](https://github.com/lorenzofiamingo/swiftui-variadic-views)
64 | 
65 | [SwiftUI CachedAsyncImage 🗃️](https://github.com/lorenzofiamingo/swiftui-cached-async-image)
66 | 
67 | [SwiftUI MapItemPicker 🗺️](https://github.com/lorenzofiamingo/swiftui-map-item-picker)
68 | 
69 | [SwiftUI PhotosPicker 🌇](https://github.com/lorenzofiamingo/swiftui-photos-picker)
70 | 
71 | [SwiftUI VerticalTabView 🔝](https://github.com/lorenzofiamingo/swiftui-vertical-tab-view)
72 | 
73 | [SwiftUI SharedObject 🍱](https://github.com/lorenzofiamingo/swiftui-shared-object)
74 | 


--------------------------------------------------------------------------------
/Sources/AsyncButton/AsyncButton.swift:
--------------------------------------------------------------------------------
  1 | import SwiftUI
  2 | 
  3 | public struct AsyncButton<Label> : View where Label : View {
  4 |     private let role: ButtonRole?
  5 |     private let options: AsyncButtonOptions
  6 |     private let transaction: Transaction
  7 |     private let action: () async throws -> Void
  8 |     private let label: ([AsyncButtonOperation]) -> Label
  9 |     
 10 |     @State private var operations: [AsyncButtonOperation] = []
 11 |     @State private var showingErrorAlert = false
 12 |     @State private var localizedError: AnyLocalizedError?
 13 | 
 14 |     #if os(iOS)
 15 |         private let generator = UINotificationFeedbackGenerator()
 16 |     #endif
 17 | 
 18 |     @State private var tint: Color?
 19 |     
 20 |     var operationIsLoading: Bool {
 21 |         operations.contains { operation in
 22 |             if case .loading = operation {
 23 |                 return true
 24 |             } else {
 25 |                 return false
 26 |             }
 27 |         }
 28 |     }
 29 |     
 30 |     var showProgressView: Bool {
 31 |         options.contains(.showProgressViewOnLoading) && operationIsLoading
 32 |     }
 33 |     
 34 |     var disableButton: Bool {
 35 |         options.contains(.disableButtonOnLoading) && operationIsLoading
 36 |     }
 37 |     
 38 |     public var body: some View {
 39 |         Button(
 40 |             role: role,
 41 |             action: {
 42 |                 if options.contains(.disallowParallelOperations) {
 43 |                     guard operationIsLoading == false else { return }
 44 |                 }
 45 |                 let actionTask = Task {
 46 |                     try await action()
 47 |                 }
 48 |                 operations.append(.loading(actionTask))
 49 |                 Task {
 50 |                     if options.contains(.enableNotificationFeedback) {
 51 |                         #if os(iOS)
 52 |                             generator.prepare()
 53 |                         #endif
 54 |                     }
 55 |                     let result = await actionTask.result
 56 |                     let index = operations.lastIndex { operation in
 57 |                         if case .loading(let task) = operation {
 58 |                             return task == actionTask
 59 |                         } else {
 60 |                             return false
 61 |                         }
 62 |                     }
 63 |                     operations[index!] = .completed(actionTask, result)
 64 |                     #if os(iOS)
 65 |                         if options.contains(.enableNotificationFeedback) {
 66 |                             switch result {
 67 |                             case .success:
 68 |                                 generator.notificationOccurred(.success)
 69 |                             case .failure:
 70 |                                 generator.notificationOccurred(.error)
 71 |                             }
 72 |                         }
 73 |                     #endif
 74 |                     if options.contains(.enableTintFeedback) {
 75 |                         withAnimation(.linear(duration: 0.1)) {
 76 |                             switch result {
 77 |                             case .success:
 78 |                                 tint = .green
 79 |                             case .failure:
 80 |                                 tint = .red
 81 |                             }
 82 |                         }
 83 |                         withAnimation(.linear(duration: 0.2).delay(1.5)) {
 84 |                             tint = nil
 85 |                         }
 86 |                     }
 87 |                     if options.contains(.showAlertOnError) {
 88 |                         if case .failure(let error) = result {
 89 |                             let localizedError = error as? LocalizedError ?? UnlocalizedError(error: error)
 90 |                             self.localizedError = AnyLocalizedError(erasing: localizedError)
 91 |                             showingErrorAlert = true
 92 |                         }
 93 |                     }
 94 |                 }
 95 |             },
 96 |             label: {
 97 |                 label(operations)
 98 |                     .opacity(showProgressView ? 0 : 1)
 99 |                     .overlay {
100 |                         if showProgressView {
101 |                             ProgressView()
102 |                         }
103 |                     }
104 |             }
105 |         )
106 |         .disabled(disableButton)
107 |         .animation(transaction.animation, value: operations)
108 |         .tint(tint)
109 |         .alert(isPresented: $showingErrorAlert, error: localizedError) { error in
110 |             Button("OK") {
111 |                 showingErrorAlert = false
112 |             }
113 |         } message: { error in
114 |             if let message = error.failureReason ?? error.recoverySuggestion ?? error.helpAnchor {
115 |                 Text(message)
116 |             }
117 |         }
118 | 
119 |     }
120 |     
121 |     public init(
122 |         role: ButtonRole? = nil,
123 |         options: AsyncButtonOptions = [],
124 |         transaction: Transaction = Transaction(),
125 |         action: @escaping () async throws -> Void,
126 |         @ViewBuilder label: @escaping ([AsyncButtonOperation]) -> Label
127 |     ) {
128 |         self.role = role
129 |         self.options = options
130 |         self.transaction = transaction
131 |         self.action = action
132 |         self.label = label
133 |     }
134 | }
135 | 
136 | extension AsyncButton {
137 |     
138 |     public init(
139 |         role: ButtonRole? = nil,
140 |         options: AsyncButtonOptions = .automatic,
141 |         transaction: Transaction = Transaction(animation: .default),
142 |         action: @escaping () async throws -> Void,
143 |         @ViewBuilder label: @escaping () -> Label
144 |     ) {
145 |         self.init(role: role, options: options, transaction: transaction, action: action) { _ in
146 |             label()
147 |         }
148 |     }
149 | }
150 | 
151 | extension AsyncButton where Label == Text {
152 |     
153 |     public init(
154 |         _ titleKey: LocalizedStringKey,
155 |         role: ButtonRole? = nil,
156 |         options: AsyncButtonOptions = .automatic,
157 |         transaction: Transaction = Transaction(animation: .default),
158 |         action: @escaping () async throws -> Void
159 |     ) {
160 |         self.init(role: role, options: options, transaction: transaction, action: action) { operations in
161 |             Text(titleKey)
162 |         }
163 |     }
164 | }
165 | 
166 | extension AsyncButton where Label == Text {
167 |     
168 |     public init<S>(
169 |         _ title: S,
170 |         role: ButtonRole?,
171 |         options: AsyncButtonOptions = .automatic,
172 |         transaction: Transaction = Transaction(animation: .default),
173 |         action: @escaping () async throws -> Void
174 |     ) where S : StringProtocol
175 |     {
176 |         self.init(role: role, options: options, transaction: transaction, action: action) { operations in
177 |             Text(title)
178 |         }
179 |     }
180 | }
181 | 


--------------------------------------------------------------------------------