@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/UIKit/Pasteboard.swift

@@ -0,0 +1,363 @@
+// `UIPasteboard` in the browser. A page cannot read the system clipboard
+// without asking the viewer each time (and never synchronously), so the
+// pasteboard keeps its items in memory, as an app-private pasteboard would:
+// what the app put there, it reads back. Writing also copies to the system
+// clipboard through the page (a `clipboard` host request: the Async
+// Clipboard API's `writeText`, or an `image/png` item for an image), so the
+// viewer can paste a copied link or picture in another app. Text the viewer
+// pastes into a text field or editor is the browser's own paste, which needs
+// none of this (docs/ops-protocol.md, "Sharing and media").
+
+// On iOS, UIKit brings UniformTypeIdentifiers along (`UTType.jpeg` with
+// only `import UIKit`).
+@_exported import UniformTypeIdentifiers
+import Foundation
+import FoundationBridge
+import SwiftUI
+
+/// The system clipboard, through the page.
+@MainActor
+public enum _PageClipboard {
+    /// Copies `fields` (`text`, or a picture's `files` / `bitmaps` / `images`)
+    /// to the system clipboard. The answer is not awaited by the app: the
+    /// browser may refuse (no focus, no permission), and the in-memory
+    /// pasteboard has the items either way.
+    public static func write(_ fields: [String: _JSON]) {
+        guard !fields.isEmpty else { return }
+        var params = fields
+        params["action"] = .string("write")
+        Task { @MainActor in
+            _ = try? await _PageFiles.hostRequest("clipboard", .object(params), .object([:]))
+        }
+    }
+
+    /// Reads the system clipboard's text (the browser may ask the viewer
+    /// first, or refuse); nil when there is none or the page could not read it.
+    public static func readText() async -> String? {
+        guard let answer = try? await _PageFiles.hostRequest("clipboard", .object(["action": .string("readText")]), .object([:])),
+              case .object(let fields) = answer, case .string(let text)? = fields["text"] else { return nil }
+        return text
+    }
+}
+
+/// A pasteboard: the general one (also copied to the system clipboard) or a
+/// named one, private to the app. Items are dictionaries from type
+/// identifiers to values (strings, URLs, images, data), as on iOS.
+open class UIPasteboard: @unchecked Sendable {
+    public struct Name: RawRepresentable, Hashable, Sendable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public init(_ rawValue: String) { self.rawValue = rawValue }
+        public static let general = Name("com.apple.UIKit.pboard.general")
+        @available(*, deprecated)
+        public static let find = Name("com.apple.UIKit.pboard.find")
+    }
+
+    public struct OptionsKey: RawRepresentable, Hashable, Sendable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let localOnly = OptionsKey(rawValue: "com.apple.UIKit.pboard.localOnly")
+        public static let expirationDate = OptionsKey(rawValue: "com.apple.UIKit.pboard.expirationDate")
+    }
+
+    public static let changedNotification = Notification.Name("UIPasteboardChangedNotification")
+    public static let removedNotification = Notification.Name("UIPasteboardRemovedNotification")
+    public static let changedTypesAddedUserInfoKey = "UIPasteboardChangedTypesAddedKey"
+    public static let changedTypesRemovedUserInfoKey = "UIPasteboardChangedTypesRemovedKey"
+
+    public static let typeListString: [String] = [UTType.utf8PlainText.identifier, UTType.plainText.identifier, UTType.text.identifier]
+    public static let typeListURL: [String] = [UTType.url.identifier]
+    public static let typeListImage: [String] = [UTType.png.identifier, UTType.jpeg.identifier, UTType.gif.identifier, UTType.image.identifier]
+    public static let typeListColor: [String] = ["com.apple.uikit.color"]
+    public static let typeAutomatic = "com.apple.uikit.pasteboard.automatic"
+
+    nonisolated(unsafe) private static var named: [Name: UIPasteboard] = [:]
+
+    /// The general pasteboard: what the app copies also goes to the system clipboard.
+    public static var general: UIPasteboard { pasteboard(.general) }
+
+    public let name: Name
+    open var isPersistent = false
+    public private(set) var changeCount = 0
+    private var storage: [[String: Any]] = []
+
+    init(name: Name) { self.name = name }
+
+    private static func pasteboard(_ name: Name) -> UIPasteboard {
+        if let existing = named[name] { return existing }
+        let pasteboard = UIPasteboard(name: name)
+        named[name] = pasteboard
+        return pasteboard
+    }
+
+    /// A named pasteboard, private to the app; nil when it does not exist and `create` is false.
+    public convenience init?(name pasteboardName: Name, create: Bool) {
+        guard create || Self.named[pasteboardName] != nil else { return nil }
+        self.init(name: pasteboardName)
+    }
+
+    public static func withUniqueName() -> UIPasteboard { pasteboard(Name(UUID().uuidString)) }
+
+    public static func remove(withName pasteboardName: Name) { named[pasteboardName] = nil }
+
+    // MARK: Items
+
+    /// The items, each a dictionary from type identifiers to values.
+    open var items: [[String: Any]] {
+        get { storage }
+        set { setItems(newValue) }
+    }
+
+    open func setItems(_ items: [[String: Any]], options: [OptionsKey: Any] = [:]) {
+        storage = items
+        changed()
+    }
+
+    open func addItems(_ items: [[String: Any]]) {
+        storage += items
+        changed()
+    }
+
+    open var numberOfItems: Int { storage.count }
+
+    /// The types of the first item.
+    open var types: [String] { storage.first.map { Array($0.keys) } ?? [] }
+
+    open func types(forItemSet itemSet: IndexSet?) -> [[String]]? {
+        indices(itemSet).map { Array(storage[$0].keys) }
+    }
+
+    open func contains(pasteboardTypes: [String]) -> Bool {
+        storage.contains { item in item.keys.contains { key in pasteboardTypes.contains { Self.conforms(key, to: $0) } } }
+    }
+
+    open func contains(pasteboardTypes: [String], inItemSet itemSet: IndexSet?) -> Bool {
+        indices(itemSet).contains { index in storage[index].keys.contains { key in pasteboardTypes.contains { Self.conforms(key, to: $0) } } }
+    }
+
+    open func data(forPasteboardType pasteboardType: String) -> Data? {
+        guard let value = value(forPasteboardType: pasteboardType) else { return nil }
+        switch value {
+        case let data as Data: return data
+        case let string as String: return Data(string.utf8)
+        case let url as URL: return Data(url.absoluteString.utf8)
+        case let image as UIImage: return image._encodedFile?.data
+        default: return nil
+        }
+    }
+
+    open func setData(_ data: Data, forPasteboardType pasteboardType: String) {
+        storage = [[pasteboardType: data]]
+        changed()
+        if UTType(pasteboardType)?.conforms(to: .text) == true {
+            copyValueToSystem(String(decoding: data, as: UTF8.self))
+        } else if let image = UIImage(data: data) {
+            copyValueToSystem(image)
+        }
+    }
+
+    /// The first item's value for a type (or a type conforming to it).
+    open func value(forPasteboardType pasteboardType: String) -> Any? {
+        guard let first = storage.first else { return nil }
+        if let value = first[pasteboardType] { return value }
+        return first.first { Self.conforms($0.key, to: pasteboardType) }?.value
+    }
+
+    open func setValue(_ value: Any, forPasteboardType pasteboardType: String) {
+        storage = [[pasteboardType: value]]
+        changed()
+        copyValueToSystem(value)
+    }
+
+    open func data(forPasteboardType pasteboardType: String, inItemSet itemSet: IndexSet?) -> [Data]? {
+        let found = indices(itemSet).compactMap { storage[$0][pasteboardType] as? Data }
+        return found.isEmpty ? nil : found
+    }
+
+    open func values(forPasteboardType pasteboardType: String, inItemSet itemSet: IndexSet?) -> [Any]? {
+        let found = indices(itemSet).compactMap { storage[$0][pasteboardType] }
+        return found.isEmpty ? nil : found
+    }
+
+    // MARK: Item providers
+
+    /// An item provider per item, offering its values.
+    open var itemProviders: [NSItemProvider] {
+        get {
+            storage.map { item in
+                let provider = NSItemProvider()
+                for (key, value) in item {
+                    if let object = value as? any NSItemProviderWriting {
+                        provider.registerObject(object, visibility: .all)
+                    } else {
+                        let box = _PasteboardValue(value)
+                        provider.registerDataRepresentation(forTypeIdentifier: key, visibility: .all) { completion in
+                            completion(box.data, nil)
+                            return nil
+                        }
+                    }
+                }
+                return provider
+            }
+        }
+        set { setItemProviders(newValue, localOnly: false, expirationDate: nil) }
+    }
+
+    /// Takes the providers' objects: what each offers as text, a URL or an
+    /// image is loaded and becomes an item, in order, when loaded.
+    open func setItemProviders(_ itemProviders: [NSItemProvider], localOnly: Bool, expirationDate: Date?) {
+        storage = []
+        changed()
+        for provider in itemProviders {
+            if provider.canLoadObject(ofClass: UIImage.self) {
+                provider.loadObject(ofClass: UIImage.self) { [weak self] image, _ in
+                    guard let image else { return }
+                    Task { @MainActor in self?.image = image }
+                }
+            } else if provider.canLoadObject(ofClass: URL.self) {
+                provider.loadObject(ofClass: URL.self) { [weak self] url, _ in
+                    guard let url else { return }
+                    Task { @MainActor in self?.url = url }
+                }
+            } else if provider.canLoadObject(ofClass: String.self) {
+                provider.loadObject(ofClass: String.self) { [weak self] string, _ in
+                    guard let string else { return }
+                    Task { @MainActor in self?.string = string }
+                }
+            }
+        }
+    }
+
+    open func setObjects<T: NSItemProviderWriting>(_ objects: [T]) {
+        setObjects(objects, localOnly: false, expirationDate: nil)
+    }
+
+    open func setObjects<T: NSItemProviderWriting>(_ objects: [T], localOnly: Bool, expirationDate: Date?) {
+        storage = objects.map { object in
+            Dictionary(object.writableTypeIdentifiersForItemProvider.map { ($0, object as Any) }, uniquingKeysWith: { first, _ in first })
+        }
+        changed()
+        if let first = objects.first { copyValueToSystem(first) }
+    }
+
+    // MARK: Strings, URLs, images, colors
+
+    /// The first text item, or the first URL as text (as iOS coerces it).
+    open var string: String? {
+        get { strings?.first }
+        set { set(newValue.map { [$0] } ?? [], type: UTType.utf8PlainText.identifier) }
+    }
+
+    open var strings: [String]? {
+        get {
+            let found = storage.compactMap { item -> String? in
+                if let text = Self.typeListString.lazy.compactMap({ item[$0] as? String }).first { return text }
+                return (item[UTType.url.identifier] as? URL)?.absoluteString
+            }
+            return found.isEmpty ? nil : found
+        }
+        set { set(newValue ?? [], type: UTType.utf8PlainText.identifier) }
+    }
+
+    open var url: URL? {
+        get { urls?.first }
+        set { set(newValue.map { [$0] } ?? [], type: UTType.url.identifier) }
+    }
+
+    open var urls: [URL]? {
+        get {
+            let found = storage.compactMap { item -> URL? in
+                if let url = item[UTType.url.identifier] as? URL { return url }
+                return Self.typeListString.lazy.compactMap { item[$0] as? String }.first.flatMap { URL(string: $0) }.flatMap { $0.scheme == nil ? nil : $0 }
+            }
+            return found.isEmpty ? nil : found
+        }
+        set { set(newValue ?? [], type: UTType.url.identifier) }
+    }
+
+    open var image: UIImage? {
+        get { images?.first }
+        set { set(newValue.map { [$0] } ?? [], type: UTType.png.identifier) }
+    }
+
+    open var images: [UIImage]? {
+        get {
+            let found = storage.compactMap { item in item.values.lazy.compactMap { $0 as? UIImage }.first }
+            return found.isEmpty ? nil : found
+        }
+        set { set(newValue ?? [], type: UTType.png.identifier) }
+    }
+
+    open var color: UIColor? {
+        get { colors?.first }
+        set { set(newValue.map { [$0] } ?? [], type: Self.typeListColor[0]) }
+    }
+
+    open var colors: [UIColor]? {
+        get {
+            let found = storage.compactMap { item in item.values.lazy.compactMap { $0 as? UIColor }.first }
+            return found.isEmpty ? nil : found
+        }
+        set { set(newValue ?? [], type: Self.typeListColor[0]) }
+    }
+
+    open var hasStrings: Bool { strings != nil }
+    open var hasURLs: Bool { urls != nil }
+    open var hasImages: Bool { images != nil }
+    open var hasColors: Bool { colors != nil }
+
+    // MARK: Helpers
+
+    private func set(_ values: [Any], type: String) {
+        storage = values.map { [type: $0] }
+        changed()
+        if let first = values.first { copyValueToSystem(first) }
+    }
+
+    private func changed() {
+        changeCount += 1
+        FoundationBridge.NotificationCenter.default.post(name: Self.changedNotification, object: self)
+    }
+
+    /// Copies a string, URL or image to the system clipboard: only the
+    /// general pasteboard's, from a task on the main actor (which the
+    /// browser runs right after the tap that copied, so the page still has
+    /// the viewer's activation).
+    private func copyValueToSystem(_ value: Any) {
+        guard name == .general else { return }
+        let box = _PasteboardValue(value)
+        Task { @MainActor in
+            switch box.value {
+            case let string as String: _PageClipboard.write(["text": .string(string)])
+            case let url as URL: _PageClipboard.write(["text": .string(url.absoluteString)])
+            case let image as UIImage: _PageClipboard.write(_PageFiles.fields(for: image, name: "Image"))
+            default: break
+            }
+        }
+    }
+
+    private func indices(_ itemSet: IndexSet?) -> [Int] {
+        guard let itemSet else { return Array(storage.indices) }
+        return itemSet.filter { storage.indices.contains($0) }
+    }
+
+    private static func conforms(_ identifier: String, to other: String) -> Bool {
+        if identifier == other { return true }
+        guard let type = UTType(identifier), let otherType = UTType(other) else { return false }
+        return type.conforms(to: otherType)
+    }
+}
+
+private struct _PasteboardValue: @unchecked Sendable {
+    let value: Any
+    init(_ value: Any) { self.value = value }
+    var data: Data? {
+        switch value {
+        case let data as Data: data
+        case let string as String: Data(string.utf8)
+        case let url as URL: Data(url.absoluteString.utf8)
+        case let image as UIImage: image._encodedFile?.data
+        default: nil
+        }
+    }
+}

package/Sources/UIKit/PhotoAlbum.swift

@@ -0,0 +1,81 @@
+// Saving to the photo album, in the browser: the page has no photo library,
+// so a saved image or video becomes a download (a `download` host request;
+// docs/ops-protocol.md, "Sharing and media"). The browser puts it in the
+// viewer's downloads folder, or asks where to, as it does for any download.
+// Photos' `PHAssetChangeRequest` saves the same way (Sources/Photos).
+
+import Foundation
+import FoundationBridge
+import SwiftUI
+
+/// Files the app hands to the page: to download (`download`), share
+/// (`share`) or copy (`clipboard`). Used by UIKit, Photos and LinkPresentation.
+@MainActor
+public enum _PageFiles {
+    /// The request fields that carry `image`: `files` for an image made from
+    /// a file (its own bytes), `bitmaps` for one the page draws from a recipe
+    /// (Core Image, a drawing; the page encodes it as PNG), `images` for an
+    /// asset-catalog image. Empty for a symbol or an empty image.
+    public static func fields(for image: UIImage, name: String) -> [String: _JSON] {
+        if let file = image._encodedFile {
+            let ext = UTType(mimeType: file.mime)?.preferredFilenameExtension ?? "png"
+            return ["files": .array([entry(name: "\(name).\(ext)", type: file.mime, data: file.data)])]
+        }
+        if let recipe = image._recipe, let source = recipe.source {
+            _Runtime.shared._sendImageSource(source)
+            return ["bitmaps": .array([recipe._json])]
+        }
+        if let catalogName = image._catalogName { return ["images": .array([.string(catalogName)])] }
+        return [:]
+    }
+
+    /// The `files` entry for a file's bytes.
+    public static func entry(name: String, type: String, data: Data) -> _JSON {
+        .object(["name": .string(name), "type": .string(type), "data": .string(_base64([UInt8](data)))])
+    }
+
+    /// The `files` entry for the file at `url`, typed by its extension.
+    public static func entry(fileURL url: URL) throws -> _JSON {
+        let type = UTType(filenameExtension: url.pathExtension)?.preferredMIMEType ?? "application/octet-stream"
+        return entry(name: url.lastPathComponent, type: type, data: try Data(contentsOf: url))
+    }
+
+    /// Asks the page to download what `fields` carry (`title` names bitmap
+    /// files). Headless runs answer at once; the op in the log is the record.
+    public static func download(_ fields: [String: _JSON], title: String) async throws {
+        guard !fields.isEmpty else { throw CocoaError(.fileWriteUnknown) }
+        var params = fields
+        params["title"] = .string(title)
+        _ = try await hostRequest("download", .object(params), .object(["outcome": .string("headless")]))
+    }
+
+    /// Sends a host request (kind, params, headless answer); tests replace it.
+    public static var hostRequest: @MainActor (String, _JSON, _JSON) async throws -> _JSON = { kind, params, headless in
+        try await _Runtime.shared._hostRequest(kind: kind, params: params, headless: headless)
+    }
+}
+
+/// Saves `image` to the photo album: in the browser, downloads it (its own
+/// file for an image made from data, else a PNG the page draws). The
+/// completion selector is not called (the browser's Swift cannot call a
+/// three-argument selector); the download happens or fails on its own.
+public func UIImageWriteToSavedPhotosAlbum(_ image: UIImage, _ completionTarget: Any?, _ completionSelector: Selector?,
+                                           _ contextInfo: UnsafeMutableRawPointer?) {
+    Task { @MainActor in
+        try? await _PageFiles.download(_PageFiles.fields(for: image, name: "Photo"), title: "Photo")
+    }
+}
+
+/// Whether the video at `videoPath` can be saved: any file that exists.
+public func UIVideoAtPathIsCompatibleWithSavedPhotosAlbum(_ videoPath: String) -> Bool {
+    FileManager.default.fileExists(atPath: videoPath)
+}
+
+/// Saves the video at `videoPath` to the photo album: in the browser, downloads the file.
+public func UISaveVideoAtPathToSavedPhotosAlbum(_ videoPath: String, _ completionTarget: Any?, _ completionSelector: Selector?,
+                                                _ contextInfo: UnsafeMutableRawPointer?) {
+    Task { @MainActor in
+        guard let entry = try? _PageFiles.entry(fileURL: URL(fileURLWithPath: videoPath)) else { return }
+        try? await _PageFiles.download(["files": .array([entry])], title: "Video")
+    }
+}

package/Sources/UIKit/RemoteNotifications.swift

@@ -0,0 +1,15 @@
+// Remote (APNs) notification registration. The browser has no APNs: Apple
+// never hands the page a device token, so registering does nothing and the
+// app delegate's `didRegisterForRemoteNotificationsWithDeviceToken` is never
+// called, which apps already handle (a simulator behaves the same). Local
+// notifications are UserNotifications' (docs/ops-protocol.md, "Notifications").
+
+import Foundation
+
+extension UIApplication {
+    /// Does nothing: no device token ever arrives.
+    public func registerForRemoteNotifications() {}
+    public func unregisterForRemoteNotifications() {}
+    /// False: the page never gets a device token.
+    public var isRegisteredForRemoteNotifications: Bool { false }
+}