Async javascript take 2

.gitignore

@@ -1,7 +1,7 @@
 build
 node_modules
 *.log
-
 *.xcuserstate
-
 *.xcbkptlist
+.swiftpm
+xcuserdata

Source/Bridge.swift

@@ -8,64 +8,62 @@ public enum BridgeError: Error {
 protocol Bridgable: AnyObject {
     var delegate: BridgeDelegate? { get set }
     var webView: WKWebView? { get }
-    
-    func register(component: String)
-    func register(components: [String])
-    func unregister(component: String)
-    func reply(with message: Message)
+
+    func register(component: String) async throws
+    func register(components: [String]) async throws
+    func unregister(component: String) async throws
+    func reply(with message: Message) async throws
 }
 
 /// `Bridge` is the object for configuring a web view and
 /// the channel for sending/receiving messages
 public final class Bridge: Bridgable {
-    typealias CompletionHandler = (_ result: Any?, _ error: Error?) -> Void
-
     weak var delegate: BridgeDelegate?
     weak var webView: WKWebView?
-    
+
     public static func initialize(_ webView: WKWebView) {
         if getBridgeFor(webView) == nil {
             initialize(Bridge(webView: webView))
         }
     }
-    
+
     init(webView: WKWebView) {
         self.webView = webView
         loadIntoWebView()
     }
-    
+
     deinit {
         webView?.configuration.userContentController.removeScriptMessageHandler(forName: scriptHandlerName)
     }
-    
+
     // MARK: - Internal API
-    
+
     /// Register a single component
     /// - Parameter component: Name of a component to register support for
-    func register(component: String) {
-        callBridgeFunction(.register, arguments: [component])
+    func register(component: String) async throws {
+        try await callBridgeFunction(.register, arguments: [component])
     }
-    
+
     /// Register multiple components
     /// - Parameter components: Array of component names to register
-    func register(components: [String]) {
-        callBridgeFunction(.register, arguments: [components])
+    func register(components: [String]) async throws {
+        try await callBridgeFunction(.register, arguments: [components])
     }
-    
+
     /// Unregister support for a single component
     /// - Parameter component: Component name
-    func unregister(component: String) {
-        callBridgeFunction(.unregister, arguments: [component])
+    func unregister(component: String) async throws {
+        try await callBridgeFunction(.unregister, arguments: [component])
     }
-    
+
     /// Send a message through the bridge to the web application
     /// - Parameter message: Message to send
-    func reply(with message: Message) {
+    func reply(with message: Message) async throws {
         logger.debug("bridgeWillReplyWithMessage: \(String(describing: message))")
         let internalMessage = InternalMessage(from: message)
-        callBridgeFunction(.replyWith, arguments: [internalMessage.toJSON()])
+        try await callBridgeFunction(.replyWith, arguments: [internalMessage.toJSON()])
     }
-    
+
 //    /// Convenience method to reply to a previously received message. Data will be replaced,
 //    /// while id, component, and event will remain the same
 //    /// - Parameter message: Message to reply to
@@ -74,28 +72,26 @@ public final class Bridge: Bridgable {
 //        let replyMessage = message.replacing(data: data)
 //        callBridgeFunction("send", arguments: [replyMessage.toJSON()])
 //    }
-
-    /// Evaluates javaScript string directly as passed in sending through the web view
-    func evaluate(javaScript: String, completion: CompletionHandler? = nil) {
-        guard let webView = webView else {
-            completion?(nil, BridgeError.missingWebView)
-            return
+    @MainActor
+    @discardableResult
+    func evaluate(javaScript: String) async throws -> Any {
+        guard let webView else {
+            throw BridgeError.missingWebView
         }
-
-        webView.evaluateJavaScript(javaScript) { result, error in
-            if let error = error {
-                logger.error("Error evaluating JavaScript: \(error)")
-            }
-
-            completion?(result, error)
+
+        do {
+            return try await webView.evaluateJavaScript(javaScript)
+        } catch {
+            logger.error("Error evaluating JavaScript: \(error)")
+            throw error
         }
     }
-    
+
     /// Evaluates a JavaScript function with optional arguments by encoding the arguments
     /// Function should not include the parens
     /// Usage: evaluate(function: "console.log", arguments: ["test"])
-    func evaluate(function: String, arguments: [Any] = [], completion: CompletionHandler? = nil) {
-        evaluate(javaScript: JavaScript(functionName: function, arguments: arguments), completion: completion)
+    func evaluate(function: String, arguments: [Any] = []) async throws -> Any {
+        try await evaluate(javaScript: JavaScript(functionName: function, arguments: arguments).toString())
     }
 
     static func initialize(_ bridge: Bridge) {
@@ -106,23 +102,23 @@ public final class Bridge: Bridgable {
     static func getBridgeFor(_ webView: WKWebView) -> Bridge? {
         return instances.first { $0.webView == webView }
     }
-    
+
     // MARK: Private
 
     private static var instances: [Bridge] = []
     /// This needs to match whatever the JavaScript file uses
     private let bridgeGlobal = "window.nativeBridge"
-    
+
     /// The webkit.messageHandlers name
     private let scriptHandlerName = "strada"
-    
-    private func callBridgeFunction(_ function: JavaScriptBridgeFunction, arguments: [Any]) {
+
+    private func callBridgeFunction(_ function: JavaScriptBridgeFunction, arguments: [Any]) async throws {
         let js = JavaScript(object: bridgeGlobal, functionName: function.rawValue, arguments: arguments)
-        evaluate(javaScript: js)
+        try await evaluate(javaScript: js)
     }
 
     // MARK: - Configuration
-    
+
     /// Configure the bridge in the provided web view
     private func loadIntoWebView() {
         guard let configuration = webView?.configuration else { return }
@@ -131,17 +127,18 @@ public final class Bridge: Bridgable {
         if let userScript = makeUserScript() {
             configuration.userContentController.addUserScript(userScript)
         }
-        
+
         let scriptMessageHandler = ScriptMessageHandler(delegate: self)
         configuration.userContentController.add(scriptMessageHandler, name: scriptHandlerName)
     }
 
     private func makeUserScript() -> WKUserScript? {
         guard
-            let path = PathLoader().pathFor(name: "strada", fileType: "js") else {
-                return nil
+            let path = PathLoader().pathFor(name: "strada", fileType: "js")
+        else {
+            return nil
         }
-        
+
         do {
             let source = try String(contentsOfFile: path)
             return WKUserScript(source: source, injectionTime: .atDocumentStart, forMainFrameOnly: true)
@@ -150,18 +147,19 @@ public final class Bridge: Bridgable {
             return nil
         }
     }
-    
+
     // MARK: - JavaScript Evaluation
-
-    private func evaluate(javaScript: JavaScript, completion: CompletionHandler? = nil) {
+
+    @discardableResult
+    private func evaluate(javaScript: JavaScript) async throws -> Any {
         do {
-            evaluate(javaScript: try javaScript.toString(), completion: completion)
+            return try await evaluate(javaScript: javaScript.toString())
         } catch {
             logger.error("Error evaluating JavaScript: \(String(describing: javaScript)), error: \(error)")
-            completion?(nil, error)
+            throw error
         }
     }
-    
+
     private enum JavaScriptBridgeFunction: String {
         case register
         case unregister
@@ -170,18 +168,18 @@ public final class Bridge: Bridgable {
 }
 
 extension Bridge: ScriptMessageHandlerDelegate {
-    func scriptMessageHandlerDidReceiveMessage(_ scriptMessage: WKScriptMessage) {
-        if let event = scriptMessage.body as? String,
-            event == "ready" {
-            delegate?.bridgeDidInitialize()
+    @MainActor
+    func scriptMessageHandlerDidReceiveMessage(_ scriptMessage: WKScriptMessage) async throws {
+        if let event = scriptMessage.body as? String, event == "ready" {
+            try await delegate?.bridgeDidInitialize()
             return
         }
-        
+
         if let message = InternalMessage(scriptMessage: scriptMessage) {
             delegate?.bridgeDidReceiveMessage(message.toMessage())
             return
         }
-        
+
         logger.warning("Unhandled message received: \(String(describing: scriptMessage.body))")
     }
 }

Source/BridgeComponent.swift

@@ -23,6 +23,8 @@ protocol BridgingComponent: AnyObject {
 }
 
 open class BridgeComponent: BridgingComponent {
+    public typealias ReplyCompletionHandler = (Result<Bool, Error>) -> Void
+
     /// A unique name representing the `BridgeComponent` type.
     ///
     /// Subclasses must provide their own implementation of this property.
@@ -50,26 +52,56 @@ open class BridgeComponent: BridgingComponent {
     ///
     /// - Parameter message: The message to be replied with.
     /// - Returns: `true` if the reply was successful, `false` if the bridge is not available.
-    public func reply(with message: Message) -> Bool {
-        return delegate.reply(with: message)
+    public func reply(with message: Message) async throws -> Bool {
+        try await delegate.reply(with: message)
     }
-
+
+    /// Replies to the web with a received message, optionally replacing its `event` or `jsonData`.
+    ///
+    /// - Parameter message: The message to be replied with.
+    public func reply(with message: Message, completion: ReplyCompletionHandler? = nil) {
+        Task {
+            do {
+                let result = try await delegate.reply(with: message)
+                completion?(.success((result)))
+            } catch {
+                completion?(.failure(error))
+            }
+        }
+    }
+
     @discardableResult
     /// Replies to the web with the last received message for a given `event` with its original `jsonData`.
     ///
     /// NOTE: If a message has not been received for the given `event`, the reply will be ignored.
     ///
     /// - Parameter event: The `event` for which a reply should be sent.
     /// - Returns: `true` if the reply was successful, `false` if the event message was not received.
-    public func reply(to event: String) -> Bool {
+    public func reply(to event: String) async throws -> Bool {
         guard let message = receivedMessage(for: event) else {
             logger.warning("bridgeMessageFailedToReply: message for event \(event) was not received")
             return false
         }
 
-        return reply(with: message)
+        return try await reply(with: message)
     }
-
+
+    /// Replies to the web with the last received message for a given `event` with its original `jsonData`.
+    ///
+    /// NOTE: If a message has not been received for the given `event`, the reply will be ignored.
+    ///
+    /// - Parameter event: The `event` for which a reply should be sent.
+    public func reply(to event: String, completion: ReplyCompletionHandler? = nil) {
+        Task {
+            do {
+                let result = try await reply(to: event)
+                completion?(.success((result)))
+            } catch {
+                completion?(.failure(error))
+            }
+        }
+    }
+
     @discardableResult
     /// Replies to the web with the last received message for a given `event`, replacing its `jsonData`.
     ///
@@ -79,15 +111,14 @@ open class BridgeComponent: BridgingComponent {
     ///   - event: The `event` for which a reply should be sent.
     ///   - jsonData: The `jsonData` to be included in the reply message.
     /// - Returns: `true` if the reply was successful, `false` if the event message was not received.
-    public func reply(to event: String, with jsonData: String) -> Bool {
+    public func reply(to event: String, with jsonData: String) async throws -> Bool {
         guard let message = receivedMessage(for: event) else {
             logger.warning("bridgeMessageFailedToReply: message for event \(event) was not received")
             return false
         }
 
         let messageReply = message.replacing(jsonData: jsonData)
-
-        return reply(with: messageReply)
+        return try await reply(with: messageReply)
     }
 
     @discardableResult
@@ -100,15 +131,14 @@ open class BridgeComponent: BridgingComponent {
     ///   - event: The `event` for which a reply should be sent.
     ///   - data: An instance conforming to `Encodable` to be included as `jsonData` in the reply message.
     /// - Returns: `true` if the reply was successful, `false` if the event message was not received.
-    public func reply<T: Encodable>(to event: String, with data: T) -> Bool {
+    public func reply<T: Encodable>(to event: String, with data: T) async throws -> Bool {
         guard let message = receivedMessage(for: event) else {
             logger.warning("bridgeMessageFailedToReply: message for event \(event) was not received")
             return false
         }
 
         let messageReply = message.replacing(data: data)
-
-        return reply(with: messageReply)
+        return try await reply(with: messageReply)
     }
 
     /// Returns the last received message for a given `event`, if available.

Source/BridgeDelegate.swift

@@ -10,8 +10,8 @@ public protocol BridgingDelegate: AnyObject {
 
     func webViewDidBecomeActive(_ webView: WKWebView)
     func webViewDidBecomeDeactivated()
-    func reply(with message: Message) -> Bool
-    
+    func reply(with message: Message) async throws -> Bool
+
     func onViewDidLoad()
     func onViewWillAppear()
     func onViewDidAppear()
@@ -20,7 +20,7 @@ public protocol BridgingDelegate: AnyObject {
 
     func component<C: BridgeComponent>() -> C?
 
-    func bridgeDidInitialize()
+    func bridgeDidInitialize() async throws
     func bridgeDidReceiveMessage(_ message: Message) -> Bool
 }
 
@@ -60,13 +60,13 @@ public final class BridgeDelegate: BridgingDelegate {
     ///
     /// - Parameter message: The message to be replied with.
     /// - Returns: `true` if the reply was successful, `false` if the bridge is not available.
-    public func reply(with message: Message) -> Bool {
+    public func reply(with message: Message) async throws -> Bool {
         guard let bridge else {
             logger.warning("bridgeMessageFailedToReply: bridge is not available")
             return false
         }
 
-        bridge.reply(with: message)
+        try await bridge.reply(with: message)
         return true
     }
 
@@ -109,9 +109,9 @@ public final class BridgeDelegate: BridgingDelegate {
 
     // MARK: Internal use
 
-    public func bridgeDidInitialize() {
+    public func bridgeDidInitialize() async throws {
         let componentNames = componentTypes.map { $0.name }
-        bridge?.register(components: componentNames)
+        try await bridge?.register(components: componentNames)
     }
 
     @discardableResult