@swiftbrowser/swift 0.1.0 → 0.2.0

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

@@ -1,77 +1,29 @@
-/// What the SwiftUI shim needs from the real Foundation, for apps built with
-/// `--foundation full`: the SDK's swift-corelibs Foundation (with ICU data
-/// trimmed by the CLI) instead of FoundationEssentials + FoundationLite.
+/// What SwiftUI apps need from Foundation in the browser and the wasm SDK's
+/// swift-corelibs Foundation does not have on WASI:
 ///
-/// The shim itself never imports Foundation (that would link its 10 MB into
-/// every lean app), so it is generic over small protocols that this module
-/// conforms Foundation's types to: `IndexSet` for `onDelete` / `onMove` /
-/// `remove(atOffsets:)`, `Date` for `DatePicker`, and `FormatStyle` /
-/// `ParseableFormatStyle` for `Text(_:format:)` and `TextField(_:value:format:)`.
-/// `Timer.swift` adds the `Timer` and `RunLoop` that 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 Foundation`, together with typealiases that settle the names
-/// both the shim and Foundation declare (`CGFloat`, `CGPoint`, `CGSize`,
-/// `CGRect`, `Timer`, `RunLoop`) in the shim's favor. See
-/// docs/ops-protocol.md, "Phase 11".
+/// 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
-import _FoundationCommon
-
-// MARK: - Offset sets
-
-extension IndexSet: _OffsetSet {
-    public init(_offsets: [Int]) { self.init(_offsets) }
-    /// `IndexSet` iterates its integers in ascending order without duplicates.
-    public var _offsets: [Int] { Array(self) }
-}
-
-// MARK: - Dates
-
-extension Date: _DatePickerValue {
-    public var _secondsSince1970: Double { timeIntervalSince1970 }
-    public init(_secondsSince1970 seconds: Double) {
-        self.init(timeIntervalSince1970: seconds)
-    }
-}
-
-// MARK: - Format styles
-
-/// A Foundation parseable format style as the shim's `_TextFormat`.
-struct _ParseableFormatStyleText<F: ParseableFormatStyle>: _TextFormat where F.FormatOutput == String, F.Strategy.ParseInput == String {
-    let style: F
-    func _formatText(_ value: F.FormatInput) -> String { style.format(value) }
-    func _parseText(_ text: String) -> F.FormatInput? { try? style.parseStrategy.parse(text) }
-}
-
-extension Text {
-    /// `Text(price, format: .currency(code: "USD"))`, `Text(date, format: .dateTime.year())`.
-    public init<F: FormatStyle>(_ input: F.FormatInput, format: F) where F.FormatOutput == String {
-        self.init(verbatim: format.format(input))
-    }
-}
-
-extension TextField where Label == Text {
-    /// `TextField("Amount", value: $amount, format: .number)`: the field shows
-    /// the formatted value and sets it from what the user types when the
-    /// style's parse strategy accepts the text.
-    public init<S: StringProtocol, F: ParseableFormatStyle>(_ title: S, value: Binding<F.FormatInput>, format: F, prompt: Text? = nil)
-    where F.FormatOutput == String, F.Strategy.ParseInput == String {
-        self.init(_placeholder: prompt?._content ?? String(title), value: value, format: _ParseableFormatStyleText(style: format))
-    }
-
-    public init<F: ParseableFormatStyle>(_ titleKey: LocalizedStringKey, value: Binding<F.FormatInput>, format: F, prompt: Text? = nil)
-    where F.FormatOutput == String, F.Strategy.ParseInput == String {
-        self.init(_placeholder: prompt?._content ?? titleKey.key, value: value, format: _ParseableFormatStyleText(style: format))
-    }
-}
-
-// MARK: - Defaults and resources
-
-/// `UserDefaults` that persists through the browser and the `Bundle` that
-/// reads the app's resources (Sources/_FoundationCommon). The CLI's generated
-/// file aliases both in the app, over corelibs Foundation's (whose
-/// `UserDefaults` cannot persist on WASI and whose `Bundle.main` traps).
-public typealias UserDefaults = _FoundationCommon.UserDefaults
-public typealias Bundle = _FoundationCommon.Bundle

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