@swiftbrowser/native 0.17.7 → 0.18.0

package/swift/Sources/SwiftBrowserNative/Host/WebSocketBridge.swift

@@ -0,0 +1,118 @@
+#if canImport(SwiftUI)
+import Foundation
+import SwiftBrowserProtocol
+#if canImport(FoundationBridge)
+import FoundationBridge
+#endif
+
+/// The app's `WebSocket`s (packages/native/src/webSocket.ts) on
+/// `URLSessionWebSocketTask`: `wsOpen` starts one, which is open once its
+/// first ping is answered (the handshake is done by then), `wsSend` sends
+/// text or bytes, `wsClose` closes it. What a socket receives, and how it
+/// ends, goes to the app as `__sbWebSocketEvent(id, json)`: `open`,
+/// `message` (`text` or base64 `binary`), `error` and `close` (`code`,
+/// `reason`, `wasClean`). Against the shim (the round trip) the task is the
+/// shim's, over the page's WebSocket.
+@MainActor
+final class WebSocketBridge {
+    private let session: URLSession
+    private let send: (Int, JSONValue) -> Void
+    private var tasks: [Int: URLSessionWebSocketTask] = [:]
+
+    /// `send` hands an event for socket `id` to the app.
+    init(session: URLSession, send: @escaping (Int, JSONValue) -> Void) {
+        self.session = session
+        self.send = send
+    }
+
+    func open(id: Int, url string: String, protocols: [String]) {
+        guard let url = URL(string: string) else {
+            emit(id, ["type": .string("error"), "message": .string("invalid URL")])
+            emit(id, ["type": .string("close"), "code": .number(1006), "reason": .string(""), "wasClean": .bool(false)])
+            return
+        }
+        let task = protocols.isEmpty ? session.webSocketTask(with: url) : session.webSocketTask(with: url, protocols: protocols)
+        tasks[id] = task
+        task.resume()
+        task.sendPing { [weak self] error in
+            Task { @MainActor [weak self] in
+                guard let self, self.tasks[id] === task else { return }
+                if let error {
+                    self.fail(id: id, task: task, error: error)
+                    return
+                }
+                self.emit(id, ["type": .string("open"), "protocol": .string("")])
+                self.receive(id: id, task: task)
+            }
+        }
+    }
+
+    /// `{ text }` or `{ binary }` (base64).
+    func send(id: Int, json: String) {
+        guard let task = tasks[id], let fields = (try? JSONValue.parse(json))?.object else { return }
+        let message: URLSessionWebSocketTask.Message
+        if let text = fields["text"]?.string {
+            message = .string(text)
+        } else if let encoded = fields["binary"]?.string, let data = Data(base64Encoded: encoded) {
+            message = .data(data)
+        } else {
+            return
+        }
+        task.send(message) { [weak self] error in
+            guard let error else { return }
+            Task { @MainActor [weak self] in
+                guard let self, self.tasks[id] === task else { return }
+                self.fail(id: id, task: task, error: error)
+            }
+        }
+    }
+
+    func close(id: Int, code: Int, reason: String) {
+        guard let task = tasks.removeValue(forKey: id) else { return }
+        task.cancel(with: URLSessionWebSocketTask.CloseCode(rawValue: code) ?? .normalClosure, reason: reason.isEmpty ? nil : Data(reason.utf8))
+        emit(id, ["type": .string("close"), "code": .number(Double(code)), "reason": .string(reason), "wasClean": .bool(true)])
+    }
+
+    /// Ends every socket; the app that owned the bridge is going away.
+    func invalidate() {
+        for task in tasks.values { task.cancel(with: .goingAway, reason: nil) }
+        tasks.removeAll()
+    }
+
+    private func receive(id: Int, task: URLSessionWebSocketTask) {
+        task.receive { [weak self] result in
+            Task { @MainActor [weak self] in
+                guard let self, self.tasks[id] === task else { return }
+                switch result {
+                case .success(let message):
+                    switch message {
+                    case .string(let text): self.emit(id, ["type": .string("message"), "text": .string(text)])
+                    case .data(let data): self.emit(id, ["type": .string("message"), "binary": .string(data.base64EncodedString())])
+                    @unknown default: break
+                    }
+                    self.receive(id: id, task: task)
+                case .failure(let error):
+                    self.fail(id: id, task: task, error: error)
+                }
+            }
+        }
+    }
+
+    /// The socket ended: a close the server sent (its code and reason), else an error and an unclean close.
+    private func fail(id: Int, task: URLSessionWebSocketTask, error: any Error) {
+        tasks[id] = nil
+        let code = task.closeCode
+        if code != .invalid {
+            let reason = task.closeReason.map { String(decoding: $0, as: UTF8.self) } ?? ""
+            emit(id, ["type": .string("close"), "code": .number(Double(code.rawValue)), "reason": .string(reason), "wasClean": .bool(true)])
+        } else {
+            emit(id, ["type": .string("error"), "message": .string(error.localizedDescription)])
+            emit(id, ["type": .string("close"), "code": .number(1006), "reason": .string(""), "wasClean": .bool(false)])
+        }
+    }
+
+    private func emit(_ id: Int, _ fields: JSONObject) {
+        send(id, .object(fields))
+    }
+}
+#endif

package/swift/Sources/SwiftBrowserNative/Runtime/NativeApp.swift

@@ -40,6 +40,10 @@ public final class NativeApp {
     /// URLs the app was opened with before its script could take them (a
     /// universal link that launched it): delivered once it loads.
     private var pendingURLs: [URL] = []
+    #if !canImport(FoundationBridge)
+    /// The window's undo manager, kept across reloads.
+    private weak var undoManager: UndoManager?
+    #endif
 
     #if canImport(JavaScriptCore)
     public convenience init() {
@@ -57,13 +61,52 @@ public final class NativeApp {
                 body()
             }
         }
+        // `withAnimation(_:completionCriteria:_:completion:)`: SwiftUI calls the
+        // completion when the pass's animation ends; with no animation, right
+        // after the pass (the tree sends the event a turn later, off the
+        // pass's stack, as the app answers with a pass of its own).
+        tree.animateWithCompletion = { spec, completion, body, done in
+            guard let animation = spec.map(Animation.init(spec:)) else {
+                body()
+                done()
+                return
+            }
+            let criteria: AnimationCompletionCriteria = completion.criteria == "removed" ? .removed : .logicallyComplete
+            withAnimation(animation, completionCriteria: criteria, body, completion: done)
+        }
         tree.onEvent = { [weak self] event in self?.dispatch(event) }
         #if canImport(JavaScriptCore)
         (host as? JavaScriptCoreHost)?.onError = { [weak self] error in self?.error = error.description }
         #endif
+        #if canImport(UserNotifications)
+        NotificationRouter.shared.installIfApp()
+        #endif
         bridge = HostBridge(host: host, tree: tree)
     }
 
+    #if canImport(UserNotifications)
+    // MARK: Remote notifications
+    //
+    // What the app delegate is handed (NativeAppDelegate.swift, or the app's
+    // own delegate calling these), for `registerForPush` and `onNotification`
+    // in `@swiftbrowser/native` (NotificationBridge.swift).
+
+    /// The device token: `registerForPush` resolves with it, as hex.
+    public static func didRegisterForRemoteNotifications(deviceToken: Data) {
+        NotificationRouter.shared.registered(token: deviceToken)
+    }
+
+    /// No token: `registerForPush` rejects with the error.
+    public static func didFailToRegisterForRemoteNotifications(error: any Error) {
+        NotificationRouter.shared.registrationFailed("\(error)")
+    }
+
+    /// A push delivered to the app delegate (a silent one): a `received` event.
+    public static func didReceiveRemoteNotification(userInfo: [AnyHashable: Any]) {
+        NotificationRouter.shared.received(remote: userInfo)
+    }
+    #endif
+
     /// Evaluates the app's bundle (what `@swiftbrowser/native` built: it calls
     /// `run(<App/>)` at the end, which renders the first pass into the tree
     /// before this returns). The environment, if known, is sent right after.
@@ -111,8 +154,21 @@ public final class NativeApp {
         try? tree.apply(tree.root.children.map { Op.remove(id: $0.id) } + [.commit(animation: nil)])
         host.reset()
         bridge = HostBridge(host: host, tree: tree)
+        #if !canImport(FoundationBridge)
+        bridge?.setUndoManager(undoManager)
+        #endif
     }
 
+    #if !canImport(FoundationBridge)
+    /// The window's `UndoManager` (`NativeRootView` reads it from the
+    /// environment): it mirrors the app's undo manager (UndoBridge.swift),
+    /// so the system's undo gestures, keys and menu reach the app.
+    public func setUndoManager(_ manager: UndoManager?) {
+        undoManager = manager
+        bridge?.setUndoManager(manager)
+    }
+    #endif
+
     /// Loads a bundled resource, `app.js` by default.
     public func load(resource: String = "app", extension ext: String = "js", bundle: Bundle = .main) {
         guard let url = bundle.url(forResource: resource, withExtension: ext) else {

package/swift/Sources/SwiftBrowserNative/Runtime/NativeAppDelegate.swift

@@ -0,0 +1,36 @@
+#if canImport(SwiftUI) && canImport(UIKit) && canImport(UserNotifications)
+import Foundation
+import UIKit
+import UserNotifications
+#if canImport(FoundationBridge)
+import FoundationBridge
+#endif
+
+/// The app delegate a native app adopts for remote notifications, through
+/// `@UIApplicationDelegateAdaptor(NativeAppDelegate.self)` in its App file
+/// (the project `native init` writes does): it hands the device token, a
+/// failure to get one and the pushes delivered to the app to `NativeApp`,
+/// for `registerForPush` and `onNotification` in `@swiftbrowser/native`
+/// (NotificationBridge.swift). An app with a delegate of its own calls the
+/// same `NativeApp` entry points from it.
+open class NativeAppDelegate: UIResponder, UIApplicationDelegate {
+    open func application(_ application: UIApplication, willFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
+        // Before launching finishes, so a tap that launched the app is reported.
+        NotificationRouter.shared.install()
+        return true
+    }
+
+    open func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
+        NativeApp.didRegisterForRemoteNotifications(deviceToken: deviceToken)
+    }
+
+    open func application(_ application: UIApplication, didFailToRegisterForRemoteNotificationsWithError error: any Error) {
+        NativeApp.didFailToRegisterForRemoteNotifications(error: error)
+    }
+
+    open func application(_ application: UIApplication, didReceiveRemoteNotification userInfo: [AnyHashable: Any]) async -> UIBackgroundFetchResult {
+        NativeApp.didReceiveRemoteNotification(userInfo: userInfo)
+        return .newData
+    }
+}
+#endif