craft-native 0.0.146 → 0.0.148

package/dist/ios/templates/CraftNativeServices.swift

@@ -0,0 +1,567 @@
+import AVFoundation
+import Foundation
+import UIKit
+import UserNotifications
+
+// Services native screens reach through `craft.speech`, `craft.audio`,
+// `craft.push` and a streaming `fetch` (CraftNativeScreen.swift). Speech and
+// push are the app's, shared by every screen; sounds and streams belong to the
+// screen that started them and end when it closes.
+
+// MARK: - Speech
+
+/// `craft.speech` on a native screen: AVSpeechSynthesizer, set up the way the
+/// page's own speech is (CraftApp.swift). The music ducks rather than stops,
+/// the silent switch does not mute a cue, and the session is handed back once
+/// nothing is left to say.
+final class CraftNativeSpeech: NSObject, AVSpeechSynthesizerDelegate {
+    static let shared = CraftNativeSpeech()
+
+    private let synthesizer = AVSpeechSynthesizer()
+    private var pending: [(utterance: AVSpeechUtterance, done: (Bool) -> Void)] = []
+    private var sessionToRestore: (AVAudioSession.Category, AVAudioSession.Mode, AVAudioSession.CategoryOptions)?
+
+    private override init() {
+        super.init()
+        synthesizer.delegate = self
+    }
+
+    /// Says `text`; `done` hears true once it was spoken, false when it was
+    /// stopped or interrupted. Main thread.
+    func speak(_ text: String, language: String?, rate: Double?, interrupt: Bool, done: @escaping (Bool) -> Void) {
+        if interrupt { cancelPending() }
+        let utterance = AVSpeechUtterance(string: text)
+        utterance.rate = Self.utteranceRate(rate ?? 1)
+        // An unknown language finds no voice, and a nil voice is the device's own.
+        if let language, !language.isEmpty, let voice = AVSpeechSynthesisVoice(language: language) {
+            utterance.voice = voice
+        }
+        pending.append((utterance, done))
+        claimSession()
+        synthesizer.speak(utterance)
+    }
+
+    func stop() {
+        // When something was sounding, its didCancel hands the session back
+        // once the audio has stopped; deactivating before that fails as busy.
+        if !cancelPending() { releaseSessionIfSilent() }
+    }
+
+    /// Settles every waiting call false. Returns whether anything was sounding.
+    @discardableResult
+    private func cancelPending() -> Bool {
+        let waiting = pending
+        pending.removeAll()
+        let sounding = synthesizer.isSpeaking || synthesizer.isPaused
+        if sounding { synthesizer.stopSpeaking(at: .immediate) }
+        waiting.forEach { $0.done(false) }
+        return sounding
+    }
+
+    /// The page's rate, where 1 is normal, on AVSpeechUtterance's scale: the
+    /// same mapping as the page's speech, so a cue sounds alike in both.
+    static func utteranceRate(_ rate: Double) -> Float {
+        let requested = Float(min(max(rate.isFinite ? rate : 1, 0.5), 2))
+        let normal = AVSpeechUtteranceDefaultSpeechRate
+        let mapped = requested <= 1
+            ? normal * requested
+            : normal + (AVSpeechUtteranceMaximumSpeechRate - normal) * (requested - 1) / 2
+        return min(max(mapped, AVSpeechUtteranceMinimumSpeechRate), AVSpeechUtteranceMaximumSpeechRate)
+    }
+
+    private func claimSession() {
+        guard sessionToRestore == nil else { return }
+        let session = AVAudioSession.sharedInstance()
+        let previous = (session.category, session.mode, session.categoryOptions)
+        do {
+            try session.setCategory(.playback, mode: .voicePrompt, options: [.duckOthers, .interruptSpokenAudioAndMixWithOthers])
+            try session.setActive(true)
+            sessionToRestore = previous
+        } catch {
+            // Still speak, through whatever session the app has.
+            NSLog("[craft native] speech audio session failed: %@", error.localizedDescription)
+        }
+    }
+
+    private func releaseSessionIfSilent(retry: Bool = true) {
+        guard pending.isEmpty, let previous = sessionToRestore else { return }
+        let session = AVAudioSession.sharedInstance()
+        do {
+            try session.setActive(false, options: .notifyOthersOnDeactivation)
+        } catch {
+            // Busy: the last of the audio has not drained, or the app plays
+            // something of its own. Once more shortly covers the first.
+            if retry {
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { self.releaseSessionIfSilent(retry: false) }
+                return
+            }
+        }
+        sessionToRestore = nil
+        try? session.setCategory(previous.0, mode: previous.1, options: previous.2)
+        CraftNativeSounds.reclaimSessionIfPlaying()
+    }
+
+    private func finished(_ utterance: AVSpeechUtterance, spoken: Bool) {
+        if let index = pending.firstIndex(where: { $0.utterance === utterance }) {
+            pending.remove(at: index).done(spoken)
+        }
+        releaseSessionIfSilent()
+    }
+
+    func speechSynthesizer(_ synthesizer: AVSpeechSynthesizer, didFinish utterance: AVSpeechUtterance) {
+        DispatchQueue.main.async { self.finished(utterance, spoken: true) }
+    }
+
+    func speechSynthesizer(_ synthesizer: AVSpeechSynthesizer, didCancel utterance: AVSpeechUtterance) {
+        DispatchQueue.main.async { self.finished(utterance, spoken: false) }
+    }
+}
+
+// MARK: - Background sound
+
+/// `craft.audio` on a native screen: sounds that play under the screen, such
+/// as rain under a breathing exercise. Each loops without a gap when asked
+/// (AVPlayerLooper), fades in and out, and stops when its screen closes.
+///
+/// The session is `.ambient`: it mixes with the person's music and the silent
+/// switch mutes it, as a game's background sound is muted. A sound that must
+/// be heard through the switch asks with `respectSilentSwitch: false`.
+final class CraftNativeSounds {
+    private final class Sound {
+        let player: AVQueuePlayer
+        var looper: AVPlayerLooper?
+        var observation: NSKeyValueObservation?
+        var endObserver: NSObjectProtocol?
+        var fade: Timer?
+        /// The volume asked for; a fade in or out moves toward or away from it.
+        var volume: Float
+        var paused = false
+
+        init(player: AVQueuePlayer, volume: Float) {
+            self.player = player
+            self.volume = volume
+        }
+
+        func end() {
+            fade?.invalidate()
+            fade = nil
+            observation?.invalidate()
+            observation = nil
+            if let endObserver { NotificationCenter.default.removeObserver(endObserver) }
+            endObserver = nil
+            looper?.disableLooping()
+            looper = nil
+            player.pause()
+            player.removeAllItems()
+        }
+    }
+
+    /// Every screen's sounds, so the session is handed back when the last one
+    /// anywhere stops, and taken again after speech handed it back.
+    private static var playing = 0
+    private static var sessionToRestore: (AVAudioSession.Category, AVAudioSession.Mode, AVAudioSession.CategoryOptions)?
+    private static var category: AVAudioSession.Category = .ambient
+
+    private var sounds: [String: Sound] = [:]
+    /// `{ id, event: "ended" | "error", message? }` to the screen's script.
+    var emit: (([String: Any]) -> Void)?
+
+    /// Starts `url`. `answer` hears once it plays (or could not be loaded).
+    func play(id: String, url: URL, options: [String: Any], answer: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
+        stop(id: id, fadeOut: 0)
+        let loop = options["loop"] as? Bool ?? false
+        let volume = Float(min(max((options["volume"] as? NSNumber)?.doubleValue ?? 1, 0), 1))
+        let fadeIn = max(0, (options["fadeIn"] as? NSNumber)?.doubleValue ?? 0) / 1000
+        Self.claimSession(respectSilentSwitch: options["respectSilentSwitch"] as? Bool ?? true)
+        let item = AVPlayerItem(url: url)
+        let player = AVQueuePlayer()
+        let sound = Sound(player: player, volume: volume)
+        sounds[id] = sound
+        var answered = false
+        let settle: (Result<Any, CraftNativeActionError>) -> Void = { result in
+            guard !answered else { return }
+            answered = true
+            answer(result)
+        }
+        let failed: (String) -> Void = { [weak self, weak sound] message in
+            guard let self, let sound, self.sounds[id] === sound else { return }
+            self.remove(id)
+            settle(.failure(CraftNativeActionError(code: "AUDIO_ERROR", message: message)))
+            self.emit?(["id": id, "event": "error", "message": message])
+        }
+        if loop {
+            let looper = AVPlayerLooper(player: player, templateItem: item)
+            sound.looper = looper
+            sound.observation = looper.observe(\.status, options: [.initial, .new]) { looper, _ in
+                DispatchQueue.main.async {
+                    if looper.status == .ready { settle(.success(true)) }
+                    else if looper.status == .failed { failed(looper.error?.localizedDescription ?? "The sound could not be played") }
+                }
+            }
+        } else {
+            player.insert(item, after: nil)
+            sound.observation = item.observe(\.status, options: [.initial, .new]) { item, _ in
+                DispatchQueue.main.async {
+                    if item.status == .readyToPlay { settle(.success(true)) }
+                    else if item.status == .failed { failed(item.error?.localizedDescription ?? "The sound could not be played") }
+                }
+            }
+            sound.endObserver = NotificationCenter.default.addObserver(forName: .AVPlayerItemDidPlayToEndTime, object: item, queue: .main) { [weak self, weak sound] _ in
+                guard let self, let sound, self.sounds[id] === sound else { return }
+                self.remove(id)
+                self.emit?(["id": id, "event": "ended"])
+            }
+        }
+        player.volume = fadeIn > 0 ? 0 : volume
+        player.play()
+        if fadeIn > 0 { ramp(sound, to: volume, over: fadeIn) }
+    }
+
+    func pause(id: String) {
+        guard let sound = sounds[id] else { return }
+        sound.paused = true
+        sound.fade?.invalidate()
+        sound.player.pause()
+    }
+
+    func resume(id: String) {
+        guard let sound = sounds[id], sound.paused else { return }
+        sound.paused = false
+        sound.player.volume = sound.volume
+        sound.player.play()
+    }
+
+    /// Changes the volume, over `fade` seconds when given.
+    func setVolume(id: String, volume: Double, fade: Double) {
+        guard let sound = sounds[id] else { return }
+        sound.volume = Float(min(max(volume, 0), 1))
+        if fade > 0, !sound.paused { ramp(sound, to: sound.volume, over: fade) }
+        else { sound.fade?.invalidate(); sound.player.volume = sound.volume }
+    }
+
+    /// Stops the sound, fading it out over `fadeOut` seconds first.
+    func stop(id: String, fadeOut: Double) {
+        guard let sound = sounds[id] else { return }
+        guard fadeOut > 0, !sound.paused else { remove(id); return }
+        ramp(sound, to: 0, over: fadeOut) { [weak self, weak sound] in
+            guard let self, let sound, self.sounds[id] === sound else { return }
+            self.remove(id)
+        }
+    }
+
+    func stopAll(fadeOut: Double) {
+        for id in Array(sounds.keys) { stop(id: id, fadeOut: fadeOut) }
+    }
+
+    /// The screen closed: everything stops at once.
+    func close() {
+        for id in Array(sounds.keys) { remove(id) }
+    }
+
+    private func remove(_ id: String) {
+        guard let sound = sounds.removeValue(forKey: id) else { return }
+        sound.end()
+        Self.released()
+    }
+
+    /// Moves the volume in steps on the main run loop, a 30th of a second
+    /// apart: AVPlayer has no fade of its own for a playing item.
+    private func ramp(_ sound: Sound, to target: Float, over seconds: Double, then done: (() -> Void)? = nil) {
+        sound.fade?.invalidate()
+        let start = sound.player.volume
+        let began = CACurrentMediaTime()
+        let timer = Timer(timeInterval: 1.0 / 30, repeats: true) { [weak sound] timer in
+            guard let sound else { timer.invalidate(); return }
+            let progress = Float(min(1, (CACurrentMediaTime() - began) / seconds))
+            sound.player.volume = start + (target - start) * progress
+            if progress >= 1 {
+                timer.invalidate()
+                sound.fade = nil
+                done?()
+            }
+        }
+        sound.fade = timer
+        RunLoop.main.add(timer, forMode: .common)
+    }
+
+    private static func claimSession(respectSilentSwitch: Bool) {
+        playing += 1
+        category = respectSilentSwitch ? .ambient : .playback
+        let session = AVAudioSession.sharedInstance()
+        if sessionToRestore == nil { sessionToRestore = (session.category, session.mode, session.categoryOptions) }
+        do {
+            try session.setCategory(category, mode: .default, options: [.mixWithOthers])
+            try session.setActive(true)
+        } catch {
+            NSLog("[craft native] sound audio session failed: %@", error.localizedDescription)
+        }
+    }
+
+    private static func released() {
+        playing = max(0, playing - 1)
+        guard playing == 0, let previous = sessionToRestore else { return }
+        sessionToRestore = nil
+        try? AVAudioSession.sharedInstance().setCategory(previous.0, mode: previous.1, options: previous.2)
+    }
+
+    /// Speech handed the session back with the category it found, which may
+    /// predate a sound started while it spoke: take it again for the sound.
+    static func reclaimSessionIfPlaying() {
+        guard playing > 0 else { return }
+        try? AVAudioSession.sharedInstance().setCategory(category, mode: .default, options: [.mixWithOthers])
+    }
+}
+
+// MARK: - Streaming responses
+
+/// A `fetch` whose response is read as it arrives, such as a server-sent
+/// event stream (`Accept: text/event-stream`). The head answers the screen's
+/// request; every piece of the body after it goes to the script as text, and
+/// the end or the failure last. Streams belong to their screen and close with
+/// it.
+final class CraftNativeEventStreams: NSObject, URLSessionDataDelegate {
+    private lazy var session: URLSession = {
+        let configuration = URLSessionConfiguration.default
+        // A quiet stream is still open: the idle limit is generous, and the
+        // whole response has none worth the name.
+        configuration.timeoutIntervalForRequest = 300
+        configuration.timeoutIntervalForResource = 7 * 24 * 60 * 60
+        configuration.requestCachePolicy = .reloadIgnoringLocalCacheData
+        return URLSession(configuration: configuration, delegate: self, delegateQueue: .main)
+    }()
+    private var started = false
+    private var tasks: [String: URLSessionDataTask] = [:]
+    private var streamIds: [Int: String] = [:]
+    private var heads: [String: (Result<Any, CraftNativeActionError>) -> Void] = [:]
+    /// The bytes of a character split across two pieces, until the rest comes.
+    private var carry: [String: Data] = [:]
+    /// `{ id, chunk }`, then `{ id, done: true }` or `{ id, error }`.
+    var emit: (([String: Any]) -> Void)?
+
+    func open(id: String, options: [String: Any], answer: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
+        guard !id.isEmpty, tasks[id] == nil,
+              let address = options["url"] as? String, let url = URL(string: address),
+              let scheme = url.scheme?.lowercased(), scheme == "https" || scheme == "http", url.host?.isEmpty == false else {
+            answer(.failure(CraftNativeActionError(code: "INVALID_ARGUMENT", message: "A streaming fetch needs an id and an absolute http or https URL")))
+            return
+        }
+        var request = URLRequest(url: url)
+        request.httpMethod = ((options["method"] as? String) ?? "GET").uppercased()
+        for (name, value) in options["headers"] as? [String: Any] ?? [:] {
+            if let value = value as? String { request.setValue(value, forHTTPHeaderField: name) }
+        }
+        if let body = options["body"] as? String { request.httpBody = Data(body.utf8) }
+        started = true
+        let task = session.dataTask(with: request)
+        tasks[id] = task
+        streamIds[task.taskIdentifier] = id
+        heads[id] = answer
+        task.resume()
+    }
+
+    /// The script stopped reading: the transfer ends, and nothing more is sent.
+    func cancel(id: String) {
+        guard let task = tasks.removeValue(forKey: id) else { return }
+        streamIds.removeValue(forKey: task.taskIdentifier)
+        heads.removeValue(forKey: id)?(.failure(CraftNativeActionError(code: "CANCELLED", message: "The request was aborted")))
+        carry.removeValue(forKey: id)
+        task.cancel()
+    }
+
+    /// The screen closed. The session holds its delegate until invalidated.
+    func close() {
+        tasks.removeAll()
+        streamIds.removeAll()
+        heads.removeAll()
+        carry.removeAll()
+        if started { session.invalidateAndCancel() }
+    }
+
+    func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive response: URLResponse, completionHandler: @escaping (URLSession.ResponseDisposition) -> Void) {
+        guard let id = streamIds[dataTask.taskIdentifier], let answer = heads.removeValue(forKey: id) else {
+            completionHandler(.cancel)
+            return
+        }
+        guard let http = response as? HTTPURLResponse else {
+            completionHandler(.cancel)
+            answer(.failure(CraftNativeActionError(code: "NETWORK_ERROR", message: "fetch received a response that is not HTTP")))
+            return
+        }
+        var headers: [String: String] = [:]
+        for (name, value) in http.allHeaderFields { headers[String(describing: name).lowercased()] = String(describing: value) }
+        completionHandler(.allow)
+        answer(.success([
+            "url": http.url?.absoluteString ?? "",
+            "status": http.statusCode,
+            "statusText": HTTPURLResponse.localizedString(forStatusCode: http.statusCode),
+            "headers": headers,
+            "redirected": http.url != dataTask.originalRequest?.url,
+        ]))
+    }
+
+    func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
+        guard let id = streamIds[dataTask.taskIdentifier] else { return }
+        let (text, rest) = Self.decodeUTF8((carry[id] ?? Data()) + data)
+        carry[id] = rest.isEmpty ? nil : rest
+        if !text.isEmpty { emit?(["id": id, "chunk": text]) }
+    }
+
+    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+        guard let id = streamIds.removeValue(forKey: task.taskIdentifier) else { return }
+        tasks.removeValue(forKey: id)
+        carry.removeValue(forKey: id)
+        if let answer = heads.removeValue(forKey: id) {
+            let code = (error as? URLError)?.code == .timedOut ? "TIMEOUT" : "NETWORK_ERROR"
+            answer(.failure(CraftNativeActionError(code: code, message: error?.localizedDescription ?? "Network request failed")))
+            return
+        }
+        if let error { emit?(["id": id, "error": error.localizedDescription]) }
+        else { emit?(["id": id, "done": true]) }
+    }
+
+    /// The text in `data`, and the bytes at its end that only begin a
+    /// character (kept for the next piece). Invalid bytes read as U+FFFD.
+    static func decodeUTF8(_ data: Data) -> (String, Data) {
+        let bytes = [UInt8](data)
+        var cut = bytes.count
+        // Up to three bytes back for the lead byte of an unfinished character.
+        var back = 1
+        while back <= min(3, bytes.count) {
+            let byte = bytes[bytes.count - back]
+            if byte & 0xC0 == 0x80 { back += 1; continue }
+            let length = byte >= 0xF0 ? 4 : byte >= 0xE0 ? 3 : byte >= 0xC0 ? 2 : 1
+            if length > back { cut = bytes.count - back }
+            break
+        }
+        return (String(decoding: bytes[0..<cut], as: UTF8.self), Data(bytes[cut...]))
+    }
+}
+
+// MARK: - Push
+
+/// `craft.push` on a native screen: the same permission and device token the
+/// page's `craft.registerPush` gets. The token arrives at the app delegate,
+/// which posts `craftPushToken`; every screen hears it.
+enum CraftNativePush {
+    private static var waiting: [(Result<Any, CraftNativeActionError>) -> Void] = []
+    private static var observers: [NSObjectProtocol] = []
+    private static var deadline: DispatchWorkItem?
+    /// APNs answers in a second or two; it is given this long.
+    private static let registrationSeconds: Double = 20
+
+    /// `granted`, `denied` or `undetermined`, without asking.
+    static func status(_ done: @escaping (String) -> Void) {
+        UNUserNotificationCenter.current().getNotificationSettings { settings in
+            let status: String
+            switch settings.authorizationStatus {
+            case .authorized, .provisional, .ephemeral: status = "granted"
+            case .denied: status = "denied"
+            default: status = "undetermined"
+            }
+            DispatchQueue.main.async { done(status) }
+        }
+    }
+
+    /// Asks once, if iOS has not been answered yet; the answer either way.
+    static func requestPermission(_ done: @escaping (String) -> Void) {
+        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .badge, .sound]) { _, _ in
+            status(done)
+        }
+    }
+
+    /// The device token, asking for permission first if it was never asked.
+    static func register(_ done: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
+        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .badge, .sound]) { granted, error in
+            DispatchQueue.main.async {
+                guard granted else {
+                    done(.failure(CraftNativeActionError(code: "PERMISSION_DENIED", message: error?.localizedDescription ?? "Notification permission denied")))
+                    return
+                }
+                waiting.append(done)
+                guard waiting.count == 1 else { return }
+                observe()
+                let timeout = DispatchWorkItem {
+                    settle(.failure(CraftNativeActionError(code: "TIMEOUT", message: "APNs did not answer within \(Int(registrationSeconds))s")))
+                }
+                deadline = timeout
+                DispatchQueue.main.asyncAfter(deadline: .now() + registrationSeconds, execute: timeout)
+                UIApplication.shared.registerForRemoteNotifications()
+            }
+        }
+    }
+
+    private static func observe() {
+        guard observers.isEmpty else { return }
+        observers.append(NotificationCenter.default.addObserver(forName: .craftPushToken, object: nil, queue: .main) { note in
+            guard let token = note.object as? String else { return }
+            settle(.success(token))
+        })
+        observers.append(NotificationCenter.default.addObserver(forName: .craftPushRegistrationError, object: nil, queue: .main) { note in
+            settle(.failure(CraftNativeActionError(code: "PUSH_REGISTRATION_ERROR", message: note.object as? String ?? "Push registration failed")))
+        })
+    }
+
+    private static func settle(_ result: Result<Any, CraftNativeActionError>) {
+        deadline?.cancel()
+        deadline = nil
+        observers.forEach(NotificationCenter.default.removeObserver)
+        observers.removeAll()
+        let callers = waiting
+        waiting.removeAll()
+        callers.forEach { $0(result) }
+    }
+}
+
+// MARK: - Share sheet
+
+/// `craft.share` on a native screen: the system share sheet with the page's
+/// options (`title`, `text`, `url`, `files`), plus `image`, a picture by URL
+/// that is shared as the picture rather than as its address. Answers true
+/// once something was shared, false when the sheet was dismissed.
+enum CraftNativeShare {
+    static func share(_ options: [String: Any], done: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
+        var items: [Any] = []
+        if let title = options["title"] as? String, !title.isEmpty { items.append(title) }
+        if let text = options["text"] as? String, !text.isEmpty { items.append(text) }
+        if let address = options["url"] as? String, let url = URL(string: address) { items.append(url) }
+        for file in options["files"] as? [String] ?? [] {
+            if let url = URL(string: file), url.isFileURL { items.append(url) }
+            else if FileManager.default.fileExists(atPath: file) { items.append(URL(fileURLWithPath: file)) }
+        }
+        let present: ([Any]) -> Void = { items in
+            guard !items.isEmpty else {
+                done(.failure(CraftNativeActionError(code: "INVALID_ARGUMENT", message: "Nothing to share")))
+                return
+            }
+            let sheet = UIActivityViewController(activityItems: items, applicationActivities: nil)
+            sheet.completionWithItemsHandler = { _, completed, _, error in
+                if let error { done(.failure(CraftNativeActionError(code: "SHARE_ERROR", message: error.localizedDescription))) }
+                else { done(.success(completed)) }
+            }
+            if !CraftPresenter.present(sheet, from: nil, anchor: nil) {
+                done(.failure(CraftNativeActionError(code: "SHARE_ERROR", message: "Unable to present the share sheet")))
+            }
+        }
+        guard let address = options["image"] as? String, let url = URL(string: address) else {
+            DispatchQueue.main.async { present(items) }
+            return
+        }
+        // The picture itself, so Messages and Photos get an image.
+        let load: (Data?) -> Void = { data in
+            DispatchQueue.main.async {
+                guard let data, let image = UIImage(data: data) else {
+                    done(.failure(CraftNativeActionError(code: "INVALID_ARGUMENT", message: "The image to share could not be loaded")))
+                    return
+                }
+                present([image] + items)
+            }
+        }
+        if address.hasPrefix("data:image/"), let comma = address.firstIndex(of: ",") {
+            load(Data(base64Encoded: String(address[address.index(after: comma)...])))
+        } else if url.isFileURL {
+            load(try? Data(contentsOf: url))
+        } else {
+            URLSession.shared.dataTask(with: url) { data, _, _ in load(data) }.resume()
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "craft-native",
-  "version": "0.0.146",
+  "version": "0.0.148",
   "type": "module",
   "description": "Build desktop apps with web languages - TypeScript SDK for Craft",
   "author": "Chris Breuer <chris@stacksjs.org>",