@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/Charts/Axis.swift

@@ -0,0 +1,325 @@
+// Axes: `chartXAxis { AxisMarks(values:) { value in AxisGridLine(); AxisTick();
+// AxisValueLabel() } }`, `AxisValue`, and the axis builders. The resolved
+// axis JSON is produced in Chart.swift.
+
+// MARK: - AxisValue
+
+/// A tick's value, handed to the `AxisMarks` content closure.
+public struct AxisValue {
+    /// The tick's position among the axis's ticks.
+    public let index: Int
+    /// How many ticks the axis has.
+    public let count: Int
+    let value: _PlottableValue
+
+    /// The value as a plottable type (`value.as(Double.self)`, `.as(Date.self)`).
+    public func `as`<T: Plottable>(_ type: T.Type) -> T? {
+        T(_plottableValue: value)
+    }
+}
+
+// MARK: - Axis marks (grid line, tick, label)
+
+/// What an `AxisMarks` closure produces for one tick.
+public protocol AxisMark {
+    var _items: [_AxisMarkItem] { get }
+}
+
+public enum _AxisMarkLabel {
+    /// The default text for the value.
+    case automatic
+    case text(String)
+    case view(any View)
+    /// `AxisValueLabel(format:)`: the value formatted (nil: the default text).
+    case formatted((_PlottableValue) -> String?)
+}
+
+public enum _AxisMarkItem {
+    case gridLine
+    case tick
+    case label(_AxisMarkLabel)
+}
+
+public struct AxisGridLine: AxisMark {
+    public init(centered: Bool? = nil, stroke: StrokeStyle? = nil) {}
+    public var _items: [_AxisMarkItem] { [.gridLine] }
+}
+
+public struct AxisTick: AxisMark {
+    public init(centered: Bool? = nil, length: CGFloat? = nil, stroke: StrokeStyle? = nil) {}
+    public init(centered: Bool? = nil, length: AxisTickLength, stroke: StrokeStyle? = nil) {}
+    public var _items: [_AxisMarkItem] { [.tick] }
+}
+
+/// Accepted for source compatibility; the renderer draws 4 pt ticks.
+public enum AxisTickLength: Equatable, Sendable {
+    case automatic
+    case label
+    case length(CGFloat)
+}
+
+public struct AxisValueLabel: AxisMark {
+    let label: _AxisMarkLabel
+
+    /// The default text for the value.
+    public init(centered: Bool? = nil, anchor: UnitPoint? = nil, multiLabelAlignment: Alignment? = nil,
+                offsetsMarks: Bool? = nil, horizontalSpacing: CGFloat? = nil, verticalSpacing: CGFloat? = nil) {
+        label = .automatic
+    }
+
+    public init(_ titleKey: LocalizedStringKey, centered: Bool? = nil, anchor: UnitPoint? = nil,
+                multiLabelAlignment: Alignment? = nil, offsetsMarks: Bool? = nil,
+                horizontalSpacing: CGFloat? = nil, verticalSpacing: CGFloat? = nil) {
+        label = .text(titleKey.key)
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, centered: Bool? = nil, anchor: UnitPoint? = nil,
+                                   multiLabelAlignment: Alignment? = nil, offsetsMarks: Bool? = nil,
+                                   horizontalSpacing: CGFloat? = nil, verticalSpacing: CGFloat? = nil) {
+        label = .text(String(title))
+    }
+
+    /// A view as the label: becomes a `chartitem` child of the chart.
+    public init<C: View>(centered: Bool? = nil, anchor: UnitPoint? = nil, multiLabelAlignment: Alignment? = nil,
+                         offsetsMarks: Bool? = nil, horizontalSpacing: CGFloat? = nil,
+                         verticalSpacing: CGFloat? = nil, @ViewBuilder content: () -> C) {
+        label = .view(content())
+    }
+
+    init(_label: _AxisMarkLabel) {
+        label = _label
+    }
+
+    public var _items: [_AxisMarkItem] { [.label(label)] }
+}
+
+/// The marks an `AxisMarks` closure built for one tick.
+public struct _AxisMarkList: AxisMark {
+    public let _items: [_AxisMarkItem]
+}
+
+@resultBuilder
+public enum AxisMarkBuilder {
+    public static func buildBlock(_ parts: any AxisMark...) -> _AxisMarkList {
+        _AxisMarkList(_items: parts.flatMap(\._items))
+    }
+
+    public static func buildExpression<M: AxisMark>(_ mark: M) -> _AxisMarkList { _AxisMarkList(_items: mark._items) }
+
+    public static func buildOptional(_ list: _AxisMarkList?) -> _AxisMarkList { list ?? _AxisMarkList(_items: []) }
+
+    public static func buildEither(first: _AxisMarkList) -> _AxisMarkList { first }
+    public static func buildEither(second: _AxisMarkList) -> _AxisMarkList { second }
+
+    public static func buildArray(_ lists: [_AxisMarkList]) -> _AxisMarkList {
+        _AxisMarkList(_items: lists.flatMap(\._items))
+    }
+}
+
+// MARK: - AxisMarks
+
+/// Which side of the plot an axis sits on.
+public enum AxisMarkPosition: Hashable, Sendable {
+    case automatic, bottom, top, leading, trailing
+
+    var _name: String? {
+        switch self {
+        case .automatic: nil
+        case .bottom: "bottom"
+        case .top: "top"
+        case .leading: "leading"
+        case .trailing: "trailing"
+        }
+    }
+}
+
+/// Accepted for source compatibility; every preset renders the same marks.
+public enum AxisMarkPreset: Hashable, Sendable {
+    case automatic, extended, aligned, inset
+}
+
+/// How an axis picks its tick values.
+public struct AxisMarkValues: Equatable {
+    enum Spec: Equatable {
+        case automatic(_TickOptions)
+        case stride(Double, roundLowerBound: Bool, roundUpperBound: Bool)
+        case explicit([_PlottableValue])
+    }
+    let spec: Spec
+
+    public static var automatic: AxisMarkValues { AxisMarkValues(spec: .automatic(_TickOptions())) }
+
+    public static func automatic(desiredCount: Int? = nil, roundLowerBound: Bool? = nil,
+                                 roundUpperBound: Bool? = nil) -> AxisMarkValues {
+        AxisMarkValues(spec: .automatic(_TickOptions(desiredCount: desiredCount, minimumStride: nil,
+                                                     roundLowerBound: roundLowerBound ?? true,
+                                                     roundUpperBound: roundUpperBound ?? true)))
+    }
+
+    public static func automatic(minimumStride: Double, desiredCount: Int? = nil, roundLowerBound: Bool? = nil,
+                                 roundUpperBound: Bool? = nil) -> AxisMarkValues {
+        AxisMarkValues(spec: .automatic(_TickOptions(desiredCount: desiredCount, minimumStride: minimumStride,
+                                                     roundLowerBound: roundLowerBound ?? true,
+                                                     roundUpperBound: roundUpperBound ?? true)))
+    }
+
+    /// Ticks every `stride` along a numeric axis.
+    public static func stride(by stride: Double, roundLowerBound: Bool? = nil,
+                              roundUpperBound: Bool? = nil) -> AxisMarkValues {
+        AxisMarkValues(spec: .stride(stride, roundLowerBound: roundLowerBound ?? true,
+                                     roundUpperBound: roundUpperBound ?? true))
+    }
+}
+
+/// The marks of one axis: ticks at `values`, each drawn as `content` says
+/// (grid line, tick and label by default).
+public struct AxisMarks: AxisContent {
+    let position: AxisMarkPosition
+    let values: AxisMarkValues
+    let content: ((AxisValue) -> _AxisMarkList)?
+
+    public init(preset: AxisMarkPreset = .automatic, position: AxisMarkPosition = .automatic,
+                values: AxisMarkValues = .automatic, stroke: StrokeStyle? = nil) {
+        self.position = position
+        self.values = values
+        content = nil
+    }
+
+    public init(preset: AxisMarkPreset = .automatic, position: AxisMarkPosition = .automatic,
+                values: AxisMarkValues = .automatic,
+                @AxisMarkBuilder content: @escaping (AxisValue) -> _AxisMarkList) {
+        self.position = position
+        self.values = values
+        self.content = content
+    }
+
+    /// Ticks exactly at `values`.
+    public init<T: Plottable>(preset: AxisMarkPreset = .automatic, position: AxisMarkPosition = .automatic,
+                              values: [T], stroke: StrokeStyle? = nil) {
+        self.position = position
+        self.values = AxisMarkValues(spec: .explicit(values.map(\._plottableValue)))
+        content = nil
+    }
+
+    public init<T: Plottable>(preset: AxisMarkPreset = .automatic, position: AxisMarkPosition = .automatic,
+                              values: [T], @AxisMarkBuilder content: @escaping (AxisValue) -> _AxisMarkList) {
+        self.position = position
+        self.values = AxisMarkValues(spec: .explicit(values.map(\._plottableValue)))
+        self.content = content
+    }
+
+    public var _axisMarks: [AxisMarks] { [self] }
+}
+
+// MARK: - AxisContent
+
+/// The content of `chartXAxis { }` / `chartYAxis { }`: one or more `AxisMarks`.
+public protocol AxisContent {
+    var _axisMarks: [AxisMarks] { get }
+}
+
+public struct _AxisContentList: AxisContent {
+    public let _axisMarks: [AxisMarks]
+}
+
+@resultBuilder
+public enum AxisContentBuilder {
+    public static func buildBlock(_ parts: any AxisContent...) -> _AxisContentList {
+        _AxisContentList(_axisMarks: parts.flatMap(\._axisMarks))
+    }
+
+    public static func buildExpression<C: AxisContent>(_ content: C) -> _AxisContentList {
+        _AxisContentList(_axisMarks: content._axisMarks)
+    }
+
+    public static func buildOptional(_ list: _AxisContentList?) -> _AxisContentList {
+        list ?? _AxisContentList(_axisMarks: [])
+    }
+
+    public static func buildEither(first: _AxisContentList) -> _AxisContentList { first }
+    public static func buildEither(second: _AxisContentList) -> _AxisContentList { second }
+
+    public static func buildArray(_ lists: [_AxisContentList]) -> _AxisContentList {
+        _AxisContentList(_axisMarks: lists.flatMap(\._axisMarks))
+    }
+}
+
+// MARK: - Chart modifiers (environment)
+
+/// An axis as configured by `chartXAxis` / `chartYAxis`.
+struct _AxisSpec {
+    var hidden = false
+    /// Empty: the default `AxisMarks()`.
+    var marks: [AxisMarks] = []
+}
+
+/// Everything the `chart...` view modifiers set, read by the nearest `Chart`.
+struct _ChartConfig {
+    var xAxis = _AxisSpec()
+    var yAxis = _AxisSpec()
+    var legendHidden = false
+    var legendPosition = AnnotationPosition.automatic
+    var xDomain = _ScaleDomainSpec.automatic(includesZero: nil, reversed: false)
+    var yDomain = _ScaleDomainSpec.automatic(includesZero: nil, reversed: false)
+}
+
+enum _ChartConfigKey: EnvironmentKey {
+    static var defaultValue: _ChartConfig { _ChartConfig() }
+}
+
+extension EnvironmentValues {
+    var _chartConfig: _ChartConfig {
+        get { self[_ChartConfigKey.self] }
+        set { self[_ChartConfigKey.self] = newValue }
+    }
+}
+
+nonisolated extension View {
+    func _chartConfig(_ configure: @escaping (inout _ChartConfig) -> Void) -> some View {
+        _EnvironmentView(content: self) { configure(&$0._chartConfig) }
+    }
+
+    public func chartXAxis<C: AxisContent>(@AxisContentBuilder content: () -> C) -> some View {
+        let marks = content()._axisMarks
+        return _chartConfig { $0.xAxis = _AxisSpec(hidden: false, marks: marks) }
+    }
+
+    public func chartYAxis<C: AxisContent>(@AxisContentBuilder content: () -> C) -> some View {
+        let marks = content()._axisMarks
+        return _chartConfig { $0.yAxis = _AxisSpec(hidden: false, marks: marks) }
+    }
+
+    public func chartXAxis(_ visibility: Visibility) -> some View {
+        _chartConfig { $0.xAxis.hidden = visibility == .hidden }
+    }
+
+    public func chartYAxis(_ visibility: Visibility) -> some View {
+        _chartConfig { $0.yAxis.hidden = visibility == .hidden }
+    }
+
+    public func chartXScale<D: ScaleDomain>(domain: D) -> some View {
+        let spec = domain._domainSpec
+        return _chartConfig { $0.xDomain = spec }
+    }
+
+    public func chartYScale<D: ScaleDomain>(domain: D) -> some View {
+        let spec = domain._domainSpec
+        return _chartConfig { $0.yDomain = spec }
+    }
+
+    public func chartLegend(_ visibility: Visibility) -> some View {
+        _chartConfig { $0.legendHidden = visibility == .hidden }
+    }
+
+    public func chartLegend(position: AnnotationPosition = .automatic, alignment: Alignment? = nil,
+                            spacing: CGFloat? = nil) -> some View {
+        _chartConfig { $0.legendHidden = false; $0.legendPosition = position }
+    }
+
+    /// A custom legend view is not rendered; the position still applies.
+    public func chartLegend<C: View>(position: AnnotationPosition = .automatic, alignment: Alignment? = nil,
+                                     spacing: CGFloat? = nil, @ViewBuilder content: () -> C) -> some View {
+        _chartConfig { $0.legendHidden = false; $0.legendPosition = position }
+    }
+}

package/Sources/SwiftUI/Charts/AxisFormatsAndRanges.swift

@@ -0,0 +1,68 @@
+// `AxisValueLabel(format:)` and the scale ranges of `.chartXScale(range:)`.
+//
+// A formatted label is the tick's value converted to the format's input
+// type and formatted with it (the default text when the value is of
+// another type). A scale range (`.plotDimension(startPadding:endPadding:)`,
+// a range of points) is accepted: the page maps the domain to the whole plot.
+
+import Foundation
+
+extension AxisValueLabel {
+    /// The value formatted with `format` (`.dateTime.month().day()`, `.number`…).
+    public init<F: FormatStyle>(format: F, centered: Bool? = nil, anchor: UnitPoint? = nil,
+                                multiLabelAlignment: Alignment? = nil, collisionResolution: AxisValueLabelCollisionResolution = .automatic,
+                                offsetsMarks: Bool? = nil, orientation: AxisValueLabelOrientation = .automatic,
+                                horizontalSpacing: CGFloat? = nil, verticalSpacing: CGFloat? = nil)
+    where F.FormatInput: Plottable, F.FormatOutput == String {
+        self.init(_label: .formatted { value in F.FormatInput(_plottableValue: value).map { format.format($0) } })
+    }
+}
+
+/// How overlapping axis labels are resolved; accepted.
+public struct AxisValueLabelCollisionResolution: Hashable, Sendable {
+    let name: String
+    public static let automatic = AxisValueLabelCollisionResolution(name: "automatic")
+    public static let greedy = AxisValueLabelCollisionResolution(name: "greedy")
+    public static let truncate = AxisValueLabelCollisionResolution(name: "truncate")
+    public static let disabled = AxisValueLabelCollisionResolution(name: "disabled")
+}
+
+/// Which way axis labels run; accepted (labels are horizontal).
+public struct AxisValueLabelOrientation: Hashable, Sendable {
+    let name: String
+    public static let automatic = AxisValueLabelOrientation(name: "automatic")
+    public static let horizontal = AxisValueLabelOrientation(name: "horizontal")
+    public static let vertical = AxisValueLabelOrientation(name: "vertical")
+    public static let verticalReversed = AxisValueLabelOrientation(name: "verticalReversed")
+}
+
+/// The points a scale maps its domain to; accepted.
+public protocol ScaleRange {}
+
+/// The plot's length along the axis, less the paddings.
+public struct PlotDimensionScaleRange: ScaleRange, Hashable, Sendable {}
+
+extension ScaleRange where Self == PlotDimensionScaleRange {
+    public static var plotDimension: PlotDimensionScaleRange { PlotDimensionScaleRange() }
+    public static func plotDimension(padding: CGFloat) -> PlotDimensionScaleRange { PlotDimensionScaleRange() }
+    public static func plotDimension(startPadding: CGFloat = 0, endPadding: CGFloat = 0) -> PlotDimensionScaleRange {
+        PlotDimensionScaleRange()
+    }
+}
+
+extension ClosedRange: ScaleRange where Bound == CGFloat {}
+
+nonisolated extension View {
+    /// Accepted (see the file comment).
+    public func chartXScale<R: ScaleRange>(range: R) -> some View { self }
+    public func chartYScale<R: ScaleRange>(range: R) -> some View { self }
+
+    /// The domain, as `chartXScale(domain:)`; the range is accepted.
+    public func chartXScale<D: ScaleDomain, R: ScaleRange>(domain: D, range: R) -> some View {
+        chartXScale(domain: domain)
+    }
+
+    public func chartYScale<D: ScaleDomain, R: ScaleRange>(domain: D, range: R) -> some View {
+        chartYScale(domain: domain)
+    }
+}