@swiftbrowser/native 0.17.7 → 0.17.8

package/swift/Sources/SwiftBrowserNative/Host/HostRequestBridge.swift

@@ -0,0 +1,437 @@
+#if canImport(SwiftUI)
+import Foundation
+import SwiftBrowserProtocol
+import SwiftUI
+#if canImport(UIKit)
+import UIKit
+#elseif canImport(AppKit)
+import AppKit
+#endif
+#if canImport(FoundationBridge)
+import FoundationBridge
+#endif
+#if canImport(AuthenticationServices)
+import AuthenticationServices
+#endif
+#if !canImport(FoundationBridge)
+#if canImport(PhotosUI)
+import PhotosUI
+#endif
+import UniformTypeIdentifiers
+#endif
+
+/// The host requests the web renderer's environment answers for a React app
+/// (`ShareLink`, `fileImporter`, the clipboard, a color chooser, a sign-in),
+/// answered here with the system's own (packages/native/src/hostRequests.ts):
+/// `hostRequest(id, kind, json)` performs one and `__sbHostResponse(id,
+/// { value } | { error })` answers it. The kinds and their params and values
+/// are the web renderer's (docs/ops-protocol.md): `share` (`title`, `text`,
+/// `url`, `files`: a share sheet; `{ outcome }`), `pickFiles` (`accept`,
+/// `multiple`: the photo picker for pictures and videos, else the document
+/// picker; `{ files: [{ name, type, data }] }`), `clipboard` (`write` with
+/// `text` or `files`, `readText`; `{ text }`), `pickColor` (`color`: the
+/// color picker; `{ color }`) and `webAuth` (`url`, `callbackScheme`,
+/// `ephemeral`: `ASWebAuthenticationSession`; `{ url }`). Against the shim
+/// (the round trip) the page answers the first four itself, and the sign-in
+/// runs on the shim's session; the rest answers `unsupported`.
+@MainActor
+final class HostRequestBridge {
+    private let answer: (Int, JSONValue) -> Void
+    /// Delegates and sessions kept alive until they answer.
+    private var active: [ObjectIdentifier: AnyObject] = [:]
+
+    /// `answer` hands a request's result to the app.
+    init(answer: @escaping (Int, JSONValue) -> Void) {
+        self.answer = answer
+    }
+
+    func perform(id: Int, kind: String, json: String) {
+        let params = (try? JSONValue.parse(json))?.object ?? [:]
+        Task { @MainActor in
+            do {
+                answer(id, .object(["value": try await handle(kind, params)]))
+            } catch {
+                answer(id, .object(["error": .string("\(error)")]))
+            }
+        }
+    }
+
+    private func handle(_ kind: String, _ params: JSONObject) async throws -> JSONValue {
+        switch kind {
+        case "webAuth": try await webAuth(params)
+        #if !canImport(FoundationBridge)
+        case "share": try await share(params)
+        case "pickFiles": try await pickFiles(params)
+        case "clipboard": try clipboard(params)
+        case "pickColor": try await pickColor(params)
+        #endif
+        default: throw HostRequestFailure("unsupported: the native app cannot answer a \(kind) request")
+        }
+    }
+
+    private func keep(_ object: AnyObject) {
+        active[ObjectIdentifier(object)] = object
+    }
+
+    private func release(_ object: AnyObject) {
+        active[ObjectIdentifier(object)] = nil
+    }
+
+    // MARK: Sign-in
+
+    private func webAuth(_ params: JSONObject) async throws -> JSONValue {
+        #if canImport(AuthenticationServices)
+        guard let string = params["url"]?.string, let url = URL(string: string) else { throw HostRequestFailure("webAuth: expected a url") }
+        let scheme = params["callbackScheme"]?.string
+        let ephemeral = params["ephemeral"]?.bool ?? false
+        return try await withCheckedThrowingContinuation { continuation in
+            let presentation = AuthPresentation()
+            keep(presentation)
+            let session = ASWebAuthenticationSession(url: url, callbackURLScheme: scheme) { [weak self] callback, error in
+                let result: Result<JSONValue, any Error>
+                if let callback {
+                    result = .success(.object(["url": .string(callback.absoluteString)]))
+                } else if let error, Self.isCancellation(error) {
+                    result = .failure(HostRequestFailure("cancelled: the viewer closed the sign-in"))
+                } else {
+                    result = .failure(HostRequestFailure("webAuth: \(error?.localizedDescription ?? "the sign-in ended without a URL")"))
+                }
+                Task { @MainActor [weak self] in
+                    self?.release(presentation)
+                    continuation.resume(with: result)
+                }
+            }
+            session.prefersEphemeralWebBrowserSession = ephemeral
+            #if !canImport(FoundationBridge)
+            session.presentationContextProvider = presentation
+            #endif
+            presentation.session = session
+            _ = session.start()
+        }
+        #else
+        throw HostRequestFailure("unsupported: no AuthenticationServices")
+        #endif
+    }
+
+    nonisolated private static func isCancellation(_ error: any Error) -> Bool {
+        #if canImport(AuthenticationServices) && !canImport(FoundationBridge)
+        if let failure = error as? ASWebAuthenticationSessionError, failure.code == .canceledLogin { return true }
+        #endif
+        return "\(error)".lowercased().contains("cancel")
+    }
+
+    #if !canImport(FoundationBridge)
+    // MARK: The share sheet, the pickers and the pasteboard (Apple platforms)
+
+    /// The files a request carries, written to a folder of their own, for the share sheet.
+    private func writeFiles(_ files: [JSONValue]) throws -> [URL] {
+        let folder = FileManager.default.temporaryDirectory.appendingPathComponent("swiftbrowser-share-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
+        return try files.compactMap { file -> URL? in
+            guard let encoded = file["data"].string, let data = Data(base64Encoded: encoded) else { return nil }
+            let name = file["name"].string.flatMap { $0.isEmpty ? nil : $0 } ?? "file"
+            let url = folder.appendingPathComponent(name.components(separatedBy: "/").last ?? name)
+            try data.write(to: url)
+            return url
+        }
+    }
+
+    private static func mimeType(of url: URL) -> String {
+        UTType(filenameExtension: url.pathExtension)?.preferredMIMEType ?? "application/octet-stream"
+    }
+
+    private static func fileValue(name: String, type: String, data: Data) -> JSONValue {
+        .object(["name": .string(name), "type": .string(type), "data": .string(data.base64EncodedString())])
+    }
+
+    #if canImport(UIKit)
+    /// The view controller to present from: the key window's root, or whatever it presented last.
+    private func presenter() throws -> UIViewController {
+        let windows = UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }.flatMap(\.windows)
+        guard var controller = (windows.first { $0.isKeyWindow } ?? windows.first)?.rootViewController else {
+            throw HostRequestFailure("unsupported: no window to present from")
+        }
+        while let presented = controller.presentedViewController { controller = presented }
+        return controller
+    }
+
+    private func share(_ params: JSONObject) async throws -> JSONValue {
+        var items: [Any] = []
+        if let text = params["text"]?.string, !text.isEmpty { items.append(text) }
+        if let url = params["url"]?.string.flatMap(URL.init(string:)) { items.append(url) }
+        items.append(contentsOf: try writeFiles(params["files"]?.array ?? []))
+        guard !items.isEmpty else { throw HostRequestFailure("share: nothing to share") }
+        let presenter = try presenter()
+        return await withCheckedContinuation { continuation in
+            let controller = UIActivityViewController(activityItems: items, applicationActivities: nil)
+            if let title = params["title"]?.string, !title.isEmpty { controller.title = title }
+            if let popover = controller.popoverPresentationController {
+                popover.sourceView = presenter.view
+                popover.sourceRect = CGRect(x: presenter.view.bounds.midX, y: presenter.view.bounds.midY, width: 0, height: 0)
+                popover.permittedArrowDirections = []
+            }
+            controller.completionWithItemsHandler = { _, completed, _, _ in
+                continuation.resume(returning: .object(["outcome": .string(completed ? "shared" : "cancelled")]))
+            }
+            presenter.present(controller, animated: true)
+        }
+    }
+
+    private func pickFiles(_ params: JSONObject) async throws -> JSONValue {
+        let accept = Self.parseAccept(params["accept"]?.string ?? "")
+        let multiple = params["multiple"]?.bool ?? false
+        let presenter = try presenter()
+        #if canImport(PhotosUI)
+        if accept.photos {
+            var configuration = PHPickerConfiguration(photoLibrary: .shared())
+            configuration.selectionLimit = multiple ? 0 : 1
+            configuration.filter = accept.videos && accept.images ? .any(of: [.images, .videos]) : accept.videos ? .videos : .images
+            let results: [PHPickerResult] = await withCheckedContinuation { continuation in
+                let delegate = PhotoPickerDelegate { [weak self] delegate, results in
+                    self?.release(delegate)
+                    // The results are read on the main actor only, here and after the await; the compiler cannot see that.
+                    nonisolated(unsafe) let picked = results
+                    continuation.resume(returning: picked)
+                }
+                keep(delegate)
+                let picker = PHPickerViewController(configuration: configuration)
+                picker.delegate = delegate
+                presenter.present(picker, animated: true)
+            }
+            var files: [JSONValue] = []
+            for result in results {
+                if let file = await Self.load(result.itemProvider) { files.append(file) }
+            }
+            return .object(["files": .array(files)])
+        }
+        #endif
+        let urls: [URL] = await withCheckedContinuation { continuation in
+            let delegate = DocumentPickerDelegate { [weak self] delegate, urls in
+                self?.release(delegate)
+                continuation.resume(returning: urls)
+            }
+            keep(delegate)
+            let picker = UIDocumentPickerViewController(forOpeningContentTypes: accept.types.isEmpty ? [.item] : accept.types, asCopy: true)
+            picker.allowsMultipleSelection = multiple
+            picker.delegate = delegate
+            presenter.present(picker, animated: true)
+        }
+        let files = urls.compactMap { url -> JSONValue? in
+            guard let data = try? Data(contentsOf: url) else { return nil }
+            return Self.fileValue(name: url.lastPathComponent, type: Self.mimeType(of: url), data: data)
+        }
+        return .object(["files": .array(files)])
+    }
+
+    private func clipboard(_ params: JSONObject) throws -> JSONValue {
+        let pasteboard = UIPasteboard.general
+        if params["action"]?.string == "readText" { return .object(["text": .string(pasteboard.string ?? "")]) }
+        if let text = params["text"]?.string {
+            pasteboard.string = text
+            return .object([:])
+        }
+        guard let file = params["files"]?.array?.first, let encoded = file["data"].string, let data = Data(base64Encoded: encoded) else {
+            throw HostRequestFailure("clipboard: nothing to copy")
+        }
+        if let image = UIImage(data: data) {
+            pasteboard.image = image
+        } else {
+            pasteboard.setData(data, forPasteboardType: UTType(mimeType: file["type"].string ?? "")?.identifier ?? UTType.data.identifier)
+        }
+        return .object([:])
+    }
+
+    private func pickColor(_ params: JSONObject) async throws -> JSONValue {
+        let presenter = try presenter()
+        return await withCheckedContinuation { continuation in
+            let delegate = ColorPickerDelegate { [weak self] delegate, color in
+                self?.release(delegate)
+                continuation.resume(returning: color.map { .object(["color": .string($0)]) } ?? .object([:]))
+            }
+            keep(delegate)
+            let picker = UIColorPickerViewController()
+            picker.supportsAlpha = false
+            if let hex = params["color"]?.string, let color = UIColor(hex: hex) { picker.selectedColor = color }
+            picker.delegate = delegate
+            presenter.present(picker, animated: true)
+        }
+    }
+    #elseif canImport(AppKit)
+    private func share(_ params: JSONObject) async throws -> JSONValue {
+        var items: [Any] = []
+        if let text = params["text"]?.string, !text.isEmpty { items.append(text) }
+        if let url = params["url"]?.string.flatMap(URL.init(string:)) { items.append(url) }
+        items.append(contentsOf: try writeFiles(params["files"]?.array ?? []))
+        guard !items.isEmpty else { throw HostRequestFailure("share: nothing to share") }
+        guard let view = NSApplication.shared.keyWindow?.contentView else { throw HostRequestFailure("unsupported: no window to present from") }
+        NSSharingServicePicker(items: items).show(relativeTo: .zero, of: view, preferredEdge: .minY)
+        return .object(["outcome": .string("shared")])
+    }
+
+    private func pickFiles(_ params: JSONObject) async throws -> JSONValue {
+        let accept = Self.parseAccept(params["accept"]?.string ?? "")
+        let panel = NSOpenPanel()
+        panel.allowsMultipleSelection = params["multiple"]?.bool ?? false
+        panel.canChooseDirectories = false
+        if !accept.types.isEmpty { panel.allowedContentTypes = accept.types }
+        let response = await panel.begin()
+        guard response == .OK else { return .object(["files": .array([])]) }
+        let files = panel.urls.compactMap { url -> JSONValue? in
+            guard let data = try? Data(contentsOf: url) else { return nil }
+            return Self.fileValue(name: url.lastPathComponent, type: Self.mimeType(of: url), data: data)
+        }
+        return .object(["files": .array(files)])
+    }
+
+    private func clipboard(_ params: JSONObject) throws -> JSONValue {
+        let pasteboard = NSPasteboard.general
+        if params["action"]?.string == "readText" { return .object(["text": .string(pasteboard.string(forType: .string) ?? "")]) }
+        pasteboard.clearContents()
+        if let text = params["text"]?.string {
+            pasteboard.setString(text, forType: .string)
+            return .object([:])
+        }
+        guard let file = params["files"]?.array?.first, let encoded = file["data"].string, let data = Data(base64Encoded: encoded) else {
+            throw HostRequestFailure("clipboard: nothing to copy")
+        }
+        if let image = NSImage(data: data) {
+            pasteboard.writeObjects([image])
+        } else {
+            pasteboard.setData(data, forType: NSPasteboard.PasteboardType(UTType(mimeType: file["type"].string ?? "")?.identifier ?? UTType.data.identifier))
+        }
+        return .object([:])
+    }
+
+    private func pickColor(_ params: JSONObject) async throws -> JSONValue {
+        throw HostRequestFailure("unsupported: no color picker on macOS yet")
+    }
+    #endif
+
+    /// What a chooser's `accept` asks for: the content types, and whether they are all pictures or videos (the photo library's).
+    static func parseAccept(_ accept: String) -> (types: [UTType], photos: Bool, images: Bool, videos: Bool) {
+        let entries = accept.split(separator: ",").map { $0.trimmingCharacters(in: .whitespaces) }.filter { !$0.isEmpty }
+        let images = entries.contains { $0.hasPrefix("image/") }
+        let videos = entries.contains { $0.hasPrefix("video/") }
+        let photos = !entries.isEmpty && entries.allSatisfy { $0.hasPrefix("image/") || $0.hasPrefix("video/") }
+        let types = entries.compactMap { entry -> UTType? in
+            if entry.hasPrefix(".") { return UTType(filenameExtension: String(entry.dropFirst())) }
+            switch entry {
+            case "image/*": return .image
+            case "video/*": return .movie
+            case "audio/*": return .audio
+            default: return UTType(mimeType: entry)
+            }
+        }
+        return (types, photos, images, videos)
+    }
+
+    /// A picked photo or video as a file: its first picture (or movie) representation, named after the item.
+    static func load(_ provider: NSItemProvider) async -> JSONValue? {
+        let identifiers = provider.registeredTypeIdentifiers
+        guard let identifier = identifiers.first(where: { UTType($0)?.conforms(to: .image) == true })
+            ?? identifiers.first(where: { UTType($0)?.conforms(to: .movie) == true })
+            ?? identifiers.first else { return nil }
+        let type = UTType(identifier)
+        let data: Data? = await withCheckedContinuation { continuation in
+            _ = provider.loadDataRepresentation(forTypeIdentifier: identifier) { data, _ in continuation.resume(returning: data) }
+        }
+        guard let data else { return nil }
+        let ext = type?.preferredFilenameExtension ?? "bin"
+        let suggested = provider.suggestedName ?? "photo"
+        let name = suggested.contains(".") ? suggested : "\(suggested).\(ext)"
+        return fileValue(name: name, type: type?.preferredMIMEType ?? "application/octet-stream", data: data)
+    }
+    #endif
+}
+
+struct HostRequestFailure: Error, CustomStringConvertible {
+    let description: String
+    init(_ description: String) { self.description = description }
+}
+
+#if canImport(AuthenticationServices)
+/// Where the sign-in sheet appears: over the key window. Keeps the session
+/// alive until it answers.
+private final class AuthPresentation: NSObject, @unchecked Sendable {
+    var session: ASWebAuthenticationSession?
+}
+
+#if !canImport(FoundationBridge)
+extension AuthPresentation: ASWebAuthenticationPresentationContextProviding {
+    func presentationAnchor(for session: ASWebAuthenticationSession) -> ASPresentationAnchor {
+        MainActor.assumeIsolated {
+            #if canImport(UIKit)
+            let windows = UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }.flatMap(\.windows)
+            return windows.first { $0.isKeyWindow } ?? windows.first ?? ASPresentationAnchor()
+            #else
+            return NSApplication.shared.keyWindow ?? ASPresentationAnchor()
+            #endif
+        }
+    }
+}
+#endif
+#endif
+
+#if canImport(UIKit) && !canImport(FoundationBridge)
+#if canImport(PhotosUI)
+private final class PhotoPickerDelegate: NSObject, PHPickerViewControllerDelegate, @unchecked Sendable {
+    private let done: @MainActor (PhotoPickerDelegate, [PHPickerResult]) -> Void
+    init(done: @escaping @MainActor (PhotoPickerDelegate, [PHPickerResult]) -> Void) { self.done = done }
+
+    // UIKit calls its delegates on the main thread; the protocols do not say so.
+    nonisolated func picker(_ picker: PHPickerViewController, didFinishPicking results: [PHPickerResult]) {
+        // Handed over on the main thread, and read there only.
+        nonisolated(unsafe) let picked = results
+        MainActor.assumeIsolated {
+            picker.dismiss(animated: true)
+            done(self, picked)
+        }
+    }
+}
+#endif
+
+private final class DocumentPickerDelegate: NSObject, UIDocumentPickerDelegate, @unchecked Sendable {
+    private let done: @MainActor (DocumentPickerDelegate, [URL]) -> Void
+    init(done: @escaping @MainActor (DocumentPickerDelegate, [URL]) -> Void) { self.done = done }
+
+    nonisolated func documentPicker(_ controller: UIDocumentPickerViewController, didPickDocumentsAt urls: [URL]) {
+        MainActor.assumeIsolated { done(self, urls) }
+    }
+
+    nonisolated func documentPickerWasCancelled(_ controller: UIDocumentPickerViewController) {
+        MainActor.assumeIsolated { done(self, []) }
+    }
+}
+
+private final class ColorPickerDelegate: NSObject, UIColorPickerViewControllerDelegate, @unchecked Sendable {
+    private let done: @MainActor (ColorPickerDelegate, String?) -> Void
+    private var finished = false
+    init(done: @escaping @MainActor (ColorPickerDelegate, String?) -> Void) { self.done = done }
+
+    nonisolated func colorPickerViewControllerDidFinish(_ viewController: UIColorPickerViewController) {
+        MainActor.assumeIsolated {
+            guard !finished else { return }
+            finished = true
+            done(self, viewController.selectedColor.hexString)
+        }
+    }
+}
+
+extension UIColor {
+    /// `#rrggbb`, else nil.
+    convenience init?(hex: String) {
+        var text = hex.trimmingCharacters(in: .whitespaces)
+        if text.hasPrefix("#") { text.removeFirst() }
+        guard text.count == 6, let value = UInt32(text, radix: 16) else { return nil }
+        self.init(red: CGFloat((value >> 16) & 0xff) / 255, green: CGFloat((value >> 8) & 0xff) / 255, blue: CGFloat(value & 0xff) / 255, alpha: 1)
+    }
+
+    var hexString: String {
+        var red: CGFloat = 0, green: CGFloat = 0, blue: CGFloat = 0, alpha: CGFloat = 0
+        getRed(&red, green: &green, blue: &blue, alpha: &alpha)
+        let component = { (value: CGFloat) in String(format: "%02x", Int((max(0, min(1, value)) * 255).rounded())) }
+        return "#\(component(red))\(component(green))\(component(blue))"
+    }
+}
+#endif
+#endif