@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/Photos/Photos.swift

@@ -0,0 +1,572 @@
+// `import Photos` for the browser. A web page has no photo library: it can
+// neither read the viewer's photos nor add to them. What it can do is hand
+// the viewer a file, and that is what saving does here:
+//
+// - Adding (`PHPhotoLibrary.performChanges` with a `PHAssetChangeRequest`
+//   or `PHAssetCreationRequest`, and UIKit's `UIImageWriteToSavedPhotosAlbum`)
+//   downloads each new photo or video through the page (a `download` host
+//   request; docs/ops-protocol.md, "Sharing and media"). So `.addOnly`
+//   access is `.authorized`, which is what apps check before saving.
+// - Reading finds nothing: fetches return no assets, and image requests
+//   answer nil. `.readWrite` access is `.limited`, iOS's answer when the
+//   viewer shared only some photos, which here are none; photos reach the
+//   app through PhotosUI's `PhotosPicker` instead (the page's file chooser).
+//
+// Change observers are registered and never called; nothing else changes
+// the library while the app runs.
+
+@_exported import Foundation
+import FoundationBridge
+import SwiftUI
+import UIKit
+
+// MARK: - Authorization
+
+public enum PHAccessLevel: Int, Sendable {
+    case addOnly = 1
+    case readWrite = 2
+}
+
+public enum PHAuthorizationStatus: Int, Sendable {
+    case notDetermined = 0
+    case restricted = 1
+    case denied = 2
+    case authorized = 3
+    case limited = 4
+}
+
+// MARK: - Errors
+
+public let PHPhotosErrorDomain = "PHPhotosErrorDomain"
+
+/// A photo library error, with Photos' codes.
+public struct PHPhotosError: Error, Hashable, Sendable, CustomNSError {
+    public enum Code: Int, Sendable {
+        case internalError = -1
+        case userCancelled = 3072
+        case libraryVolumeOffline = 3114
+        case relinquishingLibraryBundleToWriter = 3142
+        case switchingSystemPhotoLibrary = 3143
+        case networkAccessRequired = 3164
+        case networkError = 3169
+        case identifierNotFound = 3201
+        case multipleIdentifiersFound = 3202
+        case changeNotSupported = 3300
+        case operationInterrupted = 3301
+        case invalidResource = 3302
+        case missingResource = 3303
+        case notEnoughSpace = 3305
+        case requestNotSupportedForAsset = 3306
+        case accessRestricted = 3310
+        case accessUserDenied = 3311
+        case libraryInFileProviderSyncRoot = 5423
+        case persistentChangeTokenExpired = 3105
+        case persistentChangeDetailsUnavailable = 3210
+        case invalid = -2
+    }
+
+    public let code: Code
+    public init(_ code: Code) { self.code = code }
+
+    public static var errorDomain: String { PHPhotosErrorDomain }
+    public var errorCode: Int { code.rawValue }
+    public var errorUserInfo: [String: Any] { [:] }
+}
+
+// MARK: - The library
+
+/// Told about changes to the library. Registered and never called.
+public protocol PHPhotoLibraryChangeObserver: AnyObject {
+    func photoLibraryDidChange(_ changeInstance: PHChange)
+}
+
+/// A set of changes to the library. Never made in the browser.
+public final class PHChange: @unchecked Sendable {
+    init() {}
+    public func changeDetails<T: PHObject>(for object: T) -> PHObjectChangeDetails<T>? { nil }
+    public func changeDetails<T: PHObject>(for fetchResult: PHFetchResult<T>) -> PHFetchResultChangeDetails<T>? { nil }
+}
+
+public final class PHObjectChangeDetails<ObjectType: PHObject>: @unchecked Sendable {
+    init() {}
+}
+
+public final class PHFetchResultChangeDetails<ObjectType: AnyObject>: @unchecked Sendable {
+    init() {}
+}
+
+/// The photo library (see the top of the file): saving downloads, reading finds nothing.
+public final class PHPhotoLibrary: @unchecked Sendable {
+    private static let library = PHPhotoLibrary()
+    public static func shared() -> PHPhotoLibrary { library }
+
+    init() {}
+
+    /// `.authorized` for `.addOnly` (saving downloads), `.limited` for
+    /// `.readWrite` (the library shows the app nothing).
+    public static func authorizationStatus(for accessLevel: PHAccessLevel) -> PHAuthorizationStatus {
+        accessLevel == .addOnly ? .authorized : .limited
+    }
+
+    /// iOS 13's form, which reports `.authorized` for limited access.
+    @available(*, deprecated, renamed: "authorizationStatus(for:)")
+    public static func authorizationStatus() -> PHAuthorizationStatus { .authorized }
+
+    /// Answers at once: nothing asks the viewer.
+    public static func requestAuthorization(for accessLevel: PHAccessLevel) async -> PHAuthorizationStatus {
+        authorizationStatus(for: accessLevel)
+    }
+
+    public static func requestAuthorization(for accessLevel: PHAccessLevel,
+                                            handler: @escaping @Sendable (PHAuthorizationStatus) -> Void) {
+        handler(authorizationStatus(for: accessLevel))
+    }
+
+    @available(*, deprecated, renamed: "requestAuthorization(for:handler:)")
+    public static func requestAuthorization(_ handler: @escaping @Sendable (PHAuthorizationStatus) -> Void) {
+        handler(.authorized)
+    }
+
+    /// Runs `changeBlock` at once, then saves what it created (downloads);
+    /// `completionHandler` hears whether every save went through.
+    public func performChanges(_ changeBlock: @escaping () -> Void,
+                               completionHandler: (@Sendable (Bool, (any Error)?) -> Void)? = nil) {
+        let saves = Self.collect(changeBlock)
+        let box = _PhotosBox(saves)
+        Task { @MainActor in
+            do {
+                try await Self.perform(box.value)
+                completionHandler?(true, nil)
+            } catch {
+                completionHandler?(false, error)
+            }
+        }
+    }
+
+    nonisolated(nonsending) public func performChanges(_ changeBlock: @escaping () -> Void) async throws {
+        let saves = Self.collect(changeBlock)
+        let box = _PhotosBox(saves)
+        try await Task { @MainActor in try await Self.perform(box.value) }.value
+    }
+
+    /// Runs `changeBlock`; the downloads start without being waited for.
+    public func performChangesAndWait(_ changeBlock: () -> Void) throws {
+        let saves = withoutActuallyEscaping(changeBlock) { Self.collect($0) }
+        let box = _PhotosBox(saves)
+        Task { @MainActor in try? await Self.perform(box.value) }
+    }
+
+    public func register(_ observer: any PHPhotoLibraryChangeObserver) {}
+    public func unregisterChangeObserver(_ observer: any PHPhotoLibraryChangeObserver) {}
+
+    /// Nothing to show: the page has no library picker (PhotosUI's
+    /// `PhotosPicker` opens the file chooser).
+    @MainActor public func presentLimitedLibraryPicker(from controller: UIViewController) {}
+    @MainActor public func presentLimitedLibraryPicker(from controller: UIViewController) async -> [String] { [] }
+
+    public var unavailabilityReason: (any Error)? { nil }
+
+    // MARK: Changes
+
+    /// The change requests made while a change block runs.
+    nonisolated(unsafe) static var pending: [PHAssetChangeRequest]?
+
+    private static func collect(_ changeBlock: () -> Void) -> [PHAssetChangeRequest] {
+        let outer = pending
+        pending = []
+        changeBlock()
+        let made = pending ?? []
+        pending = outer
+        return made
+    }
+
+    /// Saves what the requests created, as downloads (the other changes, to
+    /// assets the library does not have, do nothing).
+    @MainActor
+    private static func perform(_ requests: [PHAssetChangeRequest]) async throws {
+        for request in requests {
+            guard let (fields, title) = try request.download() else { continue }
+            try await _PageFiles.download(fields, title: title)
+        }
+    }
+}
+
+private struct _PhotosBox<Value>: @unchecked Sendable {
+    let value: Value
+    init(_ value: Value) { self.value = value }
+}
+
+// MARK: - Objects and fetches
+
+/// A library object.
+open class PHObject: Hashable, @unchecked Sendable {
+    public let localIdentifier: String
+
+    init(localIdentifier: String) { self.localIdentifier = localIdentifier }
+
+    public static func == (lhs: PHObject, rhs: PHObject) -> Bool { lhs.localIdentifier == rhs.localIdentifier }
+    public func hash(into hasher: inout Hasher) { hasher.combine(localIdentifier) }
+}
+
+/// Stands for an asset a change block created, by identifier.
+public final class PHObjectPlaceholder: PHObject, @unchecked Sendable {}
+
+public enum PHAssetMediaType: Int, Sendable {
+    case unknown = 0, image = 1, video = 2, audio = 3
+}
+
+public struct PHAssetMediaSubtype: OptionSet, Hashable, Sendable {
+    public let rawValue: UInt
+    public init(rawValue: UInt) { self.rawValue = rawValue }
+    public static let photoPanorama = PHAssetMediaSubtype(rawValue: 1 << 0)
+    public static let photoHDR = PHAssetMediaSubtype(rawValue: 1 << 1)
+    public static let photoScreenshot = PHAssetMediaSubtype(rawValue: 1 << 2)
+    public static let photoLive = PHAssetMediaSubtype(rawValue: 1 << 3)
+    public static let photoDepthEffect = PHAssetMediaSubtype(rawValue: 1 << 4)
+    public static let spatialMedia = PHAssetMediaSubtype(rawValue: 1 << 10)
+    public static let videoStreamed = PHAssetMediaSubtype(rawValue: 1 << 16)
+    public static let videoHighFrameRate = PHAssetMediaSubtype(rawValue: 1 << 17)
+    public static let videoTimelapse = PHAssetMediaSubtype(rawValue: 1 << 18)
+    public static let videoCinematic = PHAssetMediaSubtype(rawValue: 1 << 21)
+}
+
+public struct PHAssetSourceType: OptionSet, Hashable, Sendable {
+    public let rawValue: UInt
+    public init(rawValue: UInt) { self.rawValue = rawValue }
+    public static let typeUserLibrary = PHAssetSourceType(rawValue: 1 << 0)
+    public static let typeCloudShared = PHAssetSourceType(rawValue: 1 << 1)
+    public static let typeiTunesSynced = PHAssetSourceType(rawValue: 1 << 2)
+}
+
+public enum PHAssetPlaybackStyle: Int, Sendable {
+    case unsupported = 0, image, imageAnimated, livePhoto, video, videoLooping
+}
+
+/// A photo or video in the library. The browser's library has none, so no
+/// fetch returns one.
+public final class PHAsset: PHObject, @unchecked Sendable {
+    public let mediaType: PHAssetMediaType
+    public let mediaSubtypes: PHAssetMediaSubtype
+    public let pixelWidth: Int
+    public let pixelHeight: Int
+    public let creationDate: Date?
+    public let modificationDate: Date?
+    public let duration: TimeInterval
+    public let isFavorite: Bool
+    public let isHidden: Bool
+    public let sourceType: PHAssetSourceType
+    public let playbackStyle: PHAssetPlaybackStyle
+    public let location: AnyObject?
+    public let burstIdentifier: String?
+
+    init(localIdentifier: String, mediaType: PHAssetMediaType) {
+        self.mediaType = mediaType
+        mediaSubtypes = []
+        pixelWidth = 0
+        pixelHeight = 0
+        creationDate = nil
+        modificationDate = nil
+        duration = 0
+        isFavorite = false
+        isHidden = false
+        sourceType = .typeUserLibrary
+        playbackStyle = mediaType == .video ? .video : .image
+        location = nil
+        burstIdentifier = nil
+        super.init(localIdentifier: localIdentifier)
+    }
+
+    public static func fetchAssets(with mediaType: PHAssetMediaType, options: PHFetchOptions?) -> PHFetchResult<PHAsset> { PHFetchResult() }
+    public static func fetchAssets(with options: PHFetchOptions?) -> PHFetchResult<PHAsset> { PHFetchResult() }
+    public static func fetchAssets(withLocalIdentifiers identifiers: [String], options: PHFetchOptions?) -> PHFetchResult<PHAsset> { PHFetchResult() }
+    public static func fetchAssets(in assetCollection: PHAssetCollection, options: PHFetchOptions?) -> PHFetchResult<PHAsset> { PHFetchResult() }
+    public static func fetchKeyAssets(in assetCollection: PHAssetCollection, options: PHFetchOptions?) -> PHFetchResult<PHAsset>? { nil }
+
+    public func canPerform(_ editOperation: PHAssetEditOperation) -> Bool { false }
+}
+
+public enum PHAssetEditOperation: Int, Sendable {
+    case delete = 1, content = 2, properties = 3
+}
+
+/// An album. The browser's library has none.
+public final class PHAssetCollection: PHObject, @unchecked Sendable {
+    public let localizedTitle: String? = nil
+
+    public static func fetchAssetCollections(with type: PHAssetCollectionType, subtype: PHAssetCollectionSubtype,
+                                             options: PHFetchOptions?) -> PHFetchResult<PHAssetCollection> { PHFetchResult() }
+    public static func fetchAssetCollections(withLocalIdentifiers identifiers: [String],
+                                             options: PHFetchOptions?) -> PHFetchResult<PHAssetCollection> { PHFetchResult() }
+}
+
+public enum PHAssetCollectionType: Int, Sendable {
+    case album = 1, smartAlbum = 2, moment = 3
+}
+
+public enum PHAssetCollectionSubtype: Int, Sendable {
+    case albumRegular = 2, albumSyncedEvent = 3, albumSyncedFaces = 4, albumSyncedAlbum = 5, albumImported = 6
+    case albumMyPhotoStream = 100, albumCloudShared = 101
+    case smartAlbumGeneric = 200, smartAlbumPanoramas = 201, smartAlbumVideos = 202, smartAlbumFavorites = 203
+    case smartAlbumTimelapses = 204, smartAlbumAllHidden = 205, smartAlbumRecentlyAdded = 206, smartAlbumBursts = 207
+    case smartAlbumSlomoVideos = 208, smartAlbumUserLibrary = 209, smartAlbumSelfPortraits = 210, smartAlbumScreenshots = 211
+    case smartAlbumDepthEffect = 212, smartAlbumLivePhotos = 213, smartAlbumAnimated = 214, smartAlbumLongExposures = 215
+    case smartAlbumUnableToUpload = 216, smartAlbumRAW = 217, smartAlbumCinematic = 218, smartAlbumSpatial = 219
+    #if _pointerBitWidth(_64)
+    case any = 9_223_372_036_854_775_807
+    #else
+    case any = 2_147_483_647
+    #endif
+}
+
+/// How a fetch filters and orders. Kept: fetches return nothing.
+public final class PHFetchOptions: @unchecked Sendable {
+    public var predicate: NSPredicate?
+    public var sortDescriptors: [NSSortDescriptor]?
+    public var includeHiddenAssets = false
+    public var includeAllBurstAssets = false
+    public var includeAssetSourceTypes: PHAssetSourceType = []
+    public var fetchLimit = 0
+    public var wantsIncrementalChangeDetails = true
+
+    public init() {}
+}
+
+extension NSSortDescriptor {
+    /// A descriptor by key, as `PHFetchOptions.sortDescriptors` takes them
+    /// (`creationDate`…). Corelibs Foundation has no key-value coding, so its
+    /// own initializer is unavailable; this one, visible where Photos is
+    /// imported, compiles the fetch options. The descriptor does not sort by
+    /// `key` (nothing reads it: fetches return nothing).
+    public convenience init(key: String?, ascending: Bool) {
+        self.init(keyPath: \NSObject.hash, ascending: ascending)
+    }
+}
+
+/// The objects a fetch found: none, in the browser.
+public final class PHFetchResult<ObjectType: AnyObject>: @unchecked Sendable, RandomAccessCollection {
+    private let objects: [ObjectType]
+
+    init(_ objects: [ObjectType] = []) { self.objects = objects }
+
+    public var count: Int { objects.count }
+    public var firstObject: ObjectType? { objects.first }
+    public var lastObject: ObjectType? { objects.last }
+    public func object(at index: Int) -> ObjectType { objects[index] }
+    public func objects(at indexes: IndexSet) -> [ObjectType] { indexes.map { objects[$0] } }
+    public func contains(_ anObject: ObjectType) -> Bool { objects.contains { $0 === anObject } }
+    public func index(of anObject: ObjectType) -> Int { objects.firstIndex { $0 === anObject } ?? NSNotFound }
+    public func countOfAssets(with mediaType: PHAssetMediaType) -> Int { 0 }
+
+    public func enumerateObjects(_ block: (ObjectType, Int, UnsafeMutablePointer<ObjCBool>) -> Void) {
+        var stop = ObjCBool(false)
+        for (index, object) in objects.enumerated() {
+            block(object, index, &stop)
+            if stop.boolValue { return }
+        }
+    }
+
+    public var startIndex: Int { objects.startIndex }
+    public var endIndex: Int { objects.endIndex }
+    public subscript(index: Int) -> ObjectType { objects[index] }
+}
+
+// MARK: - Change requests
+
+/// Creates, edits or deletes an asset inside `performChanges`. Creating
+/// one downloads its photo or video (see the top of the file); edits and
+/// deletions find no asset to change.
+open class PHAssetChangeRequest: @unchecked Sendable {
+    /// What a request creates an asset from.
+    public struct _Source: @unchecked Sendable {
+        enum Kind {
+            case image(UIImage)
+            case file(URL)
+            case resources([(PHAssetResourceType, Data?, URL?, PHAssetResourceCreationOptions?)])
+            case none
+        }
+        var kind: Kind
+    }
+
+    var source: _Source.Kind
+    public private(set) var placeholderForCreatedAsset: PHObjectPlaceholder?
+    open var creationDate: Date?
+    open var isFavorite = false
+    open var isHidden = false
+    open var location: AnyObject?
+    open var contentEditingOutput: AnyObject?
+
+    /// Made by the class methods; joins the change block that is running.
+    public required init(_source: _Source) {
+        source = _source.kind
+        if case .none = source {} else {
+            placeholderForCreatedAsset = PHObjectPlaceholder(localIdentifier: "\(UUID().uuidString)/L0/001")
+        }
+        PHPhotoLibrary.pending?.append(self)
+    }
+
+    /// Edits an asset: the browser's library has none to edit.
+    public convenience init(for asset: PHAsset) { self.init(_source: _Source(kind: .none)) }
+
+    open class func creationRequestForAsset(from image: UIImage) -> Self {
+        Self(_source: _Source(kind: .image(image)))
+    }
+
+    open class func creationRequestForAssetFromImage(atFileURL fileURL: URL) -> Self? {
+        FileManager.default.fileExists(atPath: fileURL.path) ? Self(_source: _Source(kind: .file(fileURL))) : nil
+    }
+
+    open class func creationRequestForAssetFromVideo(atFileURL fileURL: URL) -> Self? {
+        FileManager.default.fileExists(atPath: fileURL.path) ? Self(_source: _Source(kind: .file(fileURL))) : nil
+    }
+
+    open class func deleteAssets(_ assets: any Sequence) {}
+
+    /// The `download` request fields that save what this request created; nil when it created nothing.
+    @MainActor
+    func download() throws -> ([String: _JSON], String)? {
+        switch source {
+        case .none:
+            return nil
+        case .image(let image):
+            return (_PageFiles.fields(for: image, name: "Photo"), "Photo")
+        case .file(let url):
+            return (["files": .array([try _PageFiles.entry(fileURL: url)])], url.deletingPathExtension().lastPathComponent)
+        case .resources(let resources):
+            var files: [_JSON] = []
+            for (type, data, url, options) in resources {
+                if let url {
+                    files.append(try _PageFiles.entry(fileURL: url))
+                } else if let data {
+                    let uti = options?.uniformTypeIdentifier.flatMap { UTType($0) }
+                    let fallback: UTType = type == .video || type == .pairedVideo ? .movie : .image
+                    let sniffed = UIImage(data: data)?._encodedFile.flatMap { UTType(mimeType: $0.mime) }
+                    let contentType = uti ?? sniffed ?? fallback
+                    let name = options?.originalFilename
+                        ?? "Photo.\(contentType.preferredFilenameExtension ?? (fallback == .movie ? "mov" : "jpeg"))"
+                    files.append(_PageFiles.entry(name: name, type: contentType.preferredMIMEType ?? "application/octet-stream", data: data))
+                }
+            }
+            return files.isEmpty ? nil : (["files": .array(files)], "Photo")
+        }
+    }
+}
+
+/// Creates an asset from its resources (photo and video files, or data).
+open class PHAssetCreationRequest: PHAssetChangeRequest, @unchecked Sendable {
+    open class func forAsset() -> Self { Self(_source: _Source(kind: .resources([]))) }
+
+    open class func supportsAssetResourceTypes(_ types: [NSNumber]) -> Bool { true }
+
+    open func addResource(with type: PHAssetResourceType, fileURL: URL, options: PHAssetResourceCreationOptions?) {
+        guard case .resources(let resources) = source else { return }
+        source = .resources(resources + [(type, nil, fileURL, options)])
+    }
+
+    open func addResource(with type: PHAssetResourceType, data: Data, options: PHAssetResourceCreationOptions?) {
+        guard case .resources(let resources) = source else { return }
+        source = .resources(resources + [(type, data, nil, options)])
+    }
+}
+
+public enum PHAssetResourceType: Int, Sendable {
+    case photo = 1, video = 2, audio = 3, alternatePhoto = 4, fullSizePhoto = 5, fullSizeVideo = 6, adjustmentData = 7
+    case adjustmentBasePhoto = 8, pairedVideo = 9, fullSizePairedVideo = 10, adjustmentBasePairedVideo = 11
+    case adjustmentBaseVideo = 12, photoProxy = 19
+}
+
+public final class PHAssetResourceCreationOptions: @unchecked Sendable {
+    public var originalFilename: String?
+    public var uniformTypeIdentifier: String?
+    public var shouldMoveFile = false
+    public init() {}
+}
+
+// MARK: - Image requests
+
+public typealias PHImageRequestID = Int32
+public let PHInvalidImageRequestID: PHImageRequestID = 0
+public let PHImageManagerMaximumSize = CGSize(width: -1, height: -1)
+
+public let PHImageResultIsInCloudKey = "PHImageResultIsInCloudKey"
+public let PHImageResultIsDegradedKey = "PHImageResultIsDegradedKey"
+public let PHImageCancelledKey = "PHImageCancelledKey"
+public let PHImageErrorKey = "PHImageErrorKey"
+public let PHImageResultRequestIDKey = "PHImageResultRequestIDKey"
+
+public enum PHImageContentMode: Int, Sendable {
+    case aspectFit = 0, aspectFill = 1
+    public static let `default` = PHImageContentMode.aspectFit
+}
+
+public enum PHImageRequestOptionsVersion: Int, Sendable { case current = 0, unadjusted = 1, original = 2 }
+public enum PHImageRequestOptionsDeliveryMode: Int, Sendable { case opportunistic = 0, highQualityFormat = 1, fastFormat = 2 }
+public enum PHImageRequestOptionsResizeMode: Int, Sendable { case none = 0, fast = 1, exact = 2 }
+
+/// How an image request should deliver. Kept: requests find nothing.
+public final class PHImageRequestOptions: @unchecked Sendable {
+    public var version = PHImageRequestOptionsVersion.current
+    public var deliveryMode = PHImageRequestOptionsDeliveryMode.opportunistic
+    public var resizeMode = PHImageRequestOptionsResizeMode.fast
+    public var normalizedCropRect = CGRect.zero
+    public var isNetworkAccessAllowed = false
+    public var isSynchronous = false
+    public var allowSecondaryDegradedImage = false
+    public var progressHandler: ((Double, (any Error)?, UnsafeMutablePointer<ObjCBool>, [AnyHashable: Any]?) -> Void)?
+    public init() {}
+}
+
+/// Loads assets' images. The browser's library has no assets, so every
+/// request answers at once with nil and an error under `PHImageErrorKey`.
+open class PHImageManager: @unchecked Sendable {
+    private static let shared = PHImageManager()
+    open class func `default`() -> PHImageManager { shared }
+
+    private var nextID: PHImageRequestID = 1
+
+    public init() {}
+
+    private func failure(_ id: PHImageRequestID) -> [AnyHashable: Any] {
+        [PHImageErrorKey: PHPhotosError(.identifierNotFound), PHImageResultIsDegradedKey: false, PHImageResultRequestIDKey: id]
+    }
+
+    private func newID() -> PHImageRequestID {
+        defer { nextID += 1 }
+        return nextID
+    }
+
+    @discardableResult
+    open func requestImage(for asset: PHAsset, targetSize: CGSize, contentMode: PHImageContentMode, options: PHImageRequestOptions?,
+                           resultHandler: @escaping (UIImage?, [AnyHashable: Any]?) -> Void) -> PHImageRequestID {
+        let id = newID()
+        resultHandler(nil, failure(id))
+        return id
+    }
+
+    @discardableResult
+    open func requestImageDataAndOrientation(for asset: PHAsset, options: PHImageRequestOptions?,
+                                             resultHandler: @escaping (Data?, String?, CGImagePropertyOrientation, [AnyHashable: Any]?) -> Void)
+        -> PHImageRequestID {
+        let id = newID()
+        resultHandler(nil, nil, .up, failure(id))
+        return id
+    }
+
+    @available(*, deprecated, renamed: "requestImageDataAndOrientation(for:options:resultHandler:)")
+    @discardableResult
+    open func requestImageData(for asset: PHAsset, options: PHImageRequestOptions?,
+                               resultHandler: @escaping (Data?, String?, UIImage.Orientation, [AnyHashable: Any]?) -> Void) -> PHImageRequestID {
+        let id = newID()
+        resultHandler(nil, nil, .up, failure(id))
+        return id
+    }
+
+    open func cancelImageRequest(_ requestID: PHImageRequestID) {}
+}
+
+/// An image manager that caches ahead. Nothing to cache in the browser.
+open class PHCachingImageManager: PHImageManager, @unchecked Sendable {
+    open var allowsCachingHighQualityImages = true
+    open func startCachingImages(for assets: [PHAsset], targetSize: CGSize, contentMode: PHImageContentMode, options: PHImageRequestOptions?) {}
+    open func stopCachingImages(for assets: [PHAsset], targetSize: CGSize, contentMode: PHImageContentMode, options: PHImageRequestOptions?) {}
+    open func stopCachingImagesForAllAssets() {}
+}