@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/Charts/Plottable.swift

@@ -0,0 +1,99 @@
+// Swift Charts' `Plottable` and `PlottableValue`. The shim reduces every
+// plottable value to `_PlottableValue`, a number, a string or a date (seconds
+// since 1970, UTC), so the chart can scale it without knowing the type.
+// `Date` conforms in the `Charts` target, which links Foundation.
+
+/// The primitive a chart scales: numbers and dates are continuous, strings
+/// are categories.
+public enum _PlottableValue: Hashable, Sendable {
+    case number(Double)
+    case string(String)
+    /// Seconds since 1970 (UTC).
+    case date(Double)
+
+    /// The position on a continuous scale, if any.
+    var continuous: Double? {
+        switch self {
+        case .number(let v): v
+        case .date(let v): v
+        case .string: nil
+        }
+    }
+
+    var isDate: Bool { if case .date = self { true } else { false } }
+    var isString: Bool { if case .string = self { true } else { false } }
+
+    /// A plain text form (categories as themselves, numbers formatted).
+    var text: String {
+        switch self {
+        case .number(let v): _formatChartNumber(v)
+        case .string(let s): s
+        case .date(let s): _formatChartDate(s, as: .dayMonth)
+        }
+    }
+}
+
+/// A type a chart can place on an axis.
+public protocol Plottable {
+    var _plottableValue: _PlottableValue { get }
+    init?(_plottableValue: _PlottableValue)
+}
+
+extension Double: Plottable {
+    public var _plottableValue: _PlottableValue { .number(self) }
+    public init?(_plottableValue value: _PlottableValue) {
+        guard case .number(let v) = value else { return nil }
+        self = v
+    }
+}
+
+extension Float: Plottable {
+    public var _plottableValue: _PlottableValue { .number(Double(self)) }
+    public init?(_plottableValue value: _PlottableValue) {
+        guard case .number(let v) = value else { return nil }
+        self = Float(v)
+    }
+}
+
+extension Int: Plottable {
+    public var _plottableValue: _PlottableValue { .number(Double(self)) }
+    public init?(_plottableValue value: _PlottableValue) {
+        guard case .number(let v) = value, v.isFinite, abs(v) < 9e15 else { return nil }
+        self = Int(v.rounded())
+    }
+}
+
+extension String: Plottable {
+    public var _plottableValue: _PlottableValue { .string(self) }
+    public init?(_plottableValue value: _PlottableValue) {
+        guard case .string(let s) = value else { return nil }
+        self = s
+    }
+}
+
+/// A labelled value for a mark's dimension: `.value("Sales", sale.sales)`.
+public struct PlottableValue<Value: Plottable> {
+    public let label: String
+    public let value: Value
+
+    init(label: String, value: Value) {
+        self.label = label
+        self.value = value
+    }
+
+    public static func value(_ labelKey: LocalizedStringKey, _ value: Value) -> PlottableValue<Value> {
+        PlottableValue(label: labelKey.key, value: value)
+    }
+
+    public static func value<S: StringProtocol>(_ label: S, _ value: Value) -> PlottableValue<Value> {
+        PlottableValue(label: String(label), value: value)
+    }
+
+    var _erased: _LabelledValue { _LabelledValue(label: label, value: value._plottableValue) }
+}
+
+/// A `PlottableValue` without its type.
+struct _LabelledValue: Hashable {
+    var label: String
+    var value: _PlottableValue
+}

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
+}