@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/FoundationBridge/ItemProvider.swift

@@ -0,0 +1,655 @@
+// `NSItemProvider`, Foundation's carrier for content offered in several
+// types (a drag, a paste, a share extension's input, a link preview's
+// image), which corelibs Foundation does not have. In the browser a provider
+// is a list of registrations kept in memory: data, a file, an object or a
+// `Transferable` value, each under a content type. Loads run as tasks on the
+// browser's one thread and call their completion handlers when done; a
+// file representation is a copy in the temporary directory, removed once the
+// handler returns, as on iOS.
+//
+// SwiftUI's drag-and-drop API takes providers, so it lives here (the SwiftUI
+// shim cannot see this module): `onDrop`, `onDrag`, `DropInfo`,
+// `DropDelegate`. The page has no drag and drop between views or apps yet,
+// so the views are left as they are and nothing is ever dropped
+// (docs/ops-protocol.md, "Sharing and media").
+
+import Foundation
+import SwiftUI
+
+#if os(WASI)
+/// Foundation's `Progress`, which corelibs Foundation leaves out on WASI: a
+/// count of units done, children that count for part of their parent, and
+/// cancelling, pausing and resuming (which run the handlers; the work itself
+/// decides what they mean). It is an `NSObject`, so `observe(\.fractionCompleted)`
+/// works (KeyValueObserving.swift), as ButtonKit follows one.
+open class Progress: NSObject, @unchecked Sendable {
+    /// The units this progress itself has done; finished children add their pending units.
+    private var ownCompleted: Int64 = 0
+    private var children: [(progress: Progress, pending: Int64)] = []
+
+    open var totalUnitCount: Int64
+
+    /// Units done: this progress's own, plus each finished child's pending units.
+    open var completedUnitCount: Int64 {
+        get { ownCompleted + finishedChildUnits }
+        set { ownCompleted = newValue - finishedChildUnits }
+    }
+
+    open var localizedDescription: String!
+    open var localizedAdditionalDescription: String!
+    open private(set) var isCancelled = false
+    open var isCancellable = true
+    open var isPausable = false
+    open private(set) var isPaused = false
+    open var cancellationHandler: (@Sendable () -> Void)?
+    open var pausingHandler: (@Sendable () -> Void)?
+    open var resumingHandler: (@Sendable () -> Void)?
+
+    public init(totalUnitCount: Int64) {
+        self.totalUnitCount = totalUnitCount
+        super.init()
+    }
+
+    public convenience override init() {
+        self.init(totalUnitCount: -1)
+    }
+
+    /// A progress that becomes `parent`'s child (for `pendingUnitCount` of its units, once it has a total).
+    public convenience init(totalUnitCount: Int64, parent: Progress, pendingUnitCount: Int64) {
+        self.init(totalUnitCount: totalUnitCount)
+        parent.addChild(self, withPendingUnitCount: pendingUnitCount)
+    }
+
+    open class func discreteProgress(totalUnitCount: Int64) -> Progress {
+        Progress(totalUnitCount: totalUnitCount)
+    }
+
+    /// The progress current on this thread: none, the browser build has no implicit tree.
+    open class func current() -> Progress? { nil }
+
+    open func addChild(_ child: Progress, withPendingUnitCount inUnitCount: Int64) {
+        children.append((child, inUnitCount))
+        if isCancelled { child.cancel() }
+    }
+
+    private var finishedChildUnits: Int64 {
+        children.reduce(0) { $0 + ($1.progress.isFinished ? $1.pending : 0) }
+    }
+
+    /// Done units over the total, counting the unfinished children's fractions; 0 while indeterminate.
+    open var fractionCompleted: Double {
+        guard totalUnitCount > 0 else { return 0 }
+        let running = children.reduce(0.0) { $0 + ($1.progress.isFinished ? 0 : $1.progress.fractionCompleted * Double($1.pending)) }
+        return min(1, max(0, (Double(completedUnitCount) + running) / Double(totalUnitCount)))
+    }
+
+    /// As on Apple platforms: a negative count, or both counts zero.
+    open var isIndeterminate: Bool {
+        totalUnitCount < 0 || completedUnitCount < 0 || (totalUnitCount == 0 && completedUnitCount == 0)
+    }
+
+    open var isFinished: Bool { totalUnitCount > 0 && completedUnitCount >= totalUnitCount }
+
+    open func cancel() {
+        guard !isCancelled else { return }
+        isCancelled = true
+        cancellationHandler?()
+        for child in children { child.progress.cancel() }
+    }
+
+    open func pause() {
+        guard !isPaused else { return }
+        isPaused = true
+        pausingHandler?()
+        for child in children { child.progress.pause() }
+    }
+
+    open func resume() {
+        guard isPaused else { return }
+        isPaused = false
+        resumingHandler?()
+        for child in children { child.progress.resume() }
+    }
+}
+#endif
+
+// MARK: - Reading and writing objects
+
+/// A type an item provider can hand out as an object (`loadObject(ofClass:)`).
+/// `String`, `URL` and `UIImage` are; on iOS the Objective-C classes behind
+/// them are.
+public protocol NSItemProviderReading {
+    static var readableTypeIdentifiersForItemProvider: [String] { get }
+    static func object(withItemProviderData data: Data, typeIdentifier: String) throws -> Self
+}
+
+/// A type an item provider can be made from (`NSItemProvider(object:)`).
+public protocol NSItemProviderWriting {
+    static var writableTypeIdentifiersForItemProvider: [String] { get }
+    var writableTypeIdentifiersForItemProvider: [String] { get }
+    func loadData(withTypeIdentifier typeIdentifier: String,
+                  forItemProviderCompletionHandler completionHandler: @escaping @Sendable (Data?, (any Error)?) -> Void) -> Progress?
+}
+
+extension NSItemProviderWriting {
+    public var writableTypeIdentifiersForItemProvider: [String] { Self.writableTypeIdentifiersForItemProvider }
+}
+
+extension String: NSItemProviderReading, NSItemProviderWriting {
+    public static var readableTypeIdentifiersForItemProvider: [String] { [UTType.utf8PlainText.identifier, UTType.plainText.identifier, UTType.text.identifier] }
+    public static func object(withItemProviderData data: Data, typeIdentifier: String) throws -> String {
+        String(decoding: data, as: UTF8.self)
+    }
+    public static var writableTypeIdentifiersForItemProvider: [String] { [UTType.utf8PlainText.identifier] }
+    public func loadData(withTypeIdentifier typeIdentifier: String,
+                         forItemProviderCompletionHandler completionHandler: @escaping @Sendable (Data?, (any Error)?) -> Void) -> Progress? {
+        completionHandler(Data(utf8), nil)
+        return nil
+    }
+}
+
+extension URL: NSItemProviderReading, NSItemProviderWriting {
+    public static var readableTypeIdentifiersForItemProvider: [String] { [UTType.url.identifier, UTType.fileURL.identifier, UTType.plainText.identifier] }
+    public static func object(withItemProviderData data: Data, typeIdentifier: String) throws -> URL {
+        let text = String(decoding: data, as: UTF8.self).trimmingCharacters(in: .whitespacesAndNewlines)
+        guard let url = URL(string: text) else { throw CocoaError(.fileReadCorruptFile) }
+        return url
+    }
+    public static var writableTypeIdentifiersForItemProvider: [String] { [UTType.url.identifier] }
+    public var writableTypeIdentifiersForItemProvider: [String] { [(isFileURL ? UTType.fileURL : UTType.url).identifier] }
+    public func loadData(withTypeIdentifier typeIdentifier: String,
+                         forItemProviderCompletionHandler completionHandler: @escaping @Sendable (Data?, (any Error)?) -> Void) -> Progress? {
+        completionHandler(Data(absoluteString.utf8), nil)
+        return nil
+    }
+}
+
+/// UIKit's image (the SwiftUI shim's `UIImage`, which this module sees):
+/// read from any image file the page can draw; written as the file it was
+/// made from, unchanged. An image with no file (a drawing, a Core Image
+/// result, a symbol) offers no data, as it has no bytes in Swift.
+extension UIImage: NSItemProviderReading, NSItemProviderWriting {
+    public static var readableTypeIdentifiersForItemProvider: [String] {
+        [UTType.png, .jpeg, .gif, .heic, .webP, .tiff, .bmp, .image].map(\.identifier)
+    }
+
+    public static func object(withItemProviderData data: Data, typeIdentifier: String) throws -> Self {
+        guard let image = UIImage(data: data) as? Self else { throw CocoaError(.fileReadCorruptFile) }
+        return image
+    }
+
+    public static var writableTypeIdentifiersForItemProvider: [String] { [UTType.png.identifier] }
+
+    public var writableTypeIdentifiersForItemProvider: [String] {
+        guard let file = _encodedFile, let type = UTType(mimeType: file.mime) else { return [UTType.png.identifier] }
+        return [type.identifier]
+    }
+
+    public func loadData(withTypeIdentifier typeIdentifier: String,
+                         forItemProviderCompletionHandler completionHandler: @escaping @Sendable (Data?, (any Error)?) -> Void) -> Progress? {
+        if let file = _encodedFile { completionHandler(file.data, nil) } else { completionHandler(nil, CocoaError(.fileReadNoPermission)) }
+        return nil
+    }
+}
+
+// MARK: - NSItemProvider
+
+/// Content offered in one or more types, loaded on request.
+open class NSItemProvider: NSObject, @unchecked Sendable {
+    public enum FileOptions: Int, Sendable { case openInPlace = 1 }
+    public struct _FileOptions: OptionSet, Sendable {
+        public let rawValue: Int
+        public init(rawValue: Int) { self.rawValue = rawValue }
+        public static let openInPlace = _FileOptions(rawValue: 1)
+    }
+
+    /// Who may see a registration. Kept: the app is alone in the browser.
+    public enum RepresentationVisibility: Int, Sendable { case all = 0, team = 1, group = 2, ownProcess = 3 }
+
+    public typealias CompletionHandler = @Sendable (Any?, (any Error)?) -> Void
+    public typealias LoadHandler = @Sendable (CompletionHandler?, AnyClass?, [AnyHashable: Any]?) -> Void
+
+    public static let errorDomain = "NSItemProviderErrorDomain"
+    public enum ErrorCode: Int, Sendable {
+        case unknownError = -1, itemUnavailableError = -1000, unexpectedValueClassError = -1100, unavailableCoercionError = -1200
+    }
+
+    struct Registration {
+        let type: UTType
+        /// The content, when asked for; nil when it has none in this type.
+        let load: () async throws -> _TransferContent
+        /// The object it was registered from (`loadObject` and `loadItem` hand it back).
+        let object: Any?
+    }
+
+    private var registrations: [Registration] = []
+
+    /// The name a receiver gives the content (a file's name, without its extension).
+    open var suggestedName: String?
+
+    public override init() { super.init() }
+
+    /// A provider of `object` in each type it writes.
+    public convenience init(object: any NSItemProviderWriting) {
+        self.init()
+        registerObject(object, visibility: .all)
+    }
+
+    /// A provider of the file at `fileURL`, typed by its extension; nil for a
+    /// URL that is not a file's.
+    public convenience init?(contentsOf fileURL: URL?) {
+        guard let fileURL, fileURL.isFileURL else { return nil }
+        self.init()
+        let type = UTType(filenameExtension: fileURL.pathExtension) ?? .data
+        suggestedName = fileURL.deletingPathExtension().lastPathComponent
+        registrations.append(Registration(type: type, load: {
+            _TransferContent(contentType: type, file: fileURL, isOriginalFile: true, suggestedName: fileURL.deletingPathExtension().lastPathComponent)
+        }, object: fileURL))
+    }
+
+    /// A provider of `item` (a string, URL, data or other value) as `typeIdentifier`.
+    public convenience init(item: Any?, typeIdentifier: String?) {
+        self.init()
+        guard let item, let typeIdentifier else { return }
+        let type = Self.type(typeIdentifier)
+        registrations.append(Registration(type: type, load: {
+            guard let data = Self.data(of: item) else { throw Self.error(.unavailableCoercionError) }
+            return _TransferContent(contentType: type, data: data)
+        }, object: item))
+    }
+
+    // MARK: Registering
+
+    open func registerObject(_ object: any NSItemProviderWriting, visibility: RepresentationVisibility) {
+        let box = _UnsafeBox(object)
+        for identifier in object.writableTypeIdentifiersForItemProvider {
+            let type = Self.type(identifier)
+            registrations.append(Registration(type: type, load: {
+                let data = try await Self.loadData { box.value.loadData(withTypeIdentifier: identifier, forItemProviderCompletionHandler: $0) }
+                return _TransferContent(contentType: type, data: data)
+            }, object: object))
+        }
+    }
+
+    open func registerDataRepresentation(forTypeIdentifier typeIdentifier: String, visibility: RepresentationVisibility,
+                                         loadHandler: @escaping @Sendable (@escaping @Sendable (Data?, (any Error)?) -> Void) -> Progress?) {
+        registerDataRepresentation(for: Self.type(typeIdentifier), visibility: visibility, loadHandler: loadHandler)
+    }
+
+    open func registerDataRepresentation(for contentType: UTType, visibility: RepresentationVisibility = .all,
+                                         loadHandler: @escaping @Sendable (@escaping @Sendable (Data?, (any Error)?) -> Void) -> Progress?) {
+        registrations.append(Registration(type: contentType, load: {
+            _TransferContent(contentType: contentType, data: try await Self.loadData(loadHandler))
+        }, object: nil))
+    }
+
+    open func registerFileRepresentation(forTypeIdentifier typeIdentifier: String, fileOptions: _FileOptions = [],
+                                         visibility: RepresentationVisibility,
+                                         loadHandler: @escaping @Sendable (@escaping @Sendable (URL?, Bool, (any Error)?) -> Void) -> Progress?) {
+        registerFileRepresentation(for: Self.type(typeIdentifier), visibility: visibility,
+                                   openInPlace: fileOptions.contains(.openInPlace), loadHandler: loadHandler)
+    }
+
+    open func registerFileRepresentation(for contentType: UTType, visibility: RepresentationVisibility = .all, openInPlace: Bool = false,
+                                         loadHandler: @escaping @Sendable (@escaping @Sendable (URL?, Bool, (any Error)?) -> Void) -> Progress?) {
+        registrations.append(Registration(type: contentType, load: {
+            let (url, original) = try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<(URL, Bool), any Error>) in
+                _ = loadHandler { url, original, error in
+                    if let url { continuation.resume(returning: (url, original)) }
+                    else { continuation.resume(throwing: error ?? Self.error(.itemUnavailableError)) }
+                }
+            }
+            return _TransferContent(contentType: contentType, file: url, isOriginalFile: original)
+        }, object: nil))
+    }
+
+    /// The old, item-based registration: `loadHandler` is asked for the item
+    /// and hands it to the completion handler it is given.
+    open func registerItem(forTypeIdentifier typeIdentifier: String, loadHandler: @escaping LoadHandler) {
+        let type = Self.type(typeIdentifier)
+        registrations.append(Registration(type: type, load: {
+            let item: Any? = try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<_UnsafeBox<Any?>, any Error>) in
+                loadHandler({ item, error in
+                    if let error { continuation.resume(throwing: error) } else { continuation.resume(returning: _UnsafeBox(item)) }
+                }, nil, nil)
+            }.value
+            if let url = item as? URL, url.isFileURL { return _TransferContent(contentType: type, file: url, isOriginalFile: true) }
+            guard let item, let data = Self.data(of: item) else { throw Self.error(.unavailableCoercionError) }
+            return _TransferContent(contentType: type, data: data)
+        }, object: nil))
+    }
+
+    /// A `Transferable` value, in every type it exports.
+    public func register<T: Transferable>(_ transferable: @autoclosure @escaping @Sendable () -> T) {
+        for type in T.exportedContentTypes() {
+            registrations.append(Registration(type: type, load: {
+                guard let content = try await _Transfer.export(transferable(), as: type) else { throw Self.error(.unavailableCoercionError) }
+                return content
+            }, object: nil))
+        }
+    }
+
+    // MARK: What it offers
+
+    open var registeredTypeIdentifiers: [String] { registeredContentTypes.map(\.identifier) }
+
+    open var registeredContentTypes: [UTType] {
+        var seen = Set<UTType>()
+        return registrations.map(\.type).filter { seen.insert($0).inserted }
+    }
+
+    open func registeredTypeIdentifiers(fileOptions: _FileOptions) -> [String] { registeredTypeIdentifiers }
+
+    open func registeredContentTypes(conformingTo contentType: UTType) -> [UTType] {
+        registeredContentTypes.filter { $0.conforms(to: contentType) }
+    }
+
+    open var registeredContentTypesForOpenInPlace: [UTType] { [] }
+
+    open func hasItemConformingToTypeIdentifier(_ typeIdentifier: String) -> Bool {
+        let wanted = Self.type(typeIdentifier)
+        return registrations.contains { $0.type.conforms(to: wanted) }
+    }
+
+    open func hasRepresentationConforming(toTypeIdentifier typeIdentifier: String, fileOptions: _FileOptions = []) -> Bool {
+        hasItemConformingToTypeIdentifier(typeIdentifier)
+    }
+
+    open func canLoadObject(ofClass aClass: any NSItemProviderReading.Type) -> Bool {
+        registrations.contains { registration in
+            registration.object.map { Swift.type(of: $0) == aClass } ?? false
+                || aClass.readableTypeIdentifiersForItemProvider.contains { registration.type.conforms(to: Self.type($0)) }
+        }
+    }
+
+    // MARK: Loading
+
+    /// The content of the first registration conforming to `contentType`.
+    func content(conformingTo contentType: UTType) async throws -> _TransferContent {
+        guard let registration = registrations.first(where: { $0.type.conforms(to: contentType) }) else {
+            throw Self.error(.itemUnavailableError)
+        }
+        var content = try await registration.load()
+        if content.suggestedName == nil { content.suggestedName = suggestedName }
+        return content
+    }
+
+    @discardableResult
+    open func loadDataRepresentation(forTypeIdentifier typeIdentifier: String,
+                                     completionHandler: @escaping @Sendable (Data?, (any Error)?) -> Void) -> Progress {
+        loadDataRepresentation(for: Self.type(typeIdentifier), completionHandler: completionHandler)
+    }
+
+    @discardableResult
+    open func loadDataRepresentation(for contentType: UTType,
+                                     completionHandler: @escaping @Sendable (Data?, (any Error)?) -> Void) -> Progress {
+        run { () async throws -> Data in try await self.content(conformingTo: contentType).loadData() } done: { result in
+            switch result {
+            case .success(let data): completionHandler(data, nil)
+            case .failure(let error): completionHandler(nil, error)
+            }
+        }
+    }
+
+    /// The content as a file: a copy in the temporary directory, removed once
+    /// `completionHandler` returns.
+    @discardableResult
+    open func loadFileRepresentation(forTypeIdentifier typeIdentifier: String,
+                                     completionHandler: @escaping @Sendable (URL?, (any Error)?) -> Void) -> Progress {
+        loadFileRepresentation(for: Self.type(typeIdentifier), openInPlace: false) { url, _, error in completionHandler(url, error) }
+    }
+
+    @discardableResult
+    open func loadFileRepresentation(for contentType: UTType, openInPlace: Bool = false,
+                                     completionHandler: @escaping @Sendable (URL?, Bool, (any Error)?) -> Void) -> Progress {
+        run { () async throws -> ReceivedTransferredFile in
+            try Self.receivedFile(try await self.content(conformingTo: contentType), inPlace: openInPlace)
+        } done: { result in
+            switch result {
+            case .success(let file):
+                completionHandler(file.file, file.isOriginalFile, nil)
+                if !file.isOriginalFile { try? FileManager.default.removeItem(at: file.file) }
+            case .failure(let error):
+                completionHandler(nil, false, error)
+            }
+        }
+    }
+
+    @discardableResult
+    open func loadInPlaceFileRepresentation(forTypeIdentifier typeIdentifier: String,
+                                            completionHandler: @escaping @Sendable (URL?, Bool, (any Error)?) -> Void) -> Progress {
+        loadFileRepresentation(for: Self.type(typeIdentifier), openInPlace: true, completionHandler: completionHandler)
+    }
+
+    /// The registered object itself when it is of `aClass`, else one made
+    /// from the first readable type's data.
+    @discardableResult
+    open func loadObject<T: NSItemProviderReading>(ofClass aClass: T.Type,
+                                                   completionHandler: @escaping @Sendable (T?, (any Error)?) -> Void) -> Progress {
+        run { () async throws -> _UnsafeBox<T> in
+            if let object = self.registrations.lazy.compactMap({ $0.object as? T }).first { return _UnsafeBox(object) }
+            for identifier in T.readableTypeIdentifiersForItemProvider {
+                let type = Self.type(identifier)
+                guard self.registrations.contains(where: { $0.type.conforms(to: type) }) else { continue }
+                let data = try await self.content(conformingTo: type).loadData()
+                return _UnsafeBox(try T.object(withItemProviderData: data, typeIdentifier: identifier))
+            }
+            throw Self.error(.unavailableCoercionError)
+        } done: { result in
+            switch result {
+            case .success(let box): completionHandler(box.value, nil)
+            case .failure(let error): completionHandler(nil, error)
+            }
+        }
+    }
+
+    /// The old, item-based load: the registered object, a file's URL, a
+    /// string for text, a URL for a link, a `UIImage` for image data, else the data.
+    open func loadItem(forTypeIdentifier typeIdentifier: String, options: [AnyHashable: Any]? = nil,
+                       completionHandler: CompletionHandler? = nil) {
+        let wanted = Self.type(typeIdentifier)
+        _ = run { () async throws -> _UnsafeBox<Any?> in
+            guard let registration = self.registrations.first(where: { $0.type.conforms(to: wanted) }) else {
+                throw Self.error(.itemUnavailableError)
+            }
+            if let object = registration.object { return _UnsafeBox(object) }
+            let content = try await registration.load()
+            if let file = content.file { return _UnsafeBox(file) }
+            let data = try content.loadData()
+            if content.contentType.conforms(to: .url) { return _UnsafeBox(try URL.object(withItemProviderData: data, typeIdentifier: typeIdentifier)) }
+            if content.contentType.conforms(to: .text) { return _UnsafeBox(String(decoding: data, as: UTF8.self)) }
+            if content.contentType.conforms(to: .image), let image = UIImage(data: data) { return _UnsafeBox(image) }
+            return _UnsafeBox(data)
+        } done: { result in
+            switch result {
+            case .success(let box): completionHandler?(box.value, nil)
+            case .failure(let error): completionHandler?(nil, error)
+            }
+        }
+    }
+
+    /// The content as `type`, through its first importing representation
+    /// that takes a registered type.
+    @discardableResult
+    public func loadTransferable<T: Transferable>(type: T.Type,
+                                                  completionHandler: @escaping @Sendable (Result<T, any Error>) -> Void) -> Progress {
+        run { () async throws -> _UnsafeBox<T> in _UnsafeBox(try await self.loadTransferableNow(type)) } done: { result in
+            completionHandler(result.map(\.value))
+        }
+    }
+
+    /// `loadTransferable(type:completionHandler:)`, awaited.
+    nonisolated(nonsending) public func loadTransferable<T: Transferable>(type: T.Type) async throws -> T {
+        try await loadTransferableNow(type)
+    }
+
+    nonisolated(nonsending) private func loadTransferableNow<T: Transferable>(_ type: T.Type) async throws -> T {
+        for registration in registrations where _Transfer.canImport(T.self, contentType: registration.type) {
+            var content = try await registration.load()
+            if content.suggestedName == nil { content.suggestedName = suggestedName }
+            if let value = try await _Transfer.import(T.self, from: content) { return value }
+        }
+        throw Self.error(.unavailableCoercionError)
+    }
+
+    // MARK: Helpers
+
+    /// Runs `work` as a task and reports its result to `done`; the progress
+    /// completes with it.
+    private func run<Value>(_ work: @escaping () async throws -> Value, done: @escaping (Result<Value, any Error>) -> Void) -> Progress {
+        let job = _ItemProviderJob(work: work, done: done)
+        Task { await job.perform() }
+        return job.progress
+    }
+
+    private static func loadData(_ handler: @escaping @Sendable (@escaping @Sendable (Data?, (any Error)?) -> Void) -> Progress?) async throws -> Data {
+        try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Data, any Error>) in
+            _ = handler { data, error in
+                if let data { continuation.resume(returning: data) }
+                else { continuation.resume(throwing: error ?? Self.error(.itemUnavailableError)) }
+            }
+        }
+    }
+
+    static func type(_ identifier: String) -> UTType {
+        UTType(identifier) ?? UTType(exportedAs: identifier)
+    }
+
+    static func data(of item: Any) -> Data? {
+        switch item {
+        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 attributed as NSAttributedString: Data(attributed.string.utf8)
+        default: nil
+        }
+    }
+
+    static func error(_ code: ErrorCode) -> NSError {
+        NSError(domain: errorDomain, code: code.rawValue)
+    }
+
+    static func receivedFile(_ content: _TransferContent, inPlace: Bool) throws -> ReceivedTransferredFile {
+        if let file = content.file, inPlace { return ReceivedTransferredFile(_file: file, isOriginalFile: true) }
+        let folder = FileManager.default.temporaryDirectory.appendingPathComponent("ItemProvider-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
+        let copy = folder.appendingPathComponent(content.fileName)
+        if let file = content.file { try FileManager.default.copyItem(at: file, to: copy) } else { try content.loadData().write(to: copy) }
+        return ReceivedTransferredFile(_file: copy, isOriginalFile: false)
+    }
+}
+
+/// One load: its work, its completion and its progress.
+final class _ItemProviderJob<Value>: @unchecked Sendable {
+    let work: () async throws -> Value
+    let done: (Result<Value, any Error>) -> Void
+    let progress = Progress(totalUnitCount: 1)
+
+    init(work: @escaping () async throws -> Value, done: @escaping (Result<Value, any Error>) -> Void) {
+        self.work = work
+        self.done = done
+    }
+
+    func perform() async {
+        var result: Result<Value, any Error>
+        do {
+            let value = try await work()
+            result = .success(value)
+        } catch {
+            result = .failure(error)
+        }
+        progress.completedUnitCount = 1
+        done(result)
+    }
+}
+
+/// A value carried across a task boundary on the browser's one thread.
+struct _UnsafeBox<Value>: @unchecked Sendable {
+    let value: Value
+    init(_ value: Value) { self.value = value }
+}
+
+// MARK: - SwiftUI: drag and drop
+
+/// What a drop offers: where it is and the providers of what was dropped.
+/// The page has no drag and drop yet, so no drop is ever delivered.
+public struct DropInfo {
+    public let location: SwiftUI.CGPoint
+    let providers: [NSItemProvider]
+
+    public init(_location location: SwiftUI.CGPoint, providers: [NSItemProvider]) {
+        self.location = location
+        self.providers = providers
+    }
+
+    public func hasItemsConforming(to contentTypes: [UTType]) -> Bool {
+        providers.contains { provider in contentTypes.contains { !provider.registeredContentTypes(conformingTo: $0).isEmpty } }
+    }
+
+    public func hasItemsConforming(to typeIdentifiers: [String]) -> Bool {
+        hasItemsConforming(to: typeIdentifiers.map(NSItemProvider.type))
+    }
+
+    public func itemProviders(for contentTypes: [UTType]) -> [NSItemProvider] {
+        providers.filter { provider in contentTypes.contains { !provider.registeredContentTypes(conformingTo: $0).isEmpty } }
+    }
+
+    public func itemProviders(for typeIdentifiers: [String]) -> [NSItemProvider] {
+        itemProviders(for: typeIdentifiers.map(NSItemProvider.type))
+    }
+}
+
+/// How a drop would act on what it carries.
+public enum DropOperation: Sendable {
+    case cancel, forbidden, copy, move
+}
+
+public struct DropProposal: Sendable {
+    public let operation: DropOperation
+    public init(operation: DropOperation) { self.operation = operation }
+}
+
+/// What a drop target is told as a drag moves over it and drops. Every
+/// method has a default, as on iOS. Never called in the browser yet.
+@MainActor
+public protocol DropDelegate {
+    func validateDrop(info: DropInfo) -> Bool
+    func performDrop(info: DropInfo) -> Bool
+    func dropEntered(info: DropInfo)
+    func dropUpdated(info: DropInfo) -> DropProposal?
+    func dropExited(info: DropInfo)
+}
+
+extension DropDelegate {
+    public func validateDrop(info: DropInfo) -> Bool { true }
+    public func dropEntered(info: DropInfo) {}
+    public func dropUpdated(info: DropInfo) -> DropProposal? { nil }
+    public func dropExited(info: DropInfo) {}
+}
+
+extension View {
+    /// Accepted; nothing is dropped in the browser, so `action` is never called.
+    public func onDrop(of supportedContentTypes: [UTType], isTargeted: Binding<Bool>?,
+                       perform action: @escaping ([NSItemProvider]) -> Bool) -> some View { self }
+
+    /// Accepted; nothing is dropped in the browser, so `action` is never called.
+    public func onDrop(of supportedContentTypes: [UTType], isTargeted: Binding<Bool>?,
+                       perform action: @escaping ([NSItemProvider], SwiftUI.CGPoint) -> Bool) -> some View { self }
+
+    /// Accepted; nothing is dropped in the browser, so the delegate hears nothing.
+    public func onDrop(of supportedContentTypes: [UTType], delegate: any DropDelegate) -> some View { self }
+
+    public func onDrop(of supportedTypes: [String], isTargeted: Binding<Bool>?,
+                       perform action: @escaping ([NSItemProvider]) -> Bool) -> some View { self }
+
+    public func onDrop(of supportedTypes: [String], delegate: any DropDelegate) -> some View { self }
+
+    /// Accepted; the view cannot be dragged in the browser.
+    public func onDrag(_ data: @escaping () -> NSItemProvider) -> some View { self }
+
+    /// Accepted; the view cannot be dragged in the browser.
+    public func onDrag<Preview: View>(_ data: @escaping () -> NSItemProvider, @ViewBuilder preview: () -> Preview) -> some View { self }
+
+    /// Accepted (macOS's services and iOS's drag source): nothing asks for the provider.
+    public func itemProvider(_ action: (() -> NSItemProvider?)?) -> some View { self }
+}