@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/FoundationBridge/FileImporter.swift

@@ -0,0 +1,128 @@
+// `.fileImporter`: the page's file chooser in place of the Files app. It is
+// the photo picker's `pickFiles` host request (docs/ops-protocol.md, "Photos
+// picker"), with an `accept` made from the allowed content types. The
+// chosen files are written to a folder of their own in the app's temporary
+// directory, and `onCompletion` gets their file URLs, which the app reads
+// like any file (no security scope to start: `startAccessingSecurityScopedResource`
+// answers true). A dismissed chooser calls `onCancellation`, if given, and
+// not `onCompletion`, as on iOS. Opening a chooser needs a tap, so set
+// `isPresented` from a button's action.
+
+import Foundation
+import SwiftUI
+import UniformTypeIdentifiers
+
+/// One file import: what to offer and what to do with the files.
+struct _FileImport {
+    let types: [UTType]
+    let multiple: Bool
+    let completion: @MainActor (Result<[URL], any Error>) -> Void
+    let cancellation: (@MainActor () -> Void)?
+
+    /// The chooser's `accept`: a MIME pattern or an extension per type;
+    /// empty (any file) when a type covers all data.
+    var accept: String {
+        var parts: [String] = []
+        for type in types {
+            if [UTType.item, .data, .content].contains(type) { return "" }
+            if type == .image { parts.append("image/*") }
+            else if type == .movie || type == .video || type == .audiovisualContent { parts.append("video/*") }
+            else if type == .audio { parts.append("audio/*") }
+            else if type == .text || type == .plainText { parts.append("text/*") }
+            else if let mime = type.preferredMIMEType { parts.append(mime) }
+            else if let ext = type.preferredFilenameExtension { parts.append(".\(ext)") }
+        }
+        return parts.joined(separator: ",")
+    }
+
+    @MainActor func run() async {
+        let params: _JSON = .object(["accept": .string(accept), "multiple": .bool(multiple)])
+        let value: _JSON
+        do {
+            value = try await _Runtime.shared._hostRequest(kind: "pickFiles", params: params)
+        } catch {
+            completion(.failure(error))
+            return
+        }
+        guard case .object(let fields) = value, case .array(let entries)? = fields["items"], !entries.isEmpty else {
+            cancellation?()
+            return
+        }
+        do {
+            completion(.success(try entries.map(Self.write)))
+        } catch {
+            completion(.failure(error))
+        }
+    }
+
+    /// Writes one chosen file (`{name, data}`) to a new folder in the temporary directory.
+    static func write(_ entry: _JSON) throws -> URL {
+        guard case .object(let fields) = entry, case .string(let base64)? = fields["data"],
+              let data = Data(base64Encoded: base64) else {
+            throw CocoaError(.fileReadCorruptFile)
+        }
+        var name = "file"
+        if case .string(let given)? = fields["name"], !given.isEmpty, !given.contains("/") { name = given }
+        let folder = FileManager.default.temporaryDirectory.appendingPathComponent("Imports/\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
+        let url = folder.appendingPathComponent(name)
+        try data.write(to: url)
+        return url
+    }
+}
+
+/// Opens the chooser when `isPresented` becomes true and sets it back to false once the viewer is done.
+struct _FileImporterPresenter<Content: View>: View {
+    let content: Content
+    let isPresented: Binding<Bool>
+    let fileImport: _FileImport
+
+    var body: some View {
+        let isPresented = isPresented
+        nonisolated(unsafe) let fileImport = fileImport
+        return content.onChange(of: isPresented.wrappedValue, initial: true) { _, presented in
+            guard presented else { return }
+            MainActor.assumeIsolated {
+                Task { @MainActor in
+                    await fileImport.run()
+                    isPresented.wrappedValue = false
+                }
+            }
+        }
+    }
+}
+
+extension View {
+    /// Lets the viewer pick one file of `allowedContentTypes`.
+    public func fileImporter(isPresented: Binding<Bool>, allowedContentTypes: [UTType],
+                             onCompletion: @escaping (Result<URL, any Error>) -> Void) -> some View {
+        _FileImporterPresenter(content: self, isPresented: isPresented,
+                               fileImport: _FileImport(types: allowedContentTypes, multiple: false,
+                                                       completion: { onCompletion($0.flatMap { urls in .success(urls[0]) }) },
+                                                       cancellation: nil))
+    }
+
+    /// Lets the viewer pick files of `allowedContentTypes`, several when `allowsMultipleSelection`.
+    public func fileImporter(isPresented: Binding<Bool>, allowedContentTypes: [UTType], allowsMultipleSelection: Bool,
+                             onCompletion: @escaping (Result<[URL], any Error>) -> Void) -> some View {
+        _FileImporterPresenter(content: self, isPresented: isPresented,
+                               fileImport: _FileImport(types: allowedContentTypes, multiple: allowsMultipleSelection,
+                                                       completion: { onCompletion($0) }, cancellation: nil))
+    }
+
+    /// As above, with `onCancellation` called when the viewer dismisses the chooser.
+    public func fileImporter(isPresented: Binding<Bool>, allowedContentTypes: [UTType], allowsMultipleSelection: Bool,
+                             onCompletion: @escaping (Result<[URL], any Error>) -> Void,
+                             onCancellation: @escaping () -> Void) -> some View {
+        _FileImporterPresenter(content: self, isPresented: isPresented,
+                               fileImport: _FileImport(types: allowedContentTypes, multiple: allowsMultipleSelection,
+                                                       completion: { onCompletion($0) }, cancellation: { onCancellation() }))
+    }
+}
+
+extension URL {
+    /// True: picked files are plain files of the app's.
+    public func startAccessingSecurityScopedResource() -> Bool { true }
+    /// Nothing to stop.
+    public func stopAccessingSecurityScopedResource() {}
+}

package/Sources/FoundationBridge/FileSystem.swift

@@ -0,0 +1,68 @@
+// The app's own files: an iOS-like home directory the browser keeps across
+// launches (docs/ops-protocol.md, "Phase 19").
+//
+// The host mounts a writable directory at `/data` and sets `HOME=/data`,
+// `XDG_DATA_HOME=/data/Library/Application Support` and
+// `XDG_CACHE_HOME=/data/Library/Caches`, so Foundation's
+// `FileManager.urls(for:in:)` answers with the iOS layout (`Documents`,
+// `Library/Application Support`, `Library/Caches`); `/tmp` is a second,
+// in-memory mount. The page keeps `/data` in IndexedDB; headless runs map it
+// to a directory on disk.
+//
+// swift-foundation declares `URL.documentsDirectory` and its siblings only in
+// Apple's Foundation, and marks `Data.WritingOptions.atomic` unavailable on
+// WASI (corelibs Foundation always writes in place there). Both are common in
+// apps, so they are supplied here.
+
+import Foundation
+
+extension URL {
+    /// An environment variable naming an absolute path, if set.
+    private static func _environmentPath(_ name: String) -> URL? {
+        guard let value = ProcessInfo.processInfo.environment[name], value.hasPrefix("/") else { return nil }
+        return URL(filePath: value, directoryHint: .isDirectory)
+    }
+
+    /// The app's home directory (`HOME`; `/data` in the browser). Foundation
+    /// has `URL.homeDirectory` already.
+    private static var _home: URL { _environmentPath("HOME") ?? URL(filePath: "/data", directoryHint: .isDirectory) }
+
+    /// `Documents` in the app's home: kept across launches. (On WASI this is
+    /// also what `FileManager.urls(for: .documentDirectory, in:)` answers.)
+    public static var documentsDirectory: URL { _home.appending(path: "Documents", directoryHint: .isDirectory) }
+
+    /// `Library` in the app's home.
+    public static var libraryDirectory: URL { _home.appending(path: "Library", directoryHint: .isDirectory) }
+
+    /// `Library/Application Support` in the app's home (`XDG_DATA_HOME`).
+    public static var applicationSupportDirectory: URL {
+        _environmentPath("XDG_DATA_HOME") ?? libraryDirectory.appending(path: "Application Support", directoryHint: .isDirectory)
+    }
+
+    /// `Library/Caches` in the app's home (`XDG_CACHE_HOME`).
+    public static var cachesDirectory: URL {
+        _environmentPath("XDG_CACHE_HOME") ?? libraryDirectory.appending(path: "Caches", directoryHint: .isDirectory)
+    }
+}
+
+#if os(WASI)
+extension Data.WritingOptions {
+    /// Accepted, as on Apple platforms; corelibs Foundation on WASI writes
+    /// every file in place (it has no temporary files to swap in), and marks
+    /// its own `atomic` unavailable, which makes this one the one an app gets.
+    public static var atomic: Data.WritingOptions { Data.WritingOptions(rawValue: 1 << 0) }
+}
+#endif
+
+extension FileManager {
+    /// An app group's shared container. The browser runs the app alone, so the
+    /// group's container is a folder in the app's home (`Shared/<group>`, kept
+    /// across launches like the rest of `/data`), made on first use.
+    public func containerURL(forSecurityApplicationGroupIdentifier groupIdentifier: String) -> URL? {
+        let url = URL.libraryDirectory.deletingLastPathComponent()
+            .appending(path: "Shared", directoryHint: .isDirectory)
+            .appending(path: groupIdentifier, directoryHint: .isDirectory)
+        try? createDirectory(at: url, withIntermediateDirectories: true)
+        return url
+    }
+}

package/Sources/FoundationBridge/FoundationBridge.swift

@@ -0,0 +1,29 @@
+/// What SwiftUI apps need from Foundation in the browser and the wasm SDK's
+/// swift-corelibs Foundation does not have on WASI:
+///
+/// - `Timer` and `RunLoop` (Timer.swift): corelibs' `Timer` needs CFRunLoop,
+///   which the WASI build lacks, and `RunLoop` is marked unavailable.
+/// - `UserDefaults` (UserDefaults.swift), persisted by the browser; corelibs'
+///   cannot persist on WASI. `@AppStorage` (AppStorage.swift) lives here with
+///   it, since the SwiftUI shim cannot see this module.
+/// - `Bundle` (Bundle.swift), reading the app's staged resources at `/bundle`;
+///   corelibs' `Bundle.main` traps.
+/// - `URLSession`, `URLRequest`, `URLResponse`, `HTTPURLResponse`, `URLError`
+///   (URLSession.swift) over the page's `fetch`; corelibs marks them
+///   unavailable (they moved to FoundationNetworking).
+/// - `AsyncImage` (AsyncImage.swift), loaded by the page.
+/// - `URL.documentsDirectory` and the other iOS directories, and
+///   `Data.WritingOptions.atomic` on WASI (FileSystem.swift), over the home
+///   directory the page keeps in IndexedDB.
+/// - `Locale.current` following the viewer (Locale.swift), through a link-time
+///   `--wrap` the CLI adds.
+/// - `UITextChecker` (UITextChecker.swift), a stand-in for a UIKit class
+///   tutorials reach for.
+///
+/// Apps do not import this module themselves: the CLI's staging adds it next
+/// to `import SwiftUI` and generates typealiases that settle the names both
+/// this module and Foundation declare (`Timer`, `RunLoop`, `UserDefaults`,
+/// `Bundle`, `URLSession` and friends) in this module's favor. See
+/// docs/ops-protocol.md, "Phase 11", "Phase 13" and "Phase 14".
+import Foundation
+import SwiftUI

package/Sources/FoundationBridge/HostResolution.swift

@@ -0,0 +1,31 @@
+// Host name resolution, as BSD sockets declare it: WASI's libc has the
+// address types (`in_addr`, `inet_ntoa`) but no resolver, and the page
+// cannot resolve names. `gethostbyname` answers nil, as it does for a name
+// that does not resolve, so code that checks a host's address goes on
+// without one.
+
+#if os(WASI)
+import WASILibc
+
+/// A host's entry: its name, aliases, address type and addresses.
+public struct hostent {
+    public var h_name: UnsafeMutablePointer<CChar>!
+    public var h_aliases: UnsafeMutablePointer<UnsafeMutablePointer<CChar>?>!
+    public var h_addrtype: Int32
+    public var h_length: Int32
+    /// Non-optional elements: WASI's `memcpy` takes no optional pointer, and
+    /// code copies `h_addr_list[0]` into an `in_addr` with it.
+    public var h_addr_list: UnsafeMutablePointer<UnsafeMutablePointer<CChar>>!
+
+    public init() {
+        h_name = nil
+        h_aliases = nil
+        h_addrtype = 0
+        h_length = 0
+        h_addr_list = nil
+    }
+}
+
+/// The host entry for `name`: nil, as there is no resolver.
+public func gethostbyname(_ name: UnsafePointer<CChar>!) -> UnsafeMutablePointer<hostent>! { nil }
+#endif