Merge branch 'main' of https://github.com/flocked/FZSwiftUtils

Author: actions-user

Sources/FZSwiftUtils/Extensions/Collections/Dictionary+.swift

@@ -25,9 +25,7 @@ public extension Dictionary {
      - Note: The collection of transformed keys must not contain duplicates.
      */
     func mapKeys<Transformed>(_ transform: (Key) throws -> Transformed) rethrows -> [Transformed: Value] {
-        try .init(
-            uniqueKeysWithValues: map { try (transform($0.key), $0.value) }
-        )
+        try .init(uniqueKeysWithValues: map { try (transform($0.key), $0.value) })
     }
 
     /**

Sources/FZSwiftUtils/Extensions/Networking/URLComponents+.swift

@@ -67,6 +67,13 @@ extension URLComponents {
         return self
     }
 
+    /// Sets the query items for the URL in the order in which they appear in the original query string.
+    @discardableResult
+    public mutating func queryItems(_ items: [String:String?]) -> Self {
+        self.queryItems = items.map({ URLQueryItem(name: $0, value: $1) })
+        return self
+    }
+    
     /// Sets the query items for the URL in the order in which they appear in the original query string.
     @discardableResult
     public mutating func queryItems(@Builder _ items: () -> [URLQueryItem]) -> Self {
@@ -154,6 +161,10 @@ extension URLComponents {
         public static func buildExpression(_ expression: URLQueryItem) -> [URLQueryItem] {
             [expression]
         }
+        
+        public static func buildExpression(_ expression: [String : String]) -> [URLQueryItem] {
+            expression.map({ URLQueryItem(name: $0, value: $1) })
+        }
 
         public static func buildExpression(_ expression: [URLQueryItem]) -> [URLQueryItem] {
             expression

Sources/FZSwiftUtils/Extensions/Networking/URLRequest+.swift

@@ -114,25 +114,9 @@ public extension URLRequest {
     }
 
     /// A dictionary containing all of the HTTP header fields for a request.
-    var allHTTPHeaderFieldsMapped: [HTTPRequestHeaderFieldKey: String] {
-        get {
-            guard let allHTTPHeaderFields = allHTTPHeaderFields else { return [:] }
-            var mapped: [HTTPRequestHeaderFieldKey: String] = [:]
-            for key in allHTTPHeaderFields.keys.compactMap({ HTTPRequestHeaderFieldKey(rawValue: $0) }) {
-                mapped[key] = allHTTPHeaderFields[key.rawValue]
-            }
-            return mapped
-        }
-        set {
-            guard !newValue.isEmpty else {
-                allHTTPHeaderFields = nil
-                return
-            }
-            allHTTPHeaderFields = [:]
-            for key in newValue.keys {
-                allHTTPHeaderFields?[key.rawValue] = newValue[key]
-            }
-        }
+    var httpHeaderFields: [HTTPRequestHeaderFieldKey: String] {
+        get { allHTTPHeaderFields?.mapKeys({ HTTPRequestHeaderFieldKey(rawValue: $0) }) ?? [:] }
+        set { allHTTPHeaderFields = newValue.mapKeys({$0.rawValue}) }
     }
 }
 
@@ -171,13 +155,9 @@ public enum HTTPRequestHeaderFieldKey: Hashable, CaseIterable, RawRepresentable,
     case via
     case warning
     case custom(String)
-
+    
     public init(stringLiteral value: String) {
-        if let first = Self.allCases.first(where: { $0.rawValue == value }) {
-            self = first
-        } else {
-            self = .custom(value)
-        }
+        self = .init(rawValue: value)
     }
 
     public init(rawValue: String) {

Sources/FZSwiftUtils/Extensions/Networking/URLSessionConfiguration+.swift

@@ -9,27 +9,13 @@ import Foundation
 
 public extension URLSessionConfiguration {
     /// A dictionary of additional headers to send with requests.
-    var allHTTPHeaderFieldsMapped: [HTTPRequestHeaderFieldKey: Any] {
+    var httpAdditionalHeadersMapped: [HTTPRequestHeaderFieldKey: Any] {
         get {
-            guard let allHTTPHeaderFields = httpAdditionalHeaders else { return [:] }
-            var mapped: [HTTPRequestHeaderFieldKey: Any] = [:]
-            for value in allHTTPHeaderFields {
-                if let rawValue = value.key as? String {
-                    let key = HTTPRequestHeaderFieldKey(rawValue: rawValue)
-                    mapped[key] = allHTTPHeaderFields[value.key]
-                }
-            }
-            return mapped
-        }
-        set {
-            guard !newValue.isEmpty else {
-                httpAdditionalHeaders = nil
-                return
-            }
-            httpAdditionalHeaders = [:]
-            for key in newValue.keys {
-                httpAdditionalHeaders?[key.rawValue] = newValue[key]
-            }
+            httpAdditionalHeaders?.reduce(into: [HTTPRequestHeaderFieldKey:Any](), { partialResult, value in
+                guard let key = value.key as? String else { return }
+                partialResult[HTTPRequestHeaderFieldKey(rawValue: key)] = value.value
+            }) ?? [:]
         }
+        set { httpAdditionalHeaders = newValue.mapKeys({ $0.rawValue as AnyHashable }) }
     }
 }

Sources/FZSwiftUtils/Utils/AsyncOperation.swift

@@ -13,26 +13,18 @@ open class AsyncOperation: Operation, Pausable {
     public enum State: String, Hashable {
         /// The operation is waiting to start.
         case waiting = "isWaiting"
-
         /// The operation is ready to start.
         case ready = "isReady"
-
         /// The operation is executing.
         case executing = "isExecuting"
-
         /// The operation is finished.
         case finished = "isFinished"
-
         /// The operation is cancelled.
         case cancelled = "isCancelled"
-
         /// The operation is paused.
         case paused = "isPaused"
     }
 
-    /// The handler that gets called when the state changes.
-    open var onStateChange: ((State) -> Void)?
-
     /// The error, if the operation failed.
     open var error: Error?
 
@@ -45,96 +37,69 @@ open class AsyncOperation: Operation, Pausable {
             willChangeValue(forKey: State.cancelled.rawValue)
         }
         didSet {
-            switch self.state {
+            switch state {
             case .waiting:
-                assert(oldValue == .waiting, "Invalid change from \(oldValue) to \(self.state)")
+                assert(oldValue == .waiting, "Invalid change from \(oldValue) to \(state)")
             case .ready:
-                assert(oldValue == .waiting, "Invalid change from \(oldValue) to \(self.state)")
+                assert(oldValue == .waiting, "Invalid change from \(oldValue) to \(state)")
             case .executing:
-                assert(
-                    oldValue == .ready || oldValue == .waiting || oldValue == .paused,
-                    "Invalid change from \(oldValue) to \(self.state)"
-                )
+                assert( oldValue == .ready || oldValue == .waiting || oldValue == .paused, "Invalid change from \(oldValue) to \(state)")
             case .finished:
-                assert(oldValue != .cancelled, "Invalid change from \(oldValue) to \(self.state)")
+                assert(oldValue != .cancelled, "Invalid change from \(oldValue) to \(state)")
             case .cancelled:
                 break
             case .paused:
-                assert(oldValue == .executing, "Invalid change from \(oldValue) to \(self.state)")
+                assert(oldValue == .executing, "Invalid change from \(oldValue) to \(state)")
             }
-
             didChangeValue(forKey: State.cancelled.rawValue)
             didChangeValue(forKey: State.finished.rawValue)
             didChangeValue(forKey: State.executing.rawValue)
             didChangeValue(forKey: State.ready.rawValue)
-            if oldValue != self.state {
-                self.onStateChange?(self.state)
-            }
         }
     }
 
     override open var isReady: Bool {
-        if self.state == .waiting {
-            return super.isReady
-        } else {
-            return self.state == .ready
-        }
+        state == .waiting ? super.isReady : state == .ready
     }
 
     override open var isExecuting: Bool {
-        if self.state == .waiting {
-            return super.isExecuting
-        } else {
-            return self.state == .executing || self.state == .paused
-        }
+        state == .waiting ? super.isExecuting : state == .executing || state == .paused
     }
 
     override open var isFinished: Bool {
-        if self.state == .waiting {
-            return super.isFinished
-        } else {
-            return self.state == .finished
-        }
+        state == .waiting ? super.isFinished : state == .finished
     }
 
     override open var isCancelled: Bool {
-        if self.state == .waiting {
-            return super.isCancelled
-        } else {
-            return self.state == .cancelled
-        }
+        state == .waiting ? super.isCancelled : state == .cancelled
     }
 
     /// A Boolean value indicating whether the operation has been paused.
     open var isPaused: Bool {
-        self.state == .paused
+        state == .paused
     }
 
     /// Resumes the operation, if it's paused.
     open func resume() {
-        if isExecuting, state == .paused {
-            state = .executing
-        }
+        guard isExecuting, state == .paused else { return }
+        state = .executing
     }
 
     /// Pauses the operation.
     open func pause() {
-        if isExecuting, state != .paused {
-            state = .paused
-        }
+        guard isExecuting, state != .paused else { return }
+        state = .paused
     }
 
     /// Finishes executing the operation.
     open func finish() {
-        if isExecuting {
-            state = .finished
-        }
+        guard isExecuting else { return }
+        state = .finished
     }
 
     override open func cancel() {
-        if isExecuting {
-            state = .cancelled
-        }
+        guard isExecuting else { return }
+        state = .cancelled
     }
 
     override open var isAsynchronous: Bool {
@@ -159,7 +124,14 @@ open class AsyncBlockOperation: AsyncOperation {
 
     override open func start() {
         super.start()
-        guard isExecuting else { return }
+        guard isExecuting, !isPaused else { return }
         closure(self)
+        state = .finished
+    }
+    
+    open override func resume() {
+        super.resume()
+        guard isExecuting, !isPaused else { return }
+        start()
     }
 }