@swiftbrowser/swift 0.1.0 → 0.3.0

package/Sources/SwiftUI/Charts/Axis.swift

@@ -30,6 +30,8 @@ public enum _AxisMarkLabel {
     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 {
@@ -85,6 +87,10 @@ public struct AxisValueLabel: AxisMark {
         label = .view(content())
     }
 
+    init(_label: _AxisMarkLabel) {
+        label = _label
+    }
+
     public var _items: [_AxisMarkItem] { [.label(label)] }
 }
 
@@ -269,7 +275,7 @@ extension EnvironmentValues {
     }
 }
 
-extension View {
+nonisolated extension View {
     func _chartConfig(_ configure: @escaping (inout _ChartConfig) -> Void) -> some View {
         _EnvironmentView(content: self) { configure(&$0._chartConfig) }
     }

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

package/Sources/SwiftUI/Charts/Chart.swift

@@ -535,8 +535,20 @@ private struct _ChartResolver {
         for set in axis.ticks {
             let count = set.values.count
             for (index, value) in set.values.enumerated() {
-                let unit = axis.scale.unit(value) ?? 0
+                let scaled = axis.scale.unit(value)
+                // A value outside the scale's domain (a date bin that starts
+                // before the data) has no mark, as in Swift Charts.
+                if let scaled, scaled < -1e-9 || scaled > 1 + 1e-9 { continue }
+                let unit = scaled ?? 0
                 let at = _unit(isX ? unit : 1 - unit)
+                // A date's label starts at its tick, as Swift Charts places it;
+                // other values are centered on theirs.
+                func label(_ text: String) -> _JSON {
+                    if isX, case .date = value {
+                        return .object(["at": .number(at), "text": .string(text), "anchor": .string("leading")])
+                    }
+                    return .object(["at": .number(at), "text": .string(text)])
+                }
                 let marks = set.marks.content?(AxisValue(index: index, count: count, value: value))._items
                     ?? [.gridLine, .tick, .label(.automatic)]
                 for item in marks {
@@ -546,9 +558,11 @@ private struct _ChartResolver {
                     case .tick:
                         ticks.append(.number(at))
                     case .label(.automatic):
-                        labels.append(.object(["at": .number(at), "text": .string(defaultLabel(value, axis: axis))]))
+                        labels.append(label(defaultLabel(value, axis: axis)))
                     case .label(.text(let text)):
-                        labels.append(.object(["at": .number(at), "text": .string(text)]))
+                        labels.append(label(text))
+                    case .label(.formatted(let format)):
+                        labels.append(label(format(value) ?? defaultLabel(value, axis: axis)))
                     case .label(.view(let view)):
                         let edge: Double = position == "top" || position == "leading" ? 0 : 1
                         views.append(_ChartItemView(

package/Sources/SwiftUI/Charts/ChartProxy.swift

@@ -0,0 +1,57 @@
+/// `ChartProxy`, `.chartOverlay`, `.chartBackground` and the selection
+/// modifiers. The page lays charts out and draws their marks (Phase 7), so
+/// the Swift side knows no plot geometry: a proxy maps no value to a
+/// position or back (nil), and its plot frame is unknown (nil). An overlay
+/// or background is drawn over or under the chart with that proxy. The
+/// page reports no taps or drags on a chart, so a selection binding is
+/// never set by the viewer.
+
+/// Positions in a chart's plot, for overlays: unknown in the browser.
+public struct ChartProxy {
+    init() {}
+
+    /// Nil: the plot's geometry is the page's.
+    public func position<P: Plottable>(forX value: P) -> CGFloat? { nil }
+    public func position<P: Plottable>(forY value: P) -> CGFloat? { nil }
+    public func position<X: Plottable, Y: Plottable>(for value: (x: X, y: Y)) -> CGPoint? { nil }
+    public func value<P: Plottable>(atX position: CGFloat, as type: P.Type = P.self) -> P? { nil }
+    public func value<P: Plottable>(atY position: CGFloat, as type: P.Type = P.self) -> P? { nil }
+    public func value<X: Plottable, Y: Plottable>(at location: CGPoint, as type: (X, Y).Type = (X, Y).self) -> (X, Y)? { nil }
+    /// Nil: the plot's frame is the page's.
+    public var plotFrame: Anchor<CGRect>? { nil }
+    /// Zero.
+    public var plotSize: CGSize { .zero }
+}
+
+nonisolated extension View {
+    /// Draws `content` over the chart with a proxy (see the file comment).
+    public func chartOverlay<V: View>(alignment: Alignment = .center,
+                                      @ViewBuilder content: @escaping (ChartProxy) -> V) -> some View {
+        overlay(alignment: alignment) { content(ChartProxy()) }
+    }
+
+    /// Draws `content` under the chart with a proxy (see the file comment).
+    public func chartBackground<V: View>(alignment: Alignment = .center,
+                                         @ViewBuilder content: @escaping (ChartProxy) -> V) -> some View {
+        background(alignment: alignment) { content(ChartProxy()) }
+    }
+
+    /// Styles the chart's plot area with `content`. The page lays the plot
+    /// out inside the chart, so the plot is not a view of its own here:
+    /// `content` gets the whole chart (an overlay covers the axes too).
+    public func chartPlotStyle<Content: View>(@ViewBuilder content: @escaping (ChartPlotContent) -> Content) -> some View {
+        content(ChartPlotContent(content: AnyView(self)))
+    }
+
+    /// Accepted: the viewer cannot select a value on the page.
+    public func chartXSelection<P: Plottable>(value: Binding<P?>) -> some View { self }
+    public func chartXSelection<P: Plottable & Comparable>(range: Binding<ClosedRange<P>?>) -> some View { self }
+    public func chartYSelection<P: Plottable>(value: Binding<P?>) -> some View { self }
+    public func chartYSelection<P: Plottable & Comparable>(range: Binding<ClosedRange<P>?>) -> some View { self }
+}
+
+/// The plot area `chartPlotStyle` styles: here, the whole chart (see there).
+public struct ChartPlotContent: View {
+    let content: AnyView
+    public var body: some View { content }
+}