@swiftbrowser/swift 0.0.0-stage → 0.1.0

package/Sources/SwiftUI/API/Gauge.swift

@@ -0,0 +1,289 @@
+// Gauge and its styles, plus `labelsHidden()`. See docs/ops-protocol.md (Phase 6).
+
+// MARK: - Styles
+
+/// The appearance of a `Gauge`. The shim's styles are names the renderer draws;
+/// a custom conformance renders as `automatic`.
+public protocol GaugeStyle {}
+
+protocol _NamedGaugeStyle {
+    var _name: String { get }
+}
+
+public struct DefaultGaugeStyle: GaugeStyle, _NamedGaugeStyle, Sendable {
+    public init() {}
+    var _name: String { "automatic" }
+}
+
+public struct LinearCapacityGaugeStyle: GaugeStyle, _NamedGaugeStyle, Sendable {
+    public init() {}
+    var _name: String { "linearCapacity" }
+}
+
+public struct AccessoryLinearGaugeStyle: GaugeStyle, _NamedGaugeStyle, Sendable {
+    public init() {}
+    var _name: String { "accessoryLinear" }
+}
+
+public struct AccessoryCircularGaugeStyle: GaugeStyle, _NamedGaugeStyle, Sendable {
+    public init() {}
+    var _name: String { "accessoryCircular" }
+}
+
+public struct AccessoryCircularCapacityGaugeStyle: GaugeStyle, _NamedGaugeStyle, Sendable {
+    public init() {}
+    var _name: String { "accessoryCircularCapacity" }
+}
+
+extension GaugeStyle where Self == DefaultGaugeStyle {
+    public static var automatic: DefaultGaugeStyle { DefaultGaugeStyle() }
+}
+extension GaugeStyle where Self == LinearCapacityGaugeStyle {
+    public static var linearCapacity: LinearCapacityGaugeStyle { LinearCapacityGaugeStyle() }
+}
+extension GaugeStyle where Self == AccessoryLinearGaugeStyle {
+    public static var accessoryLinear: AccessoryLinearGaugeStyle { AccessoryLinearGaugeStyle() }
+}
+extension GaugeStyle where Self == AccessoryCircularGaugeStyle {
+    public static var accessoryCircular: AccessoryCircularGaugeStyle { AccessoryCircularGaugeStyle() }
+}
+extension GaugeStyle where Self == AccessoryCircularCapacityGaugeStyle {
+    public static var accessoryCircularCapacity: AccessoryCircularCapacityGaugeStyle { AccessoryCircularCapacityGaugeStyle() }
+}
+
+// MARK: - Environment
+
+enum _GaugeStyleKey: EnvironmentKey { static let defaultValue = "automatic" }
+enum _LabelsHiddenKey: EnvironmentKey { static let defaultValue = false }
+
+extension EnvironmentValues {
+    /// The name of the gauge style set by `.gaugeStyle(_:)`.
+    var gaugeStyle: String {
+        get { self[_GaugeStyleKey.self] }
+        set { self[_GaugeStyleKey.self] = newValue }
+    }
+
+    /// Set by `.labelsHidden()`: controls omit their label.
+    var labelsHidden: Bool {
+        get { self[_LabelsHiddenKey.self] }
+        set { self[_LabelsHiddenKey.self] = newValue }
+    }
+}
+
+extension View {
+    public func gaugeStyle<S: GaugeStyle>(_ style: S) -> some View {
+        environment(\.gaugeStyle, (style as? any _NamedGaugeStyle)?._name ?? "automatic")
+    }
+
+    /// Hides the labels of controls in this view (gauges, toggles, pickers).
+    public func labelsHidden() -> some View {
+        environment(\.labelsHidden, true)
+    }
+}
+
+// MARK: - Gauge
+
+/// Shows a value within a range. Kind `gauge`; the children are the label
+/// (unless `EmptyView` or hidden) followed by the current value label.
+public struct Gauge<Label: View, CurrentValueLabel: View, BoundsLabel: View, MarkedValueLabel: View> {
+    /// `value` normalized into 0…1 over `bounds`.
+    let normalizedValue: Double
+    let label: Label
+    let currentValueLabel: CurrentValueLabel
+
+    static func normalize<V: BinaryFloatingPoint>(_ value: V, in bounds: ClosedRange<V>) -> Double {
+        let lower = Double(bounds.lowerBound)
+        let upper = Double(bounds.upperBound)
+        guard upper > lower else { return 0 }
+        let fraction = (Double(value) - lower) / (upper - lower)
+        return max(0, min(1, fraction))
+    }
+}
+
+extension Gauge where CurrentValueLabel == EmptyView, BoundsLabel == EmptyView, MarkedValueLabel == EmptyView {
+    public init<V: BinaryFloatingPoint>(value: V, in bounds: ClosedRange<V> = 0...1,
+                                        @ViewBuilder label: () -> Label) {
+        normalizedValue = Self.normalize(value, in: bounds)
+        self.label = label()
+        currentValueLabel = EmptyView()
+    }
+}
+
+extension Gauge where BoundsLabel == EmptyView, MarkedValueLabel == EmptyView {
+    public init<V: BinaryFloatingPoint>(value: V, in bounds: ClosedRange<V> = 0...1,
+                                        @ViewBuilder label: () -> Label,
+                                        @ViewBuilder currentValueLabel: () -> CurrentValueLabel) {
+        normalizedValue = Self.normalize(value, in: bounds)
+        self.label = label()
+        self.currentValueLabel = currentValueLabel()
+    }
+}
+
+extension Gauge where MarkedValueLabel == EmptyView {
+    /// Bounds labels are accepted for source compatibility and not rendered.
+    public init<V: BinaryFloatingPoint>(value: V, in bounds: ClosedRange<V> = 0...1,
+                                        @ViewBuilder label: () -> Label,
+                                        @ViewBuilder currentValueLabel: () -> CurrentValueLabel,
+                                        @ViewBuilder minimumValueLabel: () -> BoundsLabel,
+                                        @ViewBuilder maximumValueLabel: () -> BoundsLabel) {
+        normalizedValue = Self.normalize(value, in: bounds)
+        self.label = label()
+        self.currentValueLabel = currentValueLabel()
+    }
+}
+
+extension Gauge: _PrimitiveView {}
+extension Gauge: _HostView {
+    var _kind: String { "gauge" }
+
+    private var hasCurrentValueLabel: Bool { !(CurrentValueLabel.self is EmptyView.Type) }
+
+    private func hasLabel(in environment: EnvironmentValues) -> Bool {
+        !(Label.self is EmptyView.Type) && !environment.labelsHidden
+    }
+
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object([
+            "value": .number(normalizedValue),
+            "style": .string(environment.gaugeStyle),
+            "hasLabel": .bool(hasLabel(in: environment)),
+            "hasCurrentValueLabel": .bool(hasCurrentValueLabel),
+        ])
+    }
+
+    var _content: [any View] {
+        // `_content` has no environment, so the label goes through a group
+        // that reads `labelsHidden` itself and drops the label when set.
+        var children: [any View] = []
+        if !(Label.self is EmptyView.Type) { children.append(_GaugeLabel(label: label)) }
+        if hasCurrentValueLabel { children.append(currentValueLabel) }
+        return children
+    }
+}
+
+// MARK: - ProgressView
+
+/// Progress toward a total. A determinate progress view draws as a
+/// `linearCapacity` gauge with its label; an indeterminate one (no value)
+/// has no spinner in the protocol and shows its label, or an hourglass
+/// symbol when it has none.
+public struct ProgressView<Label: View, CurrentValueLabel: View>: View {
+    /// Progress in 0…1, nil when indeterminate.
+    let fraction: Double?
+    let label: Label?
+    let currentValueLabel: CurrentValueLabel?
+
+    public var body: some View {
+        if let fraction {
+            Gauge(value: fraction, in: 0...1) {
+                if let label { label }
+            } currentValueLabel: {
+                if let currentValueLabel { currentValueLabel }
+            }
+            .gaugeStyle(.linearCapacity)
+        } else if let label {
+            label.foregroundStyle(.secondary)
+        } else {
+            Image(systemName: "hourglass").foregroundStyle(.secondary)
+        }
+    }
+
+    static func fraction<V: BinaryFloatingPoint>(_ value: V?, total: V) -> Double? {
+        guard let value, total > 0 else { return nil }
+        return max(0, min(1, Double(value) / Double(total)))
+    }
+}
+
+extension ProgressView where Label == EmptyView, CurrentValueLabel == EmptyView {
+    public init() {
+        fraction = nil
+        label = nil
+        currentValueLabel = nil
+    }
+
+    public init<V: BinaryFloatingPoint>(value: V?, total: V = 1.0) {
+        fraction = Self.fraction(value, total: total)
+        label = nil
+        currentValueLabel = nil
+    }
+}
+
+extension ProgressView where Label == Text, CurrentValueLabel == EmptyView {
+    public init<S: StringProtocol>(_ title: S) {
+        fraction = nil
+        label = Text(title)
+        currentValueLabel = nil
+    }
+
+    public init(_ titleKey: LocalizedStringKey) {
+        fraction = nil
+        label = Text(titleKey)
+        currentValueLabel = nil
+    }
+
+    public init<S: StringProtocol, V: BinaryFloatingPoint>(_ title: S, value: V?, total: V = 1.0) {
+        fraction = Self.fraction(value, total: total)
+        label = Text(title)
+        currentValueLabel = nil
+    }
+
+    public init<V: BinaryFloatingPoint>(_ titleKey: LocalizedStringKey, value: V?, total: V = 1.0) {
+        fraction = Self.fraction(value, total: total)
+        label = Text(titleKey)
+        currentValueLabel = nil
+    }
+}
+
+extension ProgressView where CurrentValueLabel == EmptyView {
+    public init(@ViewBuilder label: () -> Label) {
+        fraction = nil
+        self.label = label()
+        currentValueLabel = nil
+    }
+
+    public init<V: BinaryFloatingPoint>(value: V?, total: V = 1.0, @ViewBuilder label: () -> Label) {
+        fraction = Self.fraction(value, total: total)
+        self.label = label()
+        currentValueLabel = nil
+    }
+}
+
+extension ProgressView {
+    public init<V: BinaryFloatingPoint>(value: V?, total: V = 1.0, @ViewBuilder label: () -> Label,
+                                        @ViewBuilder currentValueLabel: () -> CurrentValueLabel) {
+        fraction = Self.fraction(value, total: total)
+        self.label = label()
+        self.currentValueLabel = currentValueLabel()
+    }
+}
+
+/// `.progressViewStyle`: accepted for source compatibility.
+public protocol ProgressViewStyle {}
+public struct DefaultProgressViewStyle: ProgressViewStyle { public init() {} }
+public struct LinearProgressViewStyle: ProgressViewStyle { public init() {} }
+public struct CircularProgressViewStyle: ProgressViewStyle { public init() {} }
+extension ProgressViewStyle where Self == DefaultProgressViewStyle {
+    public static var automatic: DefaultProgressViewStyle { DefaultProgressViewStyle() }
+}
+extension ProgressViewStyle where Self == LinearProgressViewStyle {
+    public static var linear: LinearProgressViewStyle { LinearProgressViewStyle() }
+}
+extension ProgressViewStyle where Self == CircularProgressViewStyle {
+    public static var circular: CircularProgressViewStyle { CircularProgressViewStyle() }
+}
+
+extension View {
+    public func progressViewStyle<S: ProgressViewStyle>(_ style: S) -> some View { self }
+}
+
+/// Contributes the gauge's label unless `labelsHidden` is set in the environment.
+struct _GaugeLabel<Label: View> {
+    let label: Label
+    @Environment(\.labelsHidden) private var labelsHidden
+
+    init(label: Label) { self.label = label }
+}
+extension _GaugeLabel: _PrimitiveView {}
+extension _GaugeLabel: _GroupView {
+    var _children: [any View] { labelsHidden ? [] : [label] }
+}

package/Sources/SwiftUI/API/Geometry.swift

@@ -0,0 +1,89 @@
+/// SwiftUI vends `CGFloat` through CoreGraphics. The shim provides its own
+/// alias and geometry types and never imports Foundation (that would link its
+/// 10 MB and ICU into every lean app). An app that also imports Foundation
+/// gets both declarations; the CLI's generated `_SwiftBrowserFoundation.swift`
+/// settles them with typealiases on the shim's (docs/ops-protocol.md, "Phase 11").
+public typealias CGFloat = Double
+
+public enum Edge: Int8, CaseIterable, Hashable, Sendable {
+    case top, leading, bottom, trailing
+
+    public struct Set: OptionSet, Sendable {
+        public let rawValue: Int8
+        public init(rawValue: Int8) { self.rawValue = rawValue }
+
+        public static let top = Set(rawValue: 1 << 0)
+        public static let leading = Set(rawValue: 1 << 1)
+        public static let bottom = Set(rawValue: 1 << 2)
+        public static let trailing = Set(rawValue: 1 << 3)
+        public static let horizontal: Set = [.leading, .trailing]
+        public static let vertical: Set = [.top, .bottom]
+        public static let all: Set = [.top, .leading, .bottom, .trailing]
+    }
+}
+
+public struct EdgeInsets: Equatable, Sendable {
+    public var top: CGFloat
+    public var leading: CGFloat
+    public var bottom: CGFloat
+    public var trailing: CGFloat
+
+    public init(top: CGFloat, leading: CGFloat, bottom: CGFloat, trailing: CGFloat) {
+        self.top = top
+        self.leading = leading
+        self.bottom = bottom
+        self.trailing = trailing
+    }
+
+    public init() { self.init(top: 0, leading: 0, bottom: 0, trailing: 0) }
+
+    var _json: _JSON {
+        .object(["top": .number(top), "leading": .number(leading),
+                 "bottom": .number(bottom), "trailing": .number(trailing)])
+    }
+}
+
+public struct HorizontalAlignment: Equatable, Sendable {
+    let name: String
+    public static let leading = HorizontalAlignment(name: "leading")
+    public static let center = HorizontalAlignment(name: "center")
+    public static let trailing = HorizontalAlignment(name: "trailing")
+}
+
+public struct VerticalAlignment: Equatable, Sendable {
+    let name: String
+    public static let top = VerticalAlignment(name: "top")
+    public static let center = VerticalAlignment(name: "center")
+    public static let bottom = VerticalAlignment(name: "bottom")
+    /// Baseline alignment is approximated as `center` by the renderer.
+    public static let firstTextBaseline = VerticalAlignment(name: "center")
+    public static let lastTextBaseline = VerticalAlignment(name: "center")
+}
+
+public struct Alignment: Equatable, Sendable {
+    public var horizontal: HorizontalAlignment
+    public var vertical: VerticalAlignment
+
+    public init(horizontal: HorizontalAlignment, vertical: VerticalAlignment) {
+        self.horizontal = horizontal
+        self.vertical = vertical
+    }
+
+    public static let center = Alignment(horizontal: .center, vertical: .center)
+    public static let leading = Alignment(horizontal: .leading, vertical: .center)
+    public static let trailing = Alignment(horizontal: .trailing, vertical: .center)
+    public static let top = Alignment(horizontal: .center, vertical: .top)
+    public static let bottom = Alignment(horizontal: .center, vertical: .bottom)
+    public static let topLeading = Alignment(horizontal: .leading, vertical: .top)
+    public static let topTrailing = Alignment(horizontal: .trailing, vertical: .top)
+    public static let bottomLeading = Alignment(horizontal: .leading, vertical: .bottom)
+    public static let bottomTrailing = Alignment(horizontal: .trailing, vertical: .bottom)
+
+    var _name: String {
+        switch (vertical.name, horizontal.name) {
+        case ("center", let h): h
+        case (let v, "center"): v
+        case (let v, let h): v + h.prefix(1).uppercased() + h.dropFirst()
+        }
+    }
+}

package/Sources/SwiftUI/API/GeometryReader.swift

@@ -0,0 +1,124 @@
+// CoreGraphics types, provided by the shim because browser builds have no
+// Foundation (see Geometry.swift).
+
+public struct CGPoint: Equatable, Hashable, Sendable {
+    public var x: CGFloat
+    public var y: CGFloat
+    public init(x: CGFloat, y: CGFloat) { self.x = x; self.y = y }
+    public init() { self.init(x: 0, y: 0) }
+    public static let zero = CGPoint()
+}
+
+/// A normalized point in a view's bounds; `(0, 0)` is top leading.
+public struct UnitPoint: Equatable, Hashable, Sendable {
+    public var x: CGFloat
+    public var y: CGFloat
+
+    public init(x: CGFloat, y: CGFloat) {
+        self.x = x
+        self.y = y
+    }
+
+    public init() { self.init(x: 0, y: 0) }
+
+    public static let zero = UnitPoint(x: 0, y: 0)
+    public static let center = UnitPoint(x: 0.5, y: 0.5)
+    public static let leading = UnitPoint(x: 0, y: 0.5)
+    public static let trailing = UnitPoint(x: 1, y: 0.5)
+    public static let top = UnitPoint(x: 0.5, y: 0)
+    public static let bottom = UnitPoint(x: 0.5, y: 1)
+    public static let topLeading = UnitPoint(x: 0, y: 0)
+    public static let topTrailing = UnitPoint(x: 1, y: 0)
+    public static let bottomLeading = UnitPoint(x: 0, y: 1)
+    public static let bottomTrailing = UnitPoint(x: 1, y: 1)
+}
+
+public struct CGSize: Equatable, Hashable, Sendable {
+    public var width: CGFloat
+    public var height: CGFloat
+    public init(width: CGFloat, height: CGFloat) { self.width = width; self.height = height }
+    public init() { self.init(width: 0, height: 0) }
+    public static let zero = CGSize()
+}
+
+public struct CGRect: Equatable, Hashable, Sendable {
+    public var origin: CGPoint
+    public var size: CGSize
+    public init(origin: CGPoint, size: CGSize) { self.origin = origin; self.size = size }
+    public init(x: CGFloat, y: CGFloat, width: CGFloat, height: CGFloat) {
+        self.init(origin: CGPoint(x: x, y: y), size: CGSize(width: width, height: height))
+    }
+    public init() { self.init(origin: .zero, size: .zero) }
+    public static let zero = CGRect()
+    public var minX: CGFloat { origin.x }
+    public var minY: CGFloat { origin.y }
+    public var midX: CGFloat { origin.x + size.width / 2 }
+    public var midY: CGFloat { origin.y + size.height / 2 }
+    public var maxX: CGFloat { origin.x + size.width }
+    public var maxY: CGFloat { origin.y + size.height }
+    public var width: CGFloat { size.width }
+    public var height: CGFloat { size.height }
+    public var isEmpty: Bool { size.width <= 0 || size.height <= 0 }
+
+    /// Shrinks the rectangle by `dx` on each horizontal side and `dy` on each vertical side.
+    public func insetBy(dx: CGFloat, dy: CGFloat) -> CGRect {
+        CGRect(x: origin.x + dx, y: origin.y + dy, width: size.width - 2 * dx, height: size.height - 2 * dy)
+    }
+
+    public func offsetBy(dx: CGFloat, dy: CGFloat) -> CGRect {
+        CGRect(origin: CGPoint(x: origin.x + dx, y: origin.y + dy), size: size)
+    }
+
+    public func contains(_ point: CGPoint) -> Bool {
+        point.x >= minX && point.x < maxX && point.y >= minY && point.y < maxY
+    }
+}
+
+/// The size the renderer laid a `GeometryReader` out at.
+public struct GeometryProxy {
+    public let size: CGSize
+
+    public func frame(in coordinateSpace: CoordinateSpace) -> CGRect {
+        CGRect(origin: .zero, size: size)
+    }
+}
+
+public enum CoordinateSpace: Hashable {
+    case global, local
+    case named(AnyHashable)
+
+    public var isGlobal: Bool { self == .global }
+    public var isLocal: Bool { self == .local }
+}
+/// `AnyHashable` is not `Sendable`; names are value types in practice.
+extension CoordinateSpace: @unchecked Sendable {}
+
+extension View {
+    /// Names a coordinate space; accepted for source compatibility (geometry
+    /// is always reported in the view's own box).
+    public func coordinateSpace<T: Hashable>(name: T) -> some View { self }
+}
+
+protocol _GeometryReading {
+    func _content(for size: CGSize) -> any View
+}
+
+/// A container that reports its size to its content. The size arrives from
+/// the renderer after layout, so the content renders once at zero size and
+/// again with the real size.
+public struct GeometryReader<Content: View> {
+    let content: (GeometryProxy) -> Content
+
+    public init(@ViewBuilder content: @escaping (GeometryProxy) -> Content) {
+        self.content = content
+    }
+}
+extension GeometryReader: _PrimitiveView {}
+extension GeometryReader: _HostView {
+    var _kind: String { "geometry" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object([:]) }
+    // The runtime produces the content from the last reported size.
+}
+extension GeometryReader: _GeometryReading {
+    func _content(for size: CGSize) -> any View { content(GeometryProxy(size: size)) }
+}