@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/FoundationBridge/CoreFoundation.swift

@@ -0,0 +1,77 @@
+// The Core Foundation clock, which Darwin's Foundation brings along and the
+// WASI SDK's does not (nor does Linux's, publicly). The CLI's staging aliases
+// the names, so code that imports only Foundation finds them.
+
+import Foundation
+// `CFString`, `CFURL`, `CFURLCreateWithString`…: Darwin's Foundation brings
+// CoreFoundation along, so code that imports only Foundation uses them
+// (SwiftSoup parses URLs with CFURL).
+@_exported import CoreFoundationTypes
+
+/// Seconds since 1 January 2001 (GMT), as `Date.timeIntervalSinceReferenceDate`.
+public typealias CFAbsoluteTime = Double
+public typealias CFTimeInterval = Double
+
+public func CFAbsoluteTimeGetCurrent() -> CFAbsoluteTime {
+    Date().timeIntervalSinceReferenceDate
+}
+
+extension NSError {
+    /// The type of `userInfo` keys (`NSErrorUserInfoKey`), which corelibs
+    /// Foundation leaves out. On Apple platforms it is a struct wrapping the
+    /// string; here it is the string, so `[NSError.UserInfoKey: Any]` is
+    /// `[String: Any]` and `key as String` holds.
+    public typealias UserInfoKey = String
+}
+
+/// Runs `body`: there is no Objective-C runtime, so nothing to release early.
+public func autoreleasepool<Result>(invoking body: () throws -> Result) rethrows -> Result {
+    try body()
+}
+
+// MARK: - Associated objects
+
+/// How an associated value is held. Recorded; values are always retained.
+public enum objc_AssociationPolicy: UInt, Sendable {
+    case OBJC_ASSOCIATION_ASSIGN = 0
+    case OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1
+    case OBJC_ASSOCIATION_COPY_NONATOMIC = 3
+    case OBJC_ASSOCIATION_RETAIN = 769
+    case OBJC_ASSOCIATION_COPY = 771
+}
+
+/// The values attached to objects with `objc_setAssociatedObject`. There is
+/// no Objective-C runtime, so the table is kept here: each object is held
+/// weakly, and the entries of objects that are gone are dropped as the table
+/// changes.
+nonisolated(unsafe) private var _associations: [ObjectIdentifier: (object: _WeakObject, values: [UnsafeRawPointer: Any])] = [:]
+
+private struct _WeakObject {
+    weak var object: AnyObject?
+}
+
+public func objc_setAssociatedObject(_ object: Any, _ key: UnsafeRawPointer, _ value: Any?, _ policy: objc_AssociationPolicy) {
+    let target = object as AnyObject
+    let id = ObjectIdentifier(target)
+    _associations = _associations.filter { $0.value.object.object != nil }
+    var entry = _associations[id] ?? (_WeakObject(object: target), [:])
+    entry.values[key] = value
+    _associations[id] = entry.values.isEmpty ? nil : entry
+}
+
+public func objc_getAssociatedObject(_ object: Any, _ key: UnsafeRawPointer) -> Any? {
+    let target = object as AnyObject
+    guard let entry = _associations[ObjectIdentifier(target)], entry.object.object === target else { return nil }
+    return entry.values[key]
+}
+
+public func objc_removeAssociatedObjects(_ object: Any) {
+    _associations[ObjectIdentifier(object as AnyObject)] = nil
+}
+
+/// An estimate: without the Objective-C runtime there is no instance size to
+/// read, and callers use it to weigh cache costs. Two words of header and six
+/// of storage.
+public func class_getInstanceSize(_ cls: AnyClass?) -> Int {
+    cls == nil ? 0 : 8 * MemoryLayout<Int>.size
+}

package/Sources/FoundationBridge/Dispatch.swift

@@ -0,0 +1,458 @@
+// `DispatchQueue` for the browser. The WASI SDK ships no Dispatch, yet
+// `DispatchQueue.main.async { … }` and `asyncAfter(deadline: .now() + 0.5)`
+// are how much SwiftUI code (and many packages) defer work to the next turn
+// or a moment later. The page has one thread, so every queue is the main
+// queue: work runs on the main actor, in order, from the runtime's executor,
+// and a deadline is a `Task.sleep` (so headless runs stay deterministic, like
+// `Timer` in Timer.swift).
+//
+// The CLI's staging gives the app (and each package built against the shim)
+// typealiases for these names, so a host `check`, where Foundation re-exports
+// Dispatch, type-checks against the same API the browser build has. Work
+// items and groups are here (a group's `notify` runs once everything that
+// entered has left), and memory-pressure sources, which never fire;
+// semaphores and other sources are not (waiting would block the only
+// thread): code that needs them is a compile error in the browser build.
+
+import Foundation
+
+/// A point in time for `asyncAfter`, on the clock `Task.sleep` uses.
+public struct DispatchTime: Comparable, Hashable, Sendable {
+    /// Nanoseconds since the first `now()` of the process.
+    public let uptimeNanoseconds: UInt64
+
+    public init(uptimeNanoseconds: UInt64) {
+        self.uptimeNanoseconds = uptimeNanoseconds
+    }
+
+    nonisolated(unsafe) private static let origin = ContinuousClock.now
+
+    public static func now() -> DispatchTime {
+        let elapsed = ContinuousClock.now - origin
+        let (seconds, attoseconds) = elapsed.components
+        return DispatchTime(uptimeNanoseconds: UInt64(max(0, seconds)) * 1_000_000_000 + UInt64(max(0, attoseconds) / 1_000_000_000))
+    }
+
+    public static let distantFuture = DispatchTime(uptimeNanoseconds: .max)
+
+    public static func < (lhs: DispatchTime, rhs: DispatchTime) -> Bool {
+        lhs.uptimeNanoseconds < rhs.uptimeNanoseconds
+    }
+
+    /// The time from this one to `other` (negative when `other` is earlier).
+    public func distance(to other: DispatchTime) -> DispatchTimeInterval {
+        .nanoseconds(Int(truncatingIfNeeded: Int64(bitPattern: other.uptimeNanoseconds &- uptimeNanoseconds)))
+    }
+
+    /// The time `nanoseconds` later (or earlier), clamped. Public for the CLI's generated operators.
+    public func _adding(nanoseconds: Double) -> DispatchTime {
+        let sum = Double(uptimeNanoseconds) + nanoseconds
+        if sum <= 0 { return DispatchTime(uptimeNanoseconds: 0) }
+        if sum >= Double(UInt64.max) { return .distantFuture }
+        return DispatchTime(uptimeNanoseconds: UInt64(sum))
+    }
+}
+
+// Global, as Dispatch declares them, so that `.now() + 0.5` finds them: the
+// left operand's type comes from the context, too late for a static operator.
+
+public func + (time: DispatchTime, seconds: Double) -> DispatchTime {
+    time._adding(nanoseconds: seconds * 1_000_000_000)
+}
+
+public func - (time: DispatchTime, seconds: Double) -> DispatchTime {
+    time._adding(nanoseconds: -seconds * 1_000_000_000)
+}
+
+public func + (time: DispatchTime, interval: DispatchTimeInterval) -> DispatchTime { DispatchTime._plus(time, interval) }
+public func - (time: DispatchTime, interval: DispatchTimeInterval) -> DispatchTime { DispatchTime._minus(time, interval) }
+
+extension DispatchTime {
+    public static func _plus(_ time: DispatchTime, _ interval: DispatchTimeInterval) -> DispatchTime {
+        guard let nanoseconds = interval.nanoseconds else { return .distantFuture }
+        return time._adding(nanoseconds: nanoseconds)
+    }
+
+    public static func _minus(_ time: DispatchTime, _ interval: DispatchTimeInterval) -> DispatchTime {
+        guard let nanoseconds = interval.nanoseconds else { return DispatchTime(uptimeNanoseconds: 0) }
+        return time._adding(nanoseconds: -nanoseconds)
+    }
+}
+
+/// A duration for `DispatchTime` arithmetic.
+public enum DispatchTimeInterval: Equatable, Sendable {
+    case seconds(Int)
+    case milliseconds(Int)
+    case microseconds(Int)
+    case nanoseconds(Int)
+    case never
+
+    var nanoseconds: Double? {
+        switch self {
+        case .seconds(let n): Double(n) * 1_000_000_000
+        case .milliseconds(let n): Double(n) * 1_000_000
+        case .microseconds(let n): Double(n) * 1_000
+        case .nanoseconds(let n): Double(n)
+        case .never: nil
+        }
+    }
+}
+
+/// A quality of service, accepted and ignored: the page runs everything on one thread.
+public struct DispatchQoS: Equatable, Sendable {
+    public enum QoSClass: Equatable, Sendable {
+        case background, utility, `default`, userInitiated, userInteractive, unspecified
+    }
+
+    public let qosClass: QoSClass
+
+    public init(qosClass: QoSClass, relativePriority: Int) {
+        self.qosClass = qosClass
+    }
+
+    public static let background = DispatchQoS(qosClass: .background, relativePriority: 0)
+    public static let utility = DispatchQoS(qosClass: .utility, relativePriority: 0)
+    public static let `default` = DispatchQoS(qosClass: .default, relativePriority: 0)
+    public static let userInitiated = DispatchQoS(qosClass: .userInitiated, relativePriority: 0)
+    public static let userInteractive = DispatchQoS(qosClass: .userInteractive, relativePriority: 0)
+    public static let unspecified = DispatchQoS(qosClass: .unspecified, relativePriority: 0)
+}
+
+/// A queue of work. Every queue runs its work on the main actor, in order.
+public final class DispatchQueue: Sendable {
+    public struct Attributes: OptionSet, Sendable {
+        public let rawValue: UInt64
+        public init(rawValue: UInt64) { self.rawValue = rawValue }
+        public static let concurrent = Attributes(rawValue: 1 << 1)
+        public static let initiallyInactive = Attributes(rawValue: 1 << 2)
+    }
+
+    public let label: String
+    /// `setSpecific` values, by key.
+    private let specifics = _QueueSpecifics()
+
+    public init(label: String, qos: DispatchQoS = .unspecified, attributes: Attributes = []) {
+        self.label = label
+    }
+
+    /// The queues whose work is running, innermost last: what
+    /// `DispatchQueue.getSpecific(key:)` reads. Code outside any queue's work
+    /// runs on the main queue.
+    nonisolated(unsafe) private static var running: [DispatchQueue] = []
+
+    /// Runs `work` as this queue's: `getSpecific(key:)` reads this queue's values meanwhile.
+    private func running<T>(_ work: () throws -> T) rethrows -> T {
+        Self.running.append(self)
+        defer { Self.running.removeLast() }
+        return try work()
+    }
+
+    /// Stores `value` under `key` on this queue (nil removes it).
+    public func setSpecific<T>(key: DispatchSpecificKey<T>, value: T?) {
+        specifics.values[ObjectIdentifier(key)] = value.map { $0 as Any }
+    }
+
+    /// The value stored under `key` on this queue.
+    public func getSpecific<T>(key: DispatchSpecificKey<T>) -> T? {
+        specifics.values[ObjectIdentifier(key)] as? T
+    }
+
+    /// The value stored under `key` on the queue whose work is running (the
+    /// main queue's outside any): how code tells it is already on a queue
+    /// (SQLite.swift's connections do before `sync`).
+    public static func getSpecific<T>(key: DispatchSpecificKey<T>) -> T? {
+        (running.last ?? main).getSpecific(key: key)
+    }
+
+    public static let main = DispatchQueue(label: "com.apple.main-thread")
+
+    public static func global(qos: DispatchQoS.QoSClass = .default) -> DispatchQueue {
+        main
+    }
+
+    /// Runs `work` on the next turn of the main actor.
+    public func async(execute work: @escaping () -> Void) {
+        nonisolated(unsafe) let work = work
+        Task { @MainActor in self.running(work) }
+    }
+
+    /// `async(group:qos:flags:execute:)`: the group, QoS and flags are accepted.
+    public func async(group: DispatchGroup? = nil, qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], execute work: @escaping () -> Void) {
+        group?.enter()
+        nonisolated(unsafe) let work = work
+        Task { @MainActor in
+            self.running(work)
+            group?.leave()
+        }
+    }
+
+    public func async(execute item: DispatchWorkItem) {
+        Task { @MainActor in self.running { item.perform() } }
+    }
+
+    /// Runs `work` once `deadline` has passed.
+    public func asyncAfter(deadline: DispatchTime, execute work: @escaping () -> Void) {
+        nonisolated(unsafe) let work = work
+        asyncAfter(deadline: deadline, qos: .unspecified, flags: [], execute: { work() })
+    }
+
+    public func asyncAfter(deadline: DispatchTime, qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], execute work: @escaping () -> Void) {
+        nonisolated(unsafe) let work = work
+        let delay = Self.delay(until: deadline)
+        Task { @MainActor in
+            if delay > 0 { try? await Task.sleep(for: .seconds(delay)) }
+            self.running(work)
+        }
+    }
+
+    public func asyncAfter(deadline: DispatchTime, execute item: DispatchWorkItem) {
+        let delay = Self.delay(until: deadline)
+        Task { @MainActor in
+            if delay > 0 { try? await Task.sleep(for: .seconds(delay)) }
+            self.running { item.perform() }
+        }
+    }
+
+    static func delay(until deadline: DispatchTime) -> Double {
+        let now = DispatchTime.now()
+        return deadline > now ? Double(deadline.uptimeNanoseconds - now.uptimeNanoseconds) / 1_000_000_000 : 0
+    }
+
+    public func sync(execute item: DispatchWorkItem) { running { item.perform() } }
+
+    public func sync<T>(flags: DispatchWorkItemFlags, execute work: () throws -> T) rethrows -> T {
+        try running(work)
+    }
+
+    /// Runs `work` now and returns its result: with one thread, nothing else can be running.
+    public func sync<T>(execute work: () throws -> T) rethrows -> T {
+        try running(work)
+    }
+}
+
+/// A key for `DispatchQueue.setSpecific(key:value:)`; keys compare by identity.
+public final class DispatchSpecificKey<T>: @unchecked Sendable {
+    public init() {}
+}
+
+final class _QueueSpecifics: @unchecked Sendable {
+    var values: [ObjectIdentifier: Any] = [:]
+}
+
+// MARK: - Sources
+
+/// A dispatch source. The browser raises no events for the kinds here: a
+/// memory-pressure source never fires (the page cannot tell), and handlers
+/// are kept until the source is cancelled.
+public protocol DispatchSourceProtocol: AnyObject, Sendable {
+    func setEventHandler(handler: (@Sendable () -> Void)?)
+    func setCancelHandler(handler: (@Sendable () -> Void)?)
+    func setRegistrationHandler(handler: (@Sendable () -> Void)?)
+    func activate()
+    func resume()
+    func suspend()
+    func cancel()
+    var isCancelled: Bool { get }
+}
+
+public protocol DispatchSourceMemoryPressure: DispatchSourceProtocol {
+    var data: DispatchSource.MemoryPressureEvent { get }
+    var mask: DispatchSource.MemoryPressureEvent { get }
+}
+
+public enum DispatchSource {
+    public struct MemoryPressureEvent: OptionSet, Sendable {
+        public let rawValue: UInt
+        public init(rawValue: UInt) { self.rawValue = rawValue }
+        public static let normal = MemoryPressureEvent(rawValue: 1 << 0)
+        public static let warning = MemoryPressureEvent(rawValue: 1 << 1)
+        public static let critical = MemoryPressureEvent(rawValue: 1 << 2)
+        public static let all: MemoryPressureEvent = [.normal, .warning, .critical]
+    }
+
+    public static func makeMemoryPressureSource(eventMask: MemoryPressureEvent, queue: DispatchQueue? = nil) -> any DispatchSourceMemoryPressure {
+        _MemoryPressureSource(mask: eventMask)
+    }
+}
+
+/// A timer source: once scheduled and resumed, it calls its handler at the
+/// deadline, and every `repeating` interval after that, on the main actor's
+/// clock, the executor's (asyncAfter's).
+public protocol DispatchSourceTimer: DispatchSourceProtocol {
+    /// Fires at `deadline`, then every `nanoseconds` (nil: once).
+    func _schedule(deadline: DispatchTime, repeatingNanoseconds nanoseconds: Double?)
+}
+
+extension DispatchSourceTimer {
+    public func schedule(deadline: DispatchTime, repeating interval: DispatchTimeInterval = .never, leeway: DispatchTimeInterval = .nanoseconds(0)) {
+        _schedule(deadline: deadline, repeatingNanoseconds: interval.nanoseconds.flatMap { $0 > 0 ? $0 : nil })
+    }
+    public func schedule(deadline: DispatchTime, repeating interval: Double, leeway: DispatchTimeInterval = .nanoseconds(0)) {
+        _schedule(deadline: deadline, repeatingNanoseconds: interval > 0 && interval.isFinite ? interval * 1_000_000_000 : nil)
+    }
+}
+
+extension DispatchSource {
+    public struct TimerFlags: OptionSet, Sendable {
+        public let rawValue: UInt
+        public init(rawValue: UInt) { self.rawValue = rawValue }
+        public static let strict = TimerFlags(rawValue: 1)
+    }
+
+    public static func makeTimerSource(flags: TimerFlags = [], queue: DispatchQueue? = nil) -> any DispatchSourceTimer {
+        _TimerSource()
+    }
+}
+
+final class _TimerSource: DispatchSourceTimer, @unchecked Sendable {
+    private var handler: (@Sendable () -> Void)?
+    private var cancelHandler: (@Sendable () -> Void)?
+    private var deadline: DispatchTime?
+    /// Nanoseconds between firings; nil for once.
+    private var interval: Double?
+    private var task: Task<Void, Never>?
+    private var running = false
+    private(set) var isCancelled = false
+
+    func setEventHandler(handler: (@Sendable () -> Void)?) { self.handler = handler }
+    func setCancelHandler(handler: (@Sendable () -> Void)?) { cancelHandler = handler }
+    func setRegistrationHandler(handler: (@Sendable () -> Void)?) { handler?() }
+
+    func _schedule(deadline: DispatchTime, repeatingNanoseconds nanoseconds: Double?) {
+        self.deadline = deadline
+        interval = nanoseconds
+        if running { start() }
+    }
+
+    func activate() { resume() }
+
+    func resume() {
+        guard !running, !isCancelled else { return }
+        running = true
+        start()
+    }
+
+    func suspend() {
+        running = false
+        task?.cancel()
+        task = nil
+    }
+
+    func cancel() {
+        guard !isCancelled else { return }
+        isCancelled = true
+        suspend()
+        handler = nil
+        let cancelHandler = self.cancelHandler
+        self.cancelHandler = nil
+        if let cancelHandler { DispatchQueue.main.async { cancelHandler() } }
+    }
+
+    private func start() {
+        task?.cancel()
+        guard let deadline, deadline != .distantFuture else { return }
+        nonisolated(unsafe) let source = self
+        task = Task { @MainActor in
+            let wait = Double(deadline.uptimeNanoseconds) - Double(DispatchTime.now().uptimeNanoseconds)
+            if wait > 0 { try? await Task.sleep(nanoseconds: UInt64(wait)) }
+            while !Task.isCancelled {
+                source.handler?()
+                guard let interval = source.interval else { break }
+                try? await Task.sleep(nanoseconds: UInt64(interval))
+            }
+        }
+    }
+}
+
+final class _MemoryPressureSource: DispatchSourceMemoryPressure, @unchecked Sendable {
+    let mask: DispatchSource.MemoryPressureEvent
+    private var handlers: [@Sendable () -> Void] = []
+    private(set) var isCancelled = false
+
+    init(mask: DispatchSource.MemoryPressureEvent) { self.mask = mask }
+
+    var data: DispatchSource.MemoryPressureEvent { [] }
+    func setEventHandler(handler: (@Sendable () -> Void)?) { handlers = handler.map { [$0] } ?? [] }
+    func setCancelHandler(handler: (@Sendable () -> Void)?) {}
+    func setRegistrationHandler(handler: (@Sendable () -> Void)?) {}
+    func activate() {}
+    func resume() {}
+    func suspend() {}
+    func cancel() {
+        isCancelled = true
+        handlers = []
+    }
+}
+
+// MARK: - Work items and groups
+
+public struct DispatchWorkItemFlags: OptionSet, Sendable {
+    public let rawValue: UInt
+    public init(rawValue: UInt) { self.rawValue = rawValue }
+    public static let barrier = DispatchWorkItemFlags(rawValue: 1 << 0)
+    public static let detached = DispatchWorkItemFlags(rawValue: 1 << 1)
+    public static let assignCurrentContext = DispatchWorkItemFlags(rawValue: 1 << 2)
+    public static let noQoS = DispatchWorkItemFlags(rawValue: 1 << 3)
+    public static let inheritQoS = DispatchWorkItemFlags(rawValue: 1 << 4)
+    public static let enforceQoS = DispatchWorkItemFlags(rawValue: 1 << 5)
+}
+
+/// Work that can be cancelled before it runs.
+public final class DispatchWorkItem: @unchecked Sendable {
+    private var block: (() -> Void)?
+    public private(set) var isCancelled = false
+
+    public init(qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], block: @escaping @convention(block) () -> Void) {
+        self.block = block
+    }
+
+    public func perform() {
+        guard !isCancelled else { return }
+        block?()
+    }
+
+    public func cancel() {
+        isCancelled = true
+        block = nil
+    }
+
+    /// Returns at once: with one thread, the work ran already or cannot run while this waits.
+    public func wait() {}
+}
+
+/// A group of work. `notify` runs once everything entered has left.
+public final class DispatchGroup: @unchecked Sendable {
+    private var count = 0
+    private var waiting: [() -> Void] = []
+
+    public init() {}
+
+    public func enter() { count += 1 }
+
+    public func leave() {
+        count = max(0, count - 1)
+        guard count == 0 else { return }
+        let ready = waiting
+        waiting = []
+        for work in ready { work() }
+    }
+
+    public func notify(qos: DispatchQoS = .unspecified, flags: DispatchWorkItemFlags = [], queue: DispatchQueue, execute work: @escaping () -> Void) {
+        nonisolated(unsafe) let work = work
+        if count == 0 {
+            queue.async(execute: { work() })
+        } else {
+            waiting.append { queue.async(execute: { work() }) }
+        }
+    }
+}
+
+// MARK: - Time constants
+
+// Dispatch's (C) time constants, which code multiplies `Task.sleep`
+// durations with (`Task.sleep(nanoseconds: NSEC_PER_SEC / 2)`).
+public let NSEC_PER_SEC: UInt64 = 1_000_000_000
+public let NSEC_PER_MSEC: UInt64 = 1_000_000
+public let NSEC_PER_USEC: UInt64 = 1_000
+public let USEC_PER_SEC: UInt64 = 1_000_000
+public let MSEC_PER_SEC: UInt64 = 1_000

package/Sources/FoundationBridge/EnvironmentFoundation.swift

@@ -0,0 +1,41 @@
+// SwiftUI's environment values of Foundation types: `locale`, `calendar` and
+// `timeZone`. The SwiftUI shim does not import Foundation, so they are
+// declared here. Each defaults to the current one (the viewer's locale,
+// FoundationBridge/Locale.swift); a view may set them for the views it
+// contains, which read them back. The shim's own texts and formatters do
+// not consult them.
+
+import Foundation
+import SwiftUI
+
+private struct LocaleKey: EnvironmentKey {
+    static var defaultValue: Locale? { nil }
+}
+
+private struct CalendarKey: EnvironmentKey {
+    static var defaultValue: Calendar? { nil }
+}
+
+private struct TimeZoneKey: EnvironmentKey {
+    static var defaultValue: TimeZone? { nil }
+}
+
+extension EnvironmentValues {
+    /// The locale views format for: the viewer's unless a view sets one.
+    public var locale: Locale {
+        get { self[LocaleKey.self] ?? .current }
+        set { self[LocaleKey.self] = newValue }
+    }
+
+    /// The calendar views use: the current one unless a view sets one.
+    public var calendar: Calendar {
+        get { self[CalendarKey.self] ?? .current }
+        set { self[CalendarKey.self] = newValue }
+    }
+
+    /// The time zone views use: the current one unless a view sets one.
+    public var timeZone: TimeZone {
+        get { self[TimeZoneKey.self] ?? .current }
+        set { self[TimeZoneKey.self] = newValue }
+    }
+}