@swiftbrowser/native 0.17.6 → 0.17.8

package/src/webSocket.ts

@@ -0,0 +1,175 @@
+/**
+ * `WebSocket` for the native app over the bridge's `wsOpen`, `wsSend` and
+ * `wsClose` (`URLSessionWebSocketTask` on the Swift side). What the socket
+ * receives arrives at `__sbWebSocketEvent(id, json)`: `{ type: "open",
+ * protocol }`, `{ type: "message", text }` or `{ type: "message", binary }`
+ * (base64), `{ type: "error", message }` and `{ type: "close", code, reason,
+ * wasClean }`. The browser's event model as apps use it: `onopen`,
+ * `onmessage`, `onerror`, `onclose`, `addEventListener`, `readyState`,
+ * `binaryType` (`blob` by default, or `arraybuffer`).
+ */
+
+import { SimpleBlob } from './blob';
+import type { NativeBridge } from './bridge';
+import { base64Decode, base64Encode } from './encoding';
+
+export interface WebSocketEventLike {
+  type: string;
+  target: NativeWebSocket;
+  data?: unknown;
+  code?: number;
+  reason?: string;
+  wasClean?: boolean;
+  message?: string;
+}
+
+type Handler = (event: WebSocketEventLike) => void;
+
+/** The bridge's event for socket `id`. */
+export interface NativeWebSocketEvent {
+  type: 'open' | 'message' | 'error' | 'close';
+  protocol?: string;
+  text?: string;
+  /** Base64. */
+  binary?: string;
+  message?: string;
+  code?: number;
+  reason?: string;
+  wasClean?: boolean;
+}
+
+export type WebSocketBridge = Required<Pick<NativeBridge, 'wsOpen' | 'wsSend' | 'wsClose'>>;
+
+const sockets = new Map<number, NativeWebSocket>();
+let nextId = 1;
+let bridge: WebSocketBridge | null = null;
+
+export class NativeWebSocket {
+  static readonly CONNECTING = 0;
+  static readonly OPEN = 1;
+  static readonly CLOSING = 2;
+  static readonly CLOSED = 3;
+  readonly CONNECTING = 0;
+  readonly OPEN = 1;
+  readonly CLOSING = 2;
+  readonly CLOSED = 3;
+
+  readonly url: string;
+  readyState = 0;
+  protocol = '';
+  extensions = '';
+  bufferedAmount = 0;
+  binaryType: 'blob' | 'arraybuffer' = 'blob';
+  onopen: Handler | null = null;
+  onmessage: Handler | null = null;
+  onerror: Handler | null = null;
+  onclose: Handler | null = null;
+
+  private readonly id: number;
+  private readonly listeners = new Map<string, Set<Handler>>();
+
+  constructor(url: string | { href: string }, protocols: string | string[] = []) {
+    if (!bridge) throw new TypeError('WebSocket: no native bridge');
+    const href = typeof url === 'string' ? url : url.href;
+    if (!/^wss?:\/\//i.test(href)) throw new SyntaxError(`WebSocket: the URL's scheme must be ws or wss: ${href}`);
+    this.url = href;
+    this.id = nextId++;
+    sockets.set(this.id, this);
+    bridge.wsOpen(this.id, href, typeof protocols === 'string' ? [protocols] : [...protocols]);
+  }
+
+  send(data: string | ArrayBuffer | ArrayBufferView | SimpleBlob): void {
+    if (this.readyState === NativeWebSocket.CONNECTING) throw new DOMExceptionLike('InvalidStateError', 'WebSocket: still connecting');
+    if (this.readyState !== NativeWebSocket.OPEN) return;
+    if (typeof data === 'string') {
+      bridge?.wsSend(this.id, JSON.stringify({ text: data }));
+      return;
+    }
+    const bytes = data instanceof SimpleBlob ? data.bytes() : data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    bridge?.wsSend(this.id, JSON.stringify({ binary: base64Encode(bytes) }));
+  }
+
+  close(code?: number, reason?: string): void {
+    if (code !== undefined && code !== 1000 && !(code >= 3000 && code <= 4999)) throw new DOMExceptionLike('InvalidAccessError', 'WebSocket: the close code must be 1000 or in 3000–4999');
+    if (this.readyState === NativeWebSocket.CLOSING || this.readyState === NativeWebSocket.CLOSED) return;
+    this.readyState = NativeWebSocket.CLOSING;
+    bridge?.wsClose(this.id, code ?? 1000, reason ?? '');
+  }
+
+  addEventListener(type: string, handler: Handler): void {
+    let set = this.listeners.get(type);
+    if (!set) {
+      set = new Set();
+      this.listeners.set(type, set);
+    }
+    set.add(handler);
+  }
+
+  removeEventListener(type: string, handler: Handler): void {
+    this.listeners.get(type)?.delete(handler);
+  }
+
+  dispatchEvent(event: WebSocketEventLike): boolean {
+    const own = { open: this.onopen, message: this.onmessage, error: this.onerror, close: this.onclose }[event.type];
+    own?.(event);
+    for (const handler of this.listeners.get(event.type) ?? []) handler(event);
+    return true;
+  }
+
+  /** The bridge's event for this socket. */
+  receive(event: NativeWebSocketEvent): void {
+    switch (event.type) {
+      case 'open':
+        if (this.readyState !== NativeWebSocket.CONNECTING) return;
+        this.readyState = NativeWebSocket.OPEN;
+        this.protocol = event.protocol ?? '';
+        this.dispatchEvent({ type: 'open', target: this });
+        return;
+      case 'message': {
+        if (this.readyState !== NativeWebSocket.OPEN) return;
+        let data: unknown = event.text ?? '';
+        if (event.binary !== undefined) {
+          const bytes = base64Decode(event.binary);
+          data = this.binaryType === 'arraybuffer' ? bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) : new SimpleBlob([bytes]);
+        }
+        this.dispatchEvent({ type: 'message', target: this, data });
+        return;
+      }
+      case 'error':
+        this.dispatchEvent({ type: 'error', target: this, message: event.message ?? '' });
+        return;
+      case 'close':
+        if (this.readyState === NativeWebSocket.CLOSED) return;
+        this.readyState = NativeWebSocket.CLOSED;
+        sockets.delete(this.id);
+        this.dispatchEvent({ type: 'close', target: this, code: event.code ?? 1006, reason: event.reason ?? '', wasClean: event.wasClean ?? false });
+        return;
+    }
+  }
+
+  /** The bridge's `__sbWebSocketEvent(id, json)`. */
+  static receive(id: number, json: string | NativeWebSocketEvent): void {
+    const socket = sockets.get(id);
+    if (!socket) return;
+    let event: NativeWebSocketEvent;
+    try {
+      event = typeof json === 'string' ? (JSON.parse(json) as NativeWebSocketEvent) : json;
+    } catch {
+      return;
+    }
+    socket.receive(event);
+  }
+
+  /** Points the sockets at the bridge (the runtime, once per install). */
+  static install(native: WebSocketBridge): void {
+    bridge = native;
+  }
+}
+
+/** A `DOMException` stand-in: an error with the browser's name. */
+class DOMExceptionLike extends Error {
+  constructor(name: string, message: string) {
+    super(message);
+    this.name = name;
+  }
+}

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`:
@@ -28,6 +31,13 @@ import FoundationBridge // the shim's Foundation stand-ins (ShimAliases.swift)
 /// | `openURL(url)` | the system opener |
 /// | `locale()` | the viewer's locale identifier |
 /// | `launchArguments()` | the process's arguments (`-screen list` from a scheme or `simctl launch`) |
+/// | `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) |
 /// | `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
@@ -42,6 +52,14 @@ final class HostBridge {
     #endif
     private let logger = Logger(subsystem: "swiftbrowser", category: "js")
     private let session = URLSession(configuration: .default)
+    #if canImport(MediaPlayer)
+    private var nowPlaying: NowPlayingBridge?
+    #endif
+    #if canImport(UserNotifications)
+    private var notifications: NotificationBridge?
+    #endif
+    private var webSockets: WebSocketBridge?
+    private var hostRequests: HostRequestBridge?
     /// Keys of `localStorage` live under this prefix in `UserDefaults`.
     static let storagePrefix = "swiftbrowser.storage."
 
@@ -55,6 +73,7 @@ final class HostBridge {
     func invalidate() {
         for timer in timers.values { timer.invalidate() }
         timers.removeAll()
+        webSockets?.invalidate()
         #if canImport(JavaScriptCore)
         for worker in workers.values { worker.terminate() }
         workers.removeAll()
@@ -192,6 +211,103 @@ final class HostBridge {
 
         host.install("launchArguments") { _ in .array(ProcessInfo.processInfo.arguments.map(JSONValue.string)) }
 
+        #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") }
+            if nowPlaying == nil {
+                nowPlaying = NowPlayingBridge { [weak self] command in self?.callIn("__sbMediaSessionCommand", [.string(command.json)]) }
+            }
+            return nowPlaying?.update(update).map(JSONValue.string)
+        }
+        #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
+        }
+
+        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 {
@@ -241,6 +357,70 @@ 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
+
+    /// 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 {