@swiftbrowser/swift 0.0.0-stage → 0.1.0

package/Sources/SwiftUI/Charts/Scales.swift

@@ -0,0 +1,326 @@
+// Scale domains, "nice" tick generation for numbers and dates, and the
+// default label formats. No Foundation: dates are UTC epoch seconds and the
+// calendar arithmetic is done here (Howard Hinnant's civil date algorithms).
+
+// MARK: - ScaleDomain
+
+/// The domain of a chart scale: `.automatic(includesZero:)`, a closed range or
+/// an array of categories / values.
+public protocol ScaleDomain {
+    var _domainSpec: _ScaleDomainSpec { get }
+}
+
+public enum _ScaleDomainSpec: Equatable, Sendable {
+    case automatic(includesZero: Bool?, reversed: Bool)
+    case values([_PlottableValue])
+}
+
+public struct AutomaticScaleDomain: ScaleDomain, Sendable {
+    let includesZero: Bool?
+    let reversed: Bool
+
+    public var _domainSpec: _ScaleDomainSpec { .automatic(includesZero: includesZero, reversed: reversed) }
+}
+
+extension ScaleDomain where Self == AutomaticScaleDomain {
+    public static var automatic: AutomaticScaleDomain { AutomaticScaleDomain(includesZero: nil, reversed: false) }
+
+    public static func automatic(includesZero: Bool? = nil, reversed: Bool? = nil) -> AutomaticScaleDomain {
+        AutomaticScaleDomain(includesZero: includesZero, reversed: reversed ?? false)
+    }
+}
+
+extension ClosedRange: ScaleDomain where Bound: Plottable {
+    public var _domainSpec: _ScaleDomainSpec {
+        .values([lowerBound._plottableValue, upperBound._plottableValue])
+    }
+}
+
+extension Array: ScaleDomain where Element: Plottable {
+    public var _domainSpec: _ScaleDomainSpec { .values(map(\._plottableValue)) }
+}
+
+// MARK: - Nice numbers
+
+/// Tick spacing options from `AxisMarks(values: .automatic(...))`.
+struct _TickOptions: Equatable {
+    var desiredCount: Int?
+    var minimumStride: Double?
+    var roundLowerBound = true
+    var roundUpperBound = true
+}
+
+/// A "nice" step for a range: 1, 2, 2.5, 5 or 10 × 10^k, whichever is
+/// nearest (geometrically) to `span / (desiredCount − 1)`; about 5 ticks by
+/// default.
+func _niceStep(span: Double, desiredCount: Int?, minimumStride: Double?) -> Double {
+    let count = max(1, (desiredCount ?? 5) - 1)
+    guard span > 0, span.isFinite else { return max(minimumStride ?? 1, 1) }
+    let raw = span / Double(count)
+    var magnitude = 1.0
+    while magnitude * 10 <= raw { magnitude *= 10 }
+    while magnitude > raw { magnitude /= 10 }
+    let residual = raw / magnitude
+    // Thresholds are the geometric means of neighbouring candidates.
+    let factor: Double = if residual >= 7.0710678 { 10 }
+        else if residual >= 3.5355339 { 5 }
+        else if residual >= 2.2360680 { 2.5 }
+        else if residual >= 1.4142136 { 2 }
+        else { 1 }
+    var step = factor * magnitude
+    if let minimumStride, step < minimumStride {
+        // Honor the minimum: the smallest nice multiple of the magnitude at or above it.
+        var s = minimumStride
+        var m = 1.0
+        while m * 10 <= s { m *= 10 }
+        while m > s { m /= 10 }
+        for candidate in [1.0, 2.0, 2.5, 5.0, 10.0] where candidate * m >= s - 1e-9 {
+            s = candidate * m
+            break
+        }
+        step = s
+    }
+    return step
+}
+
+/// Rounds away floating noise so `0.30000000000000004` prints as `0.3`.
+func _cleanTick(_ value: Double, step: Double) -> Double {
+    var scale = 1.0
+    var s = step
+    while s < 1, scale < 1e9 { s *= 10; scale *= 10 }
+    return (value * scale).rounded() / scale
+}
+
+/// Nice ticks over `lower...upper`. The ticks always cover the domain
+/// (first ≤ lower, last ≥ upper); the caller decides whether to extend the
+/// domain to them or drop the ones outside.
+func _niceTicks(lower: Double, upper: Double, options: _TickOptions) -> [Double] {
+    let step = _niceStep(span: upper - lower, desiredCount: options.desiredCount, minimumStride: options.minimumStride)
+    let first = (lower / step).rounded(.down) * step
+    let last = (upper / step).rounded(.up) * step
+    var ticks: [Double] = []
+    var tick = first
+    var guardCount = 0
+    while tick <= last + step * 1e-9, guardCount < 1000 {
+        ticks.append(_cleanTick(tick, step: step))
+        tick += step
+        guardCount += 1
+    }
+    return ticks
+}
+
+// MARK: - Civil dates (UTC)
+
+struct _CivilDate: Equatable {
+    var year: Int
+    var month: Int
+    var day: Int
+    var hour: Int
+    var minute: Int
+    var second: Int
+}
+
+let _secondsPerDay = 86400.0
+
+/// Days since 1970-01-01 for a civil date (Hinnant's `days_from_civil`).
+func _daysFromCivil(year: Int, month: Int, day: Int) -> Int {
+    let y = month <= 2 ? year - 1 : year
+    let era = (y >= 0 ? y : y - 399) / 400
+    let yoe = y - era * 400
+    let mp = (month + 9) % 12
+    let doy = (153 * mp + 2) / 5 + day - 1
+    let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy
+    return era * 146097 + doe - 719468
+}
+
+/// The civil date of a day count since 1970-01-01 (Hinnant's `civil_from_days`).
+func _civilFromDays(_ days: Int) -> (year: Int, month: Int, day: Int) {
+    let z = days + 719468
+    let era = (z >= 0 ? z : z - 146096) / 146097
+    let doe = z - era * 146097
+    let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365
+    let y = yoe + era * 400
+    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100)
+    let mp = (5 * doy + 2) / 153
+    let d = doy - (153 * mp + 2) / 5 + 1
+    let m = mp < 10 ? mp + 3 : mp - 9
+    return (m <= 2 ? y + 1 : y, m, d)
+}
+
+func _civil(fromSeconds seconds: Double) -> _CivilDate {
+    let days = Int((seconds / _secondsPerDay).rounded(.down))
+    var rest = Int((seconds - Double(days) * _secondsPerDay).rounded(.down))
+    rest = max(0, min(86399, rest))
+    let (y, m, d) = _civilFromDays(days)
+    return _CivilDate(year: y, month: m, day: d, hour: rest / 3600, minute: (rest % 3600) / 60, second: rest % 60)
+}
+
+func _seconds(year: Int, month: Int, day: Int, hour: Int = 0) -> Double {
+    Double(_daysFromCivil(year: year, month: month, day: day)) * _secondsPerDay + Double(hour) * 3600
+}
+
+// MARK: - Date ticks
+
+/// The calendar unit a date axis labels in.
+enum _DateUnit: Equatable {
+    case hour, day, month, year
+}
+
+enum _DateFormat: Equatable {
+    /// "9 AM", "12 PM"
+    case hour
+    /// "Sep 30"
+    case dayMonth
+    /// "Jan"
+    case month
+    /// "Jan 2026"
+    case monthYear
+    /// "2026"
+    case year
+}
+
+let _monthAbbreviations = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+
+func _formatChartDate(_ seconds: Double, as format: _DateFormat) -> String {
+    let c = _civil(fromSeconds: seconds)
+    switch format {
+    case .hour:
+        let h12 = c.hour % 12 == 0 ? 12 : c.hour % 12
+        let suffix = c.hour < 12 ? "AM" : "PM"
+        if c.minute != 0 {
+            let minute = c.minute < 10 ? "0\(c.minute)" : "\(c.minute)"
+            return "\(h12):\(minute) \(suffix)"
+        }
+        return "\(h12) \(suffix)"
+    case .dayMonth:
+        return "\(_monthAbbreviations[c.month - 1]) \(c.day)"
+    case .month:
+        return _monthAbbreviations[c.month - 1]
+    case .monthYear:
+        return "\(_monthAbbreviations[c.month - 1]) \(c.year)"
+    case .year:
+        return "\(c.year)"
+    }
+}
+
+/// The ticks of a date axis: a unit and stride chosen for the span (hours
+/// for up to three days, days for up to about 45, then months and years),
+/// aligned to calendar boundaries and covering `lower...upper`.
+func _niceDateTicks(lower: Double, upper: Double, options: _TickOptions) -> (ticks: [Double], format: _DateFormat) {
+    let span = max(upper - lower, 0)
+    let maxIntervals = Double(max(2, (options.desiredCount ?? 7) + 1))
+    func fits(_ strideSeconds: Double) -> Bool { span / strideSeconds <= maxIntervals }
+
+    if span <= 3 * _secondsPerDay {
+        let hours = [1.0, 3, 6, 12].first { fits($0 * 3600) } ?? 12
+        let step = hours * 3600
+        var ticks: [Double] = []
+        var tick = (lower / step).rounded(.down) * step
+        let last = (upper / step).rounded(.up) * step
+        while tick <= last + 1e-6, ticks.count < 1000 {
+            ticks.append(tick)
+            tick += step
+        }
+        return (ticks, .hour)
+    }
+
+    if span <= 45 * _secondsPerDay {
+        let days = [1.0, 2, 7, 14].first { fits($0 * _secondsPerDay) } ?? 14
+        let step = days * _secondsPerDay
+        var ticks: [Double] = []
+        var tick = (lower / _secondsPerDay).rounded(.down) * _secondsPerDay
+        let last = (upper / _secondsPerDay).rounded(.up) * _secondsPerDay
+        while tick <= last + 1e-6, ticks.count < 1000 {
+            ticks.append(tick)
+            tick += step
+        }
+        // Make sure the last tick covers the upper bound.
+        if let final = ticks.last, final < last { ticks.append(final + step) }
+        return (ticks, .dayMonth)
+    }
+
+    // Months and years: strides in months.
+    let lowerCivil = _civil(fromSeconds: lower)
+    let upperCivil = _civil(fromSeconds: upper)
+    let spanMonths = Double((upperCivil.year - lowerCivil.year) * 12 + (upperCivil.month - lowerCivil.month) + 1)
+    let monthStrides = [1, 2, 3, 6, 12, 24, 60, 120]
+    let stride = monthStrides.first { spanMonths / Double($0) <= maxIntervals } ?? 120
+    var ticks: [Double] = []
+    var year = lowerCivil.year
+    var month = lowerCivil.month
+    if stride >= 12 {
+        month = 1
+        let yearsStride = stride / 12
+        year = (year / yearsStride) * yearsStride
+    } else {
+        month = ((month - 1) / stride) * stride + 1
+    }
+    var crossesYear = false
+    while ticks.count < 1000 {
+        let tick = _seconds(year: year, month: month, day: 1)
+        ticks.append(tick)
+        if year != lowerCivil.year { crossesYear = true }
+        if tick >= upper { break }
+        month += stride
+        while month > 12 { month -= 12; year += 1 }
+    }
+    if stride >= 12 { return (ticks, .year) }
+    return (ticks, crossesYear || lowerCivil.year != upperCivil.year ? .monthYear : .month)
+}
+
+/// The format for explicit date values: hours when any value is not at
+/// midnight, days when any is not a month start, else months.
+func _dateFormat(forValues values: [Double]) -> _DateFormat {
+    var hasHours = false
+    var hasDays = false
+    var years = Set<Int>()
+    for value in values {
+        let c = _civil(fromSeconds: value)
+        if c.hour != 0 || c.minute != 0 { hasHours = true }
+        if c.day != 1 { hasDays = true }
+        years.insert(c.year)
+    }
+    if hasHours { return .hour }
+    if hasDays { return .dayMonth }
+    return years.count > 1 ? .monthYear : .month
+}
+
+// MARK: - Number formatting
+
+/// Thousands grouping for a run of digits.
+func _groupThousands(_ digits: String) -> String {
+    var out = ""
+    for (index, ch) in digits.enumerated() {
+        if index > 0, (digits.count - index) % 3 == 0 { out += "," }
+        out.append(ch)
+    }
+    return out
+}
+
+/// `formatted()`-like: grouped thousands, up to two fraction digits, no
+/// trailing zeros.
+func _formatChartNumber(_ value: Double) -> String {
+    guard value.isFinite else { return "\(value)" }
+    let negative = value < 0
+    let magnitude = abs(value)
+    let scaled = (magnitude * 100).rounded()
+    var integer = Int(scaled / 100)
+    var fraction = Int(scaled) - integer * 100
+    if fraction < 0 { fraction = 0 }
+    if fraction >= 100 { integer += 1; fraction = 0 }
+    var text = _groupThousands(String(integer))
+    if fraction != 0 {
+        if fraction % 10 == 0 {
+            text += ".\(fraction / 10)"
+        } else {
+            text += fraction < 10 ? ".0\(fraction)" : ".\(fraction)"
+        }
+    }
+    return (negative && (integer != 0 || fraction != 0) ? "-" : "") + text
+}
+
+/// Four decimals, so unit coordinates are byte-stable in snapshots.
+func _unit(_ value: Double) -> Double {
+    guard value.isFinite else { return 0 }
+    return (value * 10000).rounded() / 10000
+}

package/Sources/SwiftUI/Runtime/Executor.swift

@@ -0,0 +1,83 @@
+@_spi(ExperimentalCustomExecutors) @_spi(ExperimentalScheduling) import _Concurrency
+
+/// A host-driven cooperative executor. Jobs created by `Task`, `.task` and
+/// sleeps queue here until the host calls `sb_run_jobs`; delays become
+/// timers against a clock the host sets (real time in the browser, a
+/// virtual clock in headless mode). See docs/ops-protocol.md (Phase 4).
+final class _HostExecutor: MainExecutor, SchedulingExecutor, TaskExecutor, @unchecked Sendable {
+    static let shared = _HostExecutor()
+
+    private var queue: [UnownedJob] = []
+    private var timers: [(deadlineNs: UInt64, job: UnownedJob)] = []
+    /// The executor's clock in nanoseconds; origin is arbitrary.
+    var nowNs: UInt64 = 0
+
+    func enqueue(_ job: consuming ExecutorJob) {
+        queue.append(UnownedJob(job))
+    }
+
+    func run() throws {}
+    func stop() {}
+    func checkIsolated() {}
+    func isIsolatingCurrentContext() -> Bool? { true }
+
+    func enqueue<C: Clock>(_ job: consuming ExecutorJob, after delay: C.Duration, tolerance: C.Duration?, clock: C) {
+        timers.append((nowNs + nanoseconds(of: delay), UnownedJob(job)))
+    }
+
+    func enqueue<C: Clock>(_ job: consuming ExecutorJob, at instant: C.Instant, tolerance: C.Duration?, clock: C) {
+        let delay = clock.now.duration(to: instant)
+        timers.append((nowNs + nanoseconds(of: delay), UnownedJob(job)))
+    }
+
+    /// Delays are rounded so timers stay aligned and headless runs are
+    /// deterministic.
+    private func nanoseconds<D: DurationProtocol>(of duration: D) -> UInt64 {
+        guard let duration = duration as? Duration else { return 0 }
+        let (seconds, attoseconds) = duration.components
+        let ns = Double(max(0, seconds)) * 1e9 + Double(max(0, attoseconds)) / 1e9
+        // 10 ms granularity: the WASI clock is coarse, and `Task.sleep(for:)`
+        // computes an absolute instant from it before we see the delay.
+        return UInt64((ns / 1e7).rounded() * 1e7)
+    }
+
+    /// Runs every queued job and every due timer, repeatedly, until the
+    /// queue is empty. Returns nanoseconds until the next timer, or -1.
+    func runJobs() -> Int64 {
+        var ran = 0
+        repeat {
+            ran = 0
+            while !queue.isEmpty {
+                let job = queue.removeFirst()
+                job.runSynchronously(on: asUnownedSerialExecutor())
+                ran += 1
+            }
+            timers.sort { $0.deadlineNs < $1.deadlineNs }
+            while let first = timers.first, first.deadlineNs <= nowNs {
+                timers.removeFirst()
+                queue.append(first.job)
+                ran += 1
+            }
+        } while ran > 0
+        guard let next = timers.first else { return -1 }
+        return Int64(next.deadlineNs - nowNs)
+    }
+
+    var hasTimers: Bool { !timers.isEmpty }
+}
+
+enum _HostExecutorFactory: ExecutorFactory {
+    static var mainExecutor: any MainExecutor { _HostExecutor.shared }
+    static var defaultExecutor: any TaskExecutor { _HostExecutor.shared }
+}
+
+nonisolated(unsafe) private var executorInstalled = false
+
+/// Installs the host-driven executor. Must run before any task is created;
+/// `App.main()` calls it. Native test processes must not install it, since
+/// the test runner drives the main actor itself.
+public func _installHostExecutor() {
+    guard !executorInstalled else { return }
+    executorInstalled = true
+    _createExecutors(factory: _HostExecutorFactory.self)
+}

package/Sources/SwiftUI/Runtime/Exports.swift

@@ -0,0 +1,65 @@
+// C-ABI entry points for the browser renderer. See docs/ops-protocol.md.
+// Wasm is single-threaded, so the main actor is the only executor.
+
+@_cdecl("sb_event")
+public func _sb_event(_ id: Int32) {
+    MainActor.assumeIsolated {
+        _Runtime.shared.dispatch(tap: Int(id))
+    }
+}
+
+@_cdecl("sb_ops_ptr")
+public func _sb_ops_ptr() -> Int32 {
+    MainActor.assumeIsolated { _BufferedHost.shared.pointer }
+}
+
+@_cdecl("sb_ops_len")
+public func _sb_ops_len() -> Int32 {
+    MainActor.assumeIsolated { _BufferedHost.shared.length }
+}
+
+@_cdecl("sb_ops_clear")
+public func _sb_ops_clear() {
+    MainActor.assumeIsolated { _BufferedHost.shared.clear() }
+}
+
+/// Allocates a buffer the renderer fills before calling `sb_event_json`.
+@_cdecl("sb_alloc")
+public func _sb_alloc(_ length: Int32) -> Int32 {
+    let pointer = UnsafeMutablePointer<UInt8>.allocate(capacity: Int(max(length, 1)))
+    return Int32(Int(bitPattern: pointer))
+}
+
+/// Delivers one UTF-8 JSON event written into a buffer from `sb_alloc`.
+@_cdecl("sb_event_json")
+public func _sb_event_json(_ pointer: Int32, _ length: Int32) {
+    guard let base = UnsafeMutablePointer<UInt8>(bitPattern: Int(pointer)) else { return }
+    let text = String(decoding: UnsafeBufferPointer(start: base, count: Int(length)), as: UTF8.self)
+    base.deallocate()
+    MainActor.assumeIsolated {
+        guard let event = try? _JSON.parse(text) else {
+            print("[SwiftUI] ignoring malformed event: \(text)")
+            return
+        }
+        _Runtime.shared.dispatch(event: event)
+    }
+}
+
+@_cdecl("sb_state_ptr")
+public func _sb_state_ptr() -> Int32 {
+    MainActor.assumeIsolated {
+        _StateBuffer.shared.refresh(with: _Runtime.shared.snapshot())
+        return _StateBuffer.shared.pointer
+    }
+}
+
+@_cdecl("sb_state_len")
+public func _sb_state_len() -> Int32 {
+    MainActor.assumeIsolated { _StateBuffer.shared.length }
+}
+
+/// Drives Swift concurrency: see `_Runtime.runJobs(nowMilliseconds:)`.
+@_cdecl("sb_run_jobs")
+public func _sb_run_jobs(_ nowMilliseconds: Double) -> Double {
+    MainActor.assumeIsolated { _Runtime.shared.runJobs(nowMilliseconds: nowMilliseconds) }
+}

package/Sources/SwiftUI/Runtime/JSON.swift

@@ -0,0 +1,71 @@
+/// A minimal JSON value. The shim avoids Foundation (see Geometry.swift), so it
+/// carries its own serializer. Object keys serialize in sorted order so the
+/// output is byte-stable for snapshot tests.
+public enum _JSON: Equatable, Sendable {
+    case null
+    case bool(Bool)
+    case number(Double)
+    case string(String)
+    case array([_JSON])
+    case object([String: _JSON])
+
+    public var serialized: String {
+        var out = ""
+        write(into: &out)
+        return out
+    }
+
+    private func write(into out: inout String) {
+        switch self {
+        case .null:
+            out += "null"
+        case .bool(let value):
+            out += value ? "true" : "false"
+        case .number(let value):
+            if value.isFinite, value == value.rounded(), abs(value) < 1e15 {
+                out += String(Int64(value))
+            } else if value.isFinite {
+                out += "\(value)"
+            } else {
+                out += "null"
+            }
+        case .string(let value):
+            _JSON.writeString(value, into: &out)
+        case .array(let items):
+            out += "["
+            for (index, item) in items.enumerated() {
+                if index > 0 { out += "," }
+                item.write(into: &out)
+            }
+            out += "]"
+        case .object(let members):
+            out += "{"
+            for (index, key) in members.keys.sorted().enumerated() {
+                if index > 0 { out += "," }
+                _JSON.writeString(key, into: &out)
+                out += ":"
+                members[key]!.write(into: &out)
+            }
+            out += "}"
+        }
+    }
+
+    private static func writeString(_ value: String, into out: inout String) {
+        out += "\""
+        for scalar in value.unicodeScalars {
+            switch scalar {
+            case "\"": out += "\\\""
+            case "\\": out += "\\\\"
+            case "\n": out += "\\n"
+            case "\r": out += "\\r"
+            case "\t": out += "\\t"
+            case _ where scalar.value < 0x20:
+                let hex = String(scalar.value, radix: 16)
+                out += "\\u" + String(repeating: "0", count: 4 - hex.count) + hex
+            default:
+                out.unicodeScalars.append(scalar)
+            }
+        }
+        out += "\""
+    }
+}