@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/API/Font.swift

@@ -0,0 +1,131 @@
+public struct Font: Hashable, Sendable {
+    public struct Weight: Hashable, Sendable {
+        let name: String
+        public static let ultraLight = Weight(name: "ultraLight")
+        public static let thin = Weight(name: "thin")
+        public static let light = Weight(name: "light")
+        public static let regular = Weight(name: "regular")
+        public static let medium = Weight(name: "medium")
+        public static let semibold = Weight(name: "semibold")
+        public static let bold = Weight(name: "bold")
+        public static let heavy = Weight(name: "heavy")
+        public static let black = Weight(name: "black")
+    }
+
+    public enum Design: Hashable, Sendable {
+        case `default`, serif, rounded, monospaced
+
+        var name: String {
+            switch self {
+            case .default: "default"
+            case .serif: "serif"
+            case .rounded: "rounded"
+            case .monospaced: "monospaced"
+            }
+        }
+    }
+
+    public enum TextStyle: Hashable, Sendable, CaseIterable {
+        case largeTitle, title, title2, title3, headline, subheadline
+        case body, callout, footnote, caption, caption2
+
+        var name: String {
+            switch self {
+            case .largeTitle: "largeTitle"
+            case .title: "title"
+            case .title2: "title2"
+            case .title3: "title3"
+            case .headline: "headline"
+            case .subheadline: "subheadline"
+            case .body: "body"
+            case .callout: "callout"
+            case .footnote: "footnote"
+            case .caption: "caption"
+            case .caption2: "caption2"
+            }
+        }
+    }
+
+    /// Either a text style (scaled by Dynamic Type in the renderer) or a fixed size.
+    var textStyle: TextStyle?
+    var size: CGFloat?
+    var relativeTo: TextStyle?
+    var weight: Weight?
+    var design: Design?
+
+    public static let largeTitle = Font(textStyle: .largeTitle)
+    public static let title = Font(textStyle: .title)
+    public static let title2 = Font(textStyle: .title2)
+    public static let title3 = Font(textStyle: .title3)
+    public static let headline = Font(textStyle: .headline)
+    public static let subheadline = Font(textStyle: .subheadline)
+    public static let body = Font(textStyle: .body)
+    public static let callout = Font(textStyle: .callout)
+    public static let footnote = Font(textStyle: .footnote)
+    public static let caption = Font(textStyle: .caption)
+    public static let caption2 = Font(textStyle: .caption2)
+
+    init(textStyle: TextStyle) {
+        self.textStyle = textStyle
+    }
+
+    init(size: CGFloat?, weight: Weight?, design: Design?) {
+        self.size = size
+        self.weight = weight
+        self.design = design
+    }
+
+    public static func system(_ style: TextStyle, design: Design? = nil, weight: Weight? = nil) -> Font {
+        var font = Font(textStyle: style)
+        font.weight = weight
+        font.design = design
+        return font
+    }
+
+    public static func system(size: CGFloat, weight: Weight? = nil, design: Design? = nil) -> Font {
+        Font(size: size, weight: weight, design: design)
+    }
+
+    /// A custom font. The browser cannot load app fonts, so the name is
+    /// accepted for source compatibility and the system font is used.
+    public static func custom(_ name: String, size: CGFloat) -> Font {
+        var font = Font(size: size, weight: nil, design: nil)
+        font.relativeTo = .body
+        return font
+    }
+
+    /// A custom font whose size scales with Dynamic Type like `textStyle`.
+    public static func custom(_ name: String, size: CGFloat, relativeTo textStyle: TextStyle) -> Font {
+        var font = Font(size: size, weight: nil, design: nil)
+        font.relativeTo = textStyle
+        return font
+    }
+
+    /// A custom font at a fixed size that does not scale.
+    public static func custom(_ name: String, fixedSize: CGFloat) -> Font {
+        Font(size: fixedSize, weight: nil, design: nil)
+    }
+
+    public func weight(_ weight: Weight) -> Font {
+        var copy = self
+        copy.weight = weight
+        return copy
+    }
+
+    public func bold() -> Font { weight(.bold) }
+    public func monospaced() -> Font {
+        var copy = self
+        copy.design = .monospaced
+        return copy
+    }
+
+    var _json: _JSON {
+        var object: [String: _JSON] = [:]
+        if let textStyle { object["textStyle"] = .string(textStyle.name) }
+        if let size { object["size"] = .number(size) }
+        if let relativeTo { object["relativeTo"] = .string(relativeTo.name) }
+        if let weight { object["weight"] = .string(weight.name) }
+        if let design { object["design"] = .string(design.name) }
+        return .object(object)
+    }
+}

package/Sources/SwiftUI/API/Gauge.swift

@@ -0,0 +1,290 @@
+// 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 }
+    }
+}
+
+nonisolated 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 {
+    @_disfavoredOverload
+    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() }
+}
+
+nonisolated 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()
+        }
+    }
+}