@swiftbrowser/native 0.17.7 → 0.18.0

package/swift/Sources/SwiftBrowserNative/Host/HostBridge.swift

@@ -11,6 +11,9 @@ import AppKit
 #if canImport(FoundationBridge)
 import FoundationBridge // the shim's Foundation stand-ins (ShimAliases.swift)
 #endif
+#if canImport(CryptoKit)
+import CryptoKit
+#endif
 
 /// The native primitives `@swiftbrowser/native` builds the web globals from
 /// (packages/native/src/runtime.ts), installed on `__sbNative`:
@@ -27,8 +30,17 @@ import FoundationBridge // the shim's Foundation stand-ins (ShimAliases.swift)
 /// | `randomBytes(count)` | base64 of random bytes (`crypto.getRandomValues`) |
 /// | `openURL(url)` | the system opener |
 /// | `locale()` | the viewer's locale identifier |
+/// | `measureText(text, fontJSON, width)` | @swiftbrowser/react's `measureText`: `{ width, height, lines }` of the text in the font wrapped to the width (one line when null), from `NSAttributedString`'s bounding rect, synchronously (TextMeasureBridge.swift); nothing where there is no text system |
 /// | `launchArguments()` | the process's arguments (`-screen list` from a scheme or `simctl launch`) |
+/// | `appDirectories()` | the app's standard directories as `file:` URLs, a JSON object `{ documents, applicationSupport, caches, temporary }`, for `fileManager` (FilesBridge.swift); its `files` requests go through `hostRequest`. Apple platforms only |
 /// | `mediaSession(update)` | `navigator.mediaSession`: the lock screen's now-playing info and the remote commands the app handles, on MediaPlayer (NowPlayingBridge.swift); a command the viewer gives comes to `__sbMediaSessionCommand(json)` |
+/// | `notificationsReady()`, `notificationPermission(id, request)`, `notificationShow(json)`, `notificationClose(json)`, `setBadge(count)`, `pushRegister(id, key?)` | notifications on UserNotifications (NotificationBridge.swift): the permission answers `__sbNotificationPermission(id, state)`, a registration `__sbPushRegistered(id, result)`, and what the viewer opens or what arrives comes to `__sbNotification(json)` |
+/// | `wsOpen(id, url, protocols)`, `wsSend(id, json)`, `wsClose(id, code, reason)` | `WebSocket` on `URLSessionWebSocketTask` (WebSocketBridge.swift); what a socket receives comes to `__sbWebSocketEvent(id, json)` |
+/// | `digest(algorithm, base64)`, `hmac(algorithm, key, base64)` | `crypto.subtle` on CryptoKit, synchronously: the base64 digest or HMAC, or nothing when the algorithm is not one of SHA-1, SHA-256, SHA-384 and SHA-512 |
+/// | `haptic(kind)` | `navigator.vibrate`: a feedback generator's `impact`, `selection`, `success`, `warning` or `error` |
+/// | `hostRequest(id, kind, json)` | the web renderer's `share`, `pickFiles`, `clipboard`, `pickColor` and `webAuth` requests, answered with the system's share sheet, pickers, pasteboard and sign-in session (HostRequestBridge.swift); the answer comes to `__sbHostResponse(id, result)` |
+/// | `secureGet(key)`, `secureSet(key, value)`, `secureRemove(key)` | `secureStorage` over the Keychain (SecureStorage.swift) |
+/// | `undoState(json)` | the app's undo manager's `canUndo`, `canRedo`, `undoActionName` and `redoActionName`, mirrored on the window's `UndoManager` (UndoBridge.swift) so the shake, the three-finger swipe, ⌘Z and the Edit menu reach the app; what the system asks comes to `__sbUndoCommand("undo" \| "redo")` |
 /// | `workerStart(id, name, engine)`, `workerPost(id, text)`, `workerTerminate(id)` | workers (JavaScriptCore only): a `JSContext` on a thread (`"context"`, WorkerHost.swift) or a hidden web view with WebKit's JIT (`"webview"`, WebViewWorkerHost.swift); their messages come to `__sbWorkerMessage(id, text)`, their errors to `__sbWorkerError(id, message)` |
 ///
 /// Everything JavaScript-facing runs on the main thread; work that is not
@@ -46,6 +58,16 @@ final class HostBridge {
     #if canImport(MediaPlayer)
     private var nowPlaying: NowPlayingBridge?
     #endif
+    #if canImport(UserNotifications)
+    private var notifications: NotificationBridge?
+    #endif
+    private var webSockets: WebSocketBridge?
+    private var hostRequests: HostRequestBridge?
+    #if !canImport(FoundationBridge)
+    private var undo: UndoBridge?
+    /// The window's undo manager, for the undo bridge when the app first sends a state.
+    private weak var undoManager: UndoManager?
+    #endif
     /// Keys of `localStorage` live under this prefix in `UserDefaults`.
     static let storagePrefix = "swiftbrowser.storage."
 
@@ -59,6 +81,10 @@ final class HostBridge {
     func invalidate() {
         for timer in timers.values { timer.invalidate() }
         timers.removeAll()
+        webSockets?.invalidate()
+        #if !canImport(FoundationBridge)
+        undo?.manager = nil
+        #endif
         #if canImport(JavaScriptCore)
         for worker in workers.values { worker.terminate() }
         workers.removeAll()
@@ -194,8 +220,18 @@ final class HostBridge {
 
         host.install("locale") { _ in .string(Locale.current.identifier) }
 
+        host.install("measureText") { arguments in
+            guard let text = arguments[safe: 0]?.string else { return nil }
+            let font = (try? JSONValue.parse(arguments[safe: 1]?.string ?? "{}")) ?? .object([:])
+            return TextMeasureBridge.measure(text: text, font: font, width: arguments[safe: 2]?.double)
+        }
+
         host.install("launchArguments") { _ in .array(ProcessInfo.processInfo.arguments.map(JSONValue.string)) }
 
+        #if !canImport(FoundationBridge)
+        host.install("appDirectories") { _ in .string(FilesBridge.directories().json) }
+        #endif
+
         #if canImport(MediaPlayer)
         host.install("mediaSession") { [weak self] arguments in
             guard let self, let update = arguments.first?.string else { return .string("mediaSession: expected a JSON string") }
@@ -206,6 +242,100 @@ final class HostBridge {
         }
         #endif
 
+        #if canImport(UserNotifications)
+        host.install("notificationsReady") { [weak self] _ in
+            self?.notificationBridge.listen()
+            return nil
+        }
+        host.install("notificationPermission") { [weak self] arguments in
+            guard let self, let id = arguments[safe: 0]?.int else { return nil }
+            notificationBridge.permission(id: id, request: arguments[safe: 1]?.bool ?? false)
+            return nil
+        }
+        host.install("notificationShow") { [weak self] arguments in
+            guard let self, let json = arguments.first?.string else { return .string("notification: expected a JSON string") }
+            return notificationBridge.show(json).map(JSONValue.string)
+        }
+        host.install("notificationClose") { [weak self] arguments in
+            guard let self, let json = arguments.first?.string else { return nil }
+            notificationBridge.close(json)
+            return nil
+        }
+        host.install("setBadge") { [weak self] arguments in
+            guard let self, let count = arguments.first?.int else { return nil }
+            notificationBridge.setBadge(count)
+            return nil
+        }
+        host.install("pushRegister") { [weak self] arguments in
+            guard let self, let id = arguments[safe: 0]?.int else { return nil }
+            notificationBridge.registerForPush(id: id, applicationServerKey: arguments[safe: 1]?.string)
+            return nil
+        }
+        #endif
+
+        host.install("wsOpen") { [weak self] arguments in
+            guard let self, let id = arguments[safe: 0]?.int, let url = arguments[safe: 1]?.string else { return nil }
+            let protocols = arguments[safe: 2]?.array?.compactMap(\.string) ?? []
+            webSocketBridge.open(id: id, url: url, protocols: protocols)
+            return nil
+        }
+        host.install("wsSend") { [weak self] arguments in
+            guard let self, let id = arguments[safe: 0]?.int, let json = arguments[safe: 1]?.string else { return nil }
+            webSocketBridge.send(id: id, json: json)
+            return nil
+        }
+        host.install("wsClose") { [weak self] arguments in
+            guard let self, let id = arguments[safe: 0]?.int else { return nil }
+            webSocketBridge.close(id: id, code: arguments[safe: 1]?.int ?? 1000, reason: arguments[safe: 2]?.string ?? "")
+            return nil
+        }
+
+        host.install("digest") { arguments in
+            guard let algorithm = arguments[safe: 0]?.string, let encoded = arguments[safe: 1]?.string, let data = Data(base64Encoded: encoded) else { return nil }
+            return Self.digest(algorithm, data).map { .string($0.base64EncodedString()) }
+        }
+        host.install("hmac") { arguments in
+            guard let algorithm = arguments[safe: 0]?.string, let key = arguments[safe: 1]?.string, let encoded = arguments[safe: 2]?.string,
+                  let keyData = Data(base64Encoded: key), let data = Data(base64Encoded: encoded) else { return nil }
+            return Self.hmac(algorithm, key: keyData, data).map { .string($0.base64EncodedString()) }
+        }
+
+        host.install("haptic") { arguments in
+            Self.haptic(arguments.first?.string ?? "impact")
+            return nil
+        }
+
+        host.install("hostRequest") { [weak self] arguments in
+            guard let self, let id = arguments[safe: 0]?.int, let kind = arguments[safe: 1]?.string else { return nil }
+            if hostRequests == nil {
+                hostRequests = HostRequestBridge { [weak self] id, result in self?.callIn("__sbHostResponse", [.number(Double(id)), .string(result.json)]) }
+            }
+            hostRequests?.perform(id: id, kind: kind, json: arguments[safe: 2]?.string ?? "{}")
+            return nil
+        }
+
+        #if !canImport(FoundationBridge)
+        host.install("undoState") { [weak self] arguments in
+            guard let self, let json = arguments.first?.string else { return .string("undoState: expected a JSON string") }
+            return undoBridge.update(json).map(JSONValue.string)
+        }
+        #endif
+
+        host.install("secureGet") { arguments in
+            guard let key = arguments.first?.string else { return nil }
+            return SecureStorage.get(key).map(JSONValue.string) ?? .null
+        }
+        host.install("secureSet") { arguments in
+            guard let key = arguments[safe: 0]?.string, let value = arguments[safe: 1]?.string else { return nil }
+            SecureStorage.set(key, value)
+            return nil
+        }
+        host.install("secureRemove") { arguments in
+            guard let key = arguments.first?.string else { return nil }
+            SecureStorage.remove(key)
+            return nil
+        }
+
         #if canImport(JavaScriptCore)
         host.install("workerStart") { [weak self] arguments in
             guard let self, let id = arguments[safe: 0]?.int, let name = arguments[safe: 1]?.string else {
@@ -255,6 +385,87 @@ final class HostBridge {
         #endif
     }
 
+    #if canImport(UserNotifications)
+    /// The notification bridge, made when the app first uses notifications.
+    private var notificationBridge: NotificationBridge {
+        if let notifications { return notifications }
+        let bridge = NotificationBridge { [weak self] function, arguments in self?.callIn(function, arguments) }
+        notifications = bridge
+        return bridge
+    }
+    #endif
+
+    #if !canImport(FoundationBridge)
+    /// The undo bridge, made when the app first sends its undo manager's state.
+    private var undoBridge: UndoBridge {
+        if let undo { return undo }
+        let bridge = UndoBridge { [weak self] command in self?.callIn("__sbUndoCommand", [.string(command)]) }
+        bridge.manager = undoManager
+        undo = bridge
+        return bridge
+    }
+
+    /// The window's `UndoManager` (the root view's environment), which mirrors the app's.
+    func setUndoManager(_ manager: UndoManager?) {
+        undoManager = manager
+        undo?.manager = manager
+    }
+    #endif
+
+    /// The WebSocket bridge, made when the app opens its first socket.
+    private var webSocketBridge: WebSocketBridge {
+        if let webSockets { return webSockets }
+        let bridge = WebSocketBridge(session: session) { [weak self] id, event in self?.callIn("__sbWebSocketEvent", [.number(Double(id)), .string(event.json)]) }
+        webSockets = bridge
+        return bridge
+    }
+
+    // MARK: crypto.subtle and haptics
+
+    static func digest(_ algorithm: String, _ data: Data) -> Data? {
+        #if canImport(CryptoKit)
+        switch algorithm {
+        case "SHA-256": Data(SHA256.hash(data: data))
+        case "SHA-384": Data(SHA384.hash(data: data))
+        case "SHA-512": Data(SHA512.hash(data: data))
+        case "SHA-1": Data(Insecure.SHA1.hash(data: data))
+        default: nil
+        }
+        #else
+        nil
+        #endif
+    }
+
+    static func hmac(_ algorithm: String, key: Data, _ data: Data) -> Data? {
+        #if canImport(CryptoKit) && !canImport(FoundationBridge)
+        let symmetricKey = SymmetricKey(data: key)
+        return switch algorithm {
+        case "SHA-256": Data(HMAC<SHA256>.authenticationCode(for: data, using: symmetricKey))
+        case "SHA-384": Data(HMAC<SHA384>.authenticationCode(for: data, using: symmetricKey))
+        case "SHA-512": Data(HMAC<SHA512>.authenticationCode(for: data, using: symmetricKey))
+        case "SHA-1": Data(HMAC<Insecure.SHA1>.authenticationCode(for: data, using: symmetricKey))
+        default: nil
+        }
+        #else
+        // The shim's CryptoKit has no HMAC.
+        nil
+        #endif
+    }
+
+    static func haptic(_ kind: String) {
+        #if canImport(UIKit) && !os(tvOS)
+        switch kind {
+        case "selection": UISelectionFeedbackGenerator().selectionChanged()
+        case "success": UINotificationFeedbackGenerator().notificationOccurred(.success)
+        case "warning": UINotificationFeedbackGenerator().notificationOccurred(.warning)
+        case "error": UINotificationFeedbackGenerator().notificationOccurred(.error)
+        default: UIImpactFeedbackGenerator(style: .medium).impactOccurred()
+        }
+        #elseif canImport(AppKit)
+        NSHapticFeedbackManager.defaultPerformer.perform(.generic, performanceTime: .now)
+        #endif
+    }
+
     /// Calls into JavaScript from a timer or a completion, where a throw has nowhere to go but the log.
     private func callIn(_ function: String, _ arguments: [JSONValue]) {
         do {