@swiftbrowser/swift 0.0.0-stage → 0.1.0

package/Sources/SwiftUI/API/VisualEffect.swift

@@ -0,0 +1,82 @@
+/// `.visualEffect { content, proxy in … }` (docs/ops-protocol.md, "Phase 12").
+/// The closure's effects (offset, scale, rotation, opacity, blur, …) apply as
+/// the matching view modifiers. The proxy is empty: the browser does not
+/// report a view's frame on every scroll step, so an effect that reads
+/// `proxy.frame(in: .global)` sees a zero rectangle and the view renders
+/// without that part of the effect. Compile-level support, honestly limited.
+
+public protocol VisualEffect {}
+
+/// The chained effects, as style changes on the content.
+protocol _VisualEffectChaining {
+    var _effects: [(inout _Style) -> Void] { get }
+}
+
+public struct EmptyVisualEffect: VisualEffect, _VisualEffectChaining {
+    var _effects: [(inout _Style) -> Void] { [] }
+    public init() {}
+}
+
+public struct _VisualEffectChain: VisualEffect, _VisualEffectChaining {
+    var _effects: [(inout _Style) -> Void]
+}
+
+extension VisualEffect {
+    func _adding(_ effect: @escaping (inout _Style) -> Void) -> _VisualEffectChain {
+        _VisualEffectChain(_effects: ((self as? _VisualEffectChaining)?._effects ?? []) + [effect])
+    }
+
+    public func offset(x: CGFloat = 0, y: CGFloat = 0) -> _VisualEffectChain {
+        _adding { $0.extras["offset"] = .object(["x": .number(x), "y": .number(y)]) }
+    }
+    public func offset(_ offset: CGSize) -> _VisualEffectChain { self.offset(x: offset.width, y: offset.height) }
+    public func scaleEffect(_ scale: CGFloat, anchor: UnitPoint = .center) -> _VisualEffectChain {
+        scaleEffect(x: scale, y: scale, anchor: anchor)
+    }
+    public func scaleEffect(_ scale: CGSize, anchor: UnitPoint = .center) -> _VisualEffectChain {
+        scaleEffect(x: scale.width, y: scale.height, anchor: anchor)
+    }
+    public func scaleEffect(x: CGFloat = 1, y: CGFloat = 1, anchor: UnitPoint = .center) -> _VisualEffectChain {
+        _adding {
+            $0.extras["scale"] = .object(["x": .number(x), "y": .number(y)])
+            $0.extras["scaleAnchor"] = anchor._json
+        }
+    }
+    public func rotationEffect(_ angle: Angle, anchor: UnitPoint = .center) -> _VisualEffectChain {
+        _adding {
+            $0.extras["rotation"] = .number(angle.degrees)
+            $0.extras["rotationAnchor"] = anchor._json
+        }
+    }
+    public func rotation3DEffect(_ angle: Angle, axis: (x: CGFloat, y: CGFloat, z: CGFloat),
+                                 anchor: UnitPoint = .center, anchorZ: CGFloat = 0,
+                                 perspective: CGFloat = 1) -> _VisualEffectChain {
+        _adding {
+            $0.extras["rotation3D"] = .object([
+                "angle": .number(angle.degrees),
+                "axis": .object(["x": .number(axis.x), "y": .number(axis.y), "z": .number(axis.z)]),
+                "anchor": anchor._json,
+                "perspective": .number(perspective),
+            ])
+        }
+    }
+    public func opacity(_ opacity: Double) -> _VisualEffectChain { _adding { $0.opacity = opacity } }
+    public func blur(radius: CGFloat, opaque: Bool = false) -> _VisualEffectChain { _adding { $0.extras["blur"] = .number(radius) } }
+    /// Accepted; the renderer has no filter for these yet.
+    public func brightness(_ amount: Double) -> _VisualEffectChain { _adding { _ in } }
+    public func contrast(_ amount: Double) -> _VisualEffectChain { _adding { _ in } }
+    public func saturation(_ amount: Double) -> _VisualEffectChain { _adding { _ in } }
+    public func grayscale(_ amount: Double) -> _VisualEffectChain { _adding { _ in } }
+    public func hueRotation(_ angle: Angle) -> _VisualEffectChain { _adding { _ in } }
+    public func colorEffect<S: ShapeStyle>(_ shader: S) -> _VisualEffectChain { _adding { _ in } }
+}
+
+extension View {
+    public func visualEffect(_ effect: @escaping (EmptyVisualEffect, GeometryProxy) -> some VisualEffect) -> some View {
+        let result = effect(EmptyVisualEffect(), GeometryProxy(size: .zero))
+        let effects = (result as? _VisualEffectChaining)?._effects ?? []
+        return _styled { style in
+            for apply in effects { apply(&style) }
+        }
+    }
+}

package/Sources/SwiftUI/Charts/Axis.swift

@@ -0,0 +1,319 @@
+// 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)
+}
+
+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())
+    }
+
+    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 }
+    }
+}
+
+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 }
+    }
+}