@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/API/StackLayouts.swift

@@ -0,0 +1,199 @@
+/// `VStackLayout`, `HStackLayout`, `ZStackLayout` and `AnyLayout` (iOS 16):
+/// the stacks as `Layout` values, so that a view can switch its layout
+/// (`let layout = isCompact ? AnyLayout(VStackLayout()) : AnyLayout(HStackLayout())`).
+///
+/// Used as a container (`VStackLayout(spacing: 0) { … }`), a stack layout is
+/// the stack itself: the same `vstack` / `hstack` / `zstack` element, laid out
+/// by the page. `AnyLayout` does the same for a stack it wraps, and is a
+/// custom `layout` element (Phase 6) for any other layout. Switching an
+/// `AnyLayout` between kinds rebuilds its content (approximation: SwiftUI
+/// keeps the children's state and animates them to their new places).
+///
+/// Their `Layout` methods compute the stacks in Swift too, for a custom
+/// layout that delegates to one: subviews get the proposal (a vertical
+/// stack's height and a horizontal stack's width shared evenly), are placed
+/// one after the other `spacing` apart (8 by default) and aligned across
+/// the axis.
+
+public struct VStackLayout: Layout {
+    public var alignment: HorizontalAlignment
+    public var spacing: CGFloat?
+
+    public init(alignment: HorizontalAlignment = .center, spacing: CGFloat? = nil) {
+        self.alignment = alignment
+        self.spacing = spacing
+    }
+
+    public static var layoutProperties: LayoutProperties {
+        var properties = LayoutProperties()
+        properties.stackOrientation = .vertical
+        return properties
+    }
+
+    public func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
+        let sizes = _stackSizes(subviews, proposal: proposal, vertical: true)
+        let gap = spacing ?? 8
+        return CGSize(width: sizes.map(\.width).max() ?? 0,
+                      height: sizes.map(\.height).reduce(0, +) + gap * CGFloat(max(0, sizes.count - 1)))
+    }
+
+    public func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
+        let sizes = _stackSizes(subviews, proposal: proposal, vertical: true)
+        var y = bounds.minY
+        for (subview, size) in zip(subviews, sizes) {
+            let x: CGFloat = switch alignment.name {
+            case "leading": bounds.minX
+            case "trailing": bounds.maxX - size.width
+            default: bounds.midX - size.width / 2
+            }
+            subview.place(at: CGPoint(x: x, y: y), anchor: .topLeading, proposal: ProposedViewSize(size))
+            y += size.height + (spacing ?? 8)
+        }
+    }
+
+    /// The stack itself: a `VStack` of the content.
+    public func callAsFunction<V: View>(@ViewBuilder _ content: () -> V) -> some View {
+        VStack(alignment: alignment, spacing: spacing, content: content)
+    }
+}
+
+public struct HStackLayout: Layout {
+    public var alignment: VerticalAlignment
+    public var spacing: CGFloat?
+
+    public init(alignment: VerticalAlignment = .center, spacing: CGFloat? = nil) {
+        self.alignment = alignment
+        self.spacing = spacing
+    }
+
+    public static var layoutProperties: LayoutProperties {
+        var properties = LayoutProperties()
+        properties.stackOrientation = .horizontal
+        return properties
+    }
+
+    public func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
+        let sizes = _stackSizes(subviews, proposal: proposal, vertical: false)
+        let gap = spacing ?? 8
+        return CGSize(width: sizes.map(\.width).reduce(0, +) + gap * CGFloat(max(0, sizes.count - 1)),
+                      height: sizes.map(\.height).max() ?? 0)
+    }
+
+    public func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
+        let sizes = _stackSizes(subviews, proposal: proposal, vertical: false)
+        var x = bounds.minX
+        for (subview, size) in zip(subviews, sizes) {
+            let y: CGFloat = switch alignment.name {
+            case "top": bounds.minY
+            case "bottom": bounds.maxY - size.height
+            default: bounds.midY - size.height / 2
+            }
+            subview.place(at: CGPoint(x: x, y: y), anchor: .topLeading, proposal: ProposedViewSize(size))
+            x += size.width + (spacing ?? 8)
+        }
+    }
+
+    /// The stack itself: an `HStack` of the content.
+    public func callAsFunction<V: View>(@ViewBuilder _ content: () -> V) -> some View {
+        HStack(alignment: alignment, spacing: spacing, content: content)
+    }
+}
+
+public struct ZStackLayout: Layout {
+    public var alignment: Alignment
+
+    public init(alignment: Alignment = .center) {
+        self.alignment = alignment
+    }
+
+    public func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
+        let sizes = subviews.map { $0.sizeThatFits(proposal) }
+        return CGSize(width: sizes.map(\.width).max() ?? 0, height: sizes.map(\.height).max() ?? 0)
+    }
+
+    public func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
+        for subview in subviews {
+            let size = subview.sizeThatFits(proposal)
+            let x: CGFloat = switch alignment.horizontal.name {
+            case "leading": bounds.minX
+            case "trailing": bounds.maxX - size.width
+            default: bounds.midX - size.width / 2
+            }
+            let y: CGFloat = switch alignment.vertical.name {
+            case "top": bounds.minY
+            case "bottom": bounds.maxY - size.height
+            default: bounds.midY - size.height / 2
+            }
+            subview.place(at: CGPoint(x: x, y: y), anchor: .topLeading, proposal: ProposedViewSize(size))
+        }
+    }
+
+    /// The stack itself: a `ZStack` of the content.
+    public func callAsFunction<V: View>(@ViewBuilder _ content: () -> V) -> some View {
+        ZStack(alignment: alignment, content: content)
+    }
+}
+
+/// Each subview's size along a stack: the proposal's length along the axis
+/// shared evenly, the full proposal across it.
+func _stackSizes(_ subviews: LayoutSubviews, proposal: ProposedViewSize, vertical: Bool) -> [CGSize] {
+    let count = CGFloat(max(1, subviews.count))
+    let share: ProposedViewSize = vertical
+        ? ProposedViewSize(width: proposal.width, height: proposal.height.map { $0 / count })
+        : ProposedViewSize(width: proposal.width.map { $0 / count }, height: proposal.height)
+    return subviews.map { $0.sizeThatFits(share) }
+}
+
+/// A layout chosen at run time.
+public struct AnyLayout: Layout {
+    let base: any Layout
+
+    public init<L: Layout>(_ layout: L) {
+        if let any = layout as? AnyLayout { base = any.base } else { base = layout }
+    }
+
+    public typealias Cache = _AnyLayoutCache
+
+    public static var layoutProperties: LayoutProperties { LayoutProperties() }
+
+    public func makeCache(subviews: Subviews) -> Cache {
+        func make<L: Layout>(_ layout: L) -> Any { layout.makeCache(subviews: subviews) }
+        return _AnyLayoutCache(value: make(base))
+    }
+
+    public func updateCache(_ cache: inout Cache, subviews: Subviews) {
+        cache = makeCache(subviews: subviews)
+    }
+
+    public func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout Cache) -> CGSize {
+        func size<L: Layout>(_ layout: L) -> CGSize {
+            var typed = cache.value as! L.Cache
+            defer { cache.value = typed }
+            return layout.sizeThatFits(proposal: proposal, subviews: subviews, cache: &typed)
+        }
+        return size(base)
+    }
+
+    public func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout Cache) {
+        func place<L: Layout>(_ layout: L) {
+            var typed = cache.value as! L.Cache
+            layout.placeSubviews(in: bounds, proposal: proposal, subviews: subviews, cache: &typed)
+            cache.value = typed
+        }
+        place(base)
+    }
+
+    /// The wrapped stack's own element for a stack layout, else a `layout` element.
+    public func callAsFunction<V: View>(@ViewBuilder _ content: () -> V) -> some View {
+        let content = content()
+        if let stack = base as? VStackLayout { return AnyView(stack { content }) }
+        if let stack = base as? HStackLayout { return AnyView(stack { content }) }
+        if let stack = base as? ZStackLayout { return AnyView(stack { content }) }
+        return AnyView(_LayoutView(layout: self, content: content))
+    }
+}
+
+/// `AnyLayout`'s cache: the wrapped layout's.
+public struct _AnyLayoutCache {
+    var value: Any
+}

package/Sources/SwiftUI/API/State.swift

@@ -0,0 +1,144 @@
+/// Marker protocol matching SwiftUI's, so user code that constrains on it compiles.
+public protocol DynamicProperty {
+    mutating func update()
+}
+
+extension DynamicProperty {
+    public mutating func update() {}
+}
+
+/// Type-erased access to a `State` box, used by the runtime to carry storage
+/// across re-renders and to observe mutations.
+protocol _AnyStateBox: AnyObject {
+    var _anyValue: Any { get set }
+    var _onChange: (() -> Void)? { get set }
+    /// Shares the persistent storage of a box from a previous render, so that
+    /// closures captured earlier keep writing to the live value.
+    func _adopt(_ previous: any _AnyStateBox)
+}
+
+/// Views expose their `State` properties to the runtime through this protocol.
+protocol _StateProperty: _RuntimeProperty {
+    var _box: any _AnyStateBox { get }
+}
+
+/// The persistent value behind a `State`; survives the view struct being
+/// recreated because every box for the same mounted view shares it.
+final class _StateStorage<Value> {
+    var value: Value {
+        didSet { onChange?() }
+    }
+    var onChange: (() -> Void)?
+
+    init(_ value: Value) { self.value = value }
+}
+
+final class _StateBox<Value>: _AnyStateBox {
+    var storage: _StateStorage<Value>
+
+    var value: Value {
+        get { storage.value }
+        set { storage.value = newValue }
+    }
+
+    var _onChange: (() -> Void)? {
+        get { storage.onChange }
+        set { storage.onChange = newValue }
+    }
+
+    init(_ value: Value) { storage = _StateStorage(value) }
+
+    var _anyValue: Any {
+        get { storage.value }
+        set { storage.value = newValue as! Value }
+    }
+
+    func _adopt(_ previous: any _AnyStateBox) {
+        guard let previous = previous as? _StateBox<Value> else { return }
+        storage = previous.storage
+    }
+}
+
+/// A property wrapper that reads and writes a value managed by the runtime.
+///
+/// A view struct is recreated every time its parent's body runs; the runtime
+/// finds `State` properties by reflection and moves the previous values into
+/// the new struct, so the value persists for as long as the view stays mounted.
+@propertyWrapper
+public struct State<Value>: DynamicProperty {
+    let box: _StateBox<Value>
+
+    public init(wrappedValue: Value) {
+        box = _StateBox(wrappedValue)
+    }
+
+    public init(initialValue: Value) {
+        self.init(wrappedValue: initialValue)
+    }
+
+    public var wrappedValue: Value {
+        get { box.value }
+        nonmutating set { box.value = newValue }
+    }
+
+    public var projectedValue: Binding<Value> {
+        let box = self.box
+        return Binding(get: { box.value }, set: { box.value = $0 })
+    }
+}
+
+extension State where Value: ExpressibleByNilLiteral {
+    public init() { self.init(wrappedValue: nil) }
+}
+
+extension State: _StateProperty {
+    var _box: any _AnyStateBox { box }
+}
+
+/// A two-way connection to a value owned elsewhere.
+@propertyWrapper
+@dynamicMemberLookup
+public struct Binding<Value>: DynamicProperty {
+    let getter: () -> Value
+    let setter: (Value) -> Void
+    /// What the binding points at, for a binding the runtime re-creates on
+    /// every pass (a node's edit mode); nil for every other binding, which
+    /// then never compares equal (see `_Sameness`).
+    let identity: _RuntimeKey?
+
+    public init(get: @escaping () -> Value, set: @escaping (Value) -> Void) {
+        getter = get
+        setter = set
+        identity = nil
+    }
+
+    init(identity: _RuntimeKey, get: @escaping () -> Value, set: @escaping (Value) -> Void) {
+        getter = get
+        setter = set
+        self.identity = identity
+    }
+
+    public static func constant(_ value: Value) -> Binding<Value> {
+        Binding(get: { value }, set: { _ in })
+    }
+
+    public var wrappedValue: Value {
+        get { getter() }
+        nonmutating set { setter(newValue) }
+    }
+
+    public var projectedValue: Binding<Value> { self }
+
+    /// The binding itself: what a `$name` closure parameter (`ForEach($items) { $item in … }`)
+    /// is made from. It must be declared in the type for the compiler to find it.
+    public init(projectedValue: Binding<Value>) {
+        self = projectedValue
+    }
+
+    public subscript<Subject>(dynamicMember keyPath: WritableKeyPath<Value, Subject>) -> Binding<Subject> {
+        Binding<Subject>(
+            get: { self.wrappedValue[keyPath: keyPath] },
+            set: { self.wrappedValue[keyPath: keyPath] = $0 }
+        )
+    }
+}

package/Sources/SwiftUI/API/StatusGaps.swift

@@ -0,0 +1,121 @@
+import Foundation
+
+// Smaller SwiftUI API that Ice Cubes' status rows and composer use.
+
+extension LocalizedStringKey.StringInterpolation {
+    /// `"Closes in \(date, style: .timer)"`: the date formatted as
+    /// `Text(date, style:)` formats it, when the text is made (TextDates.swift).
+    public mutating func appendInterpolation(_ date: Date, style: Text.DateStyle) {
+        _append(.string(Text._format(date, style: style, now: Date())), specifier: "%@")
+    }
+}
+
+extension AnyTransition {
+    /// Moves in from `edge` while fading in, and out toward the opposite edge
+    /// while fading out (iOS 16).
+    public static func push(from edge: Edge) -> AnyTransition {
+        let opposite: Edge = switch edge {
+        case .top: .bottom
+        case .bottom: .top
+        case .leading: .trailing
+        case .trailing: .leading
+        }
+        return .asymmetric(insertion: .move(edge: edge).combined(with: .opacity),
+                           removal: .move(edge: opposite).combined(with: .opacity))
+    }
+}
+
+/// Space between toolbar items (iOS 26), which separates Liquid Glass
+/// groups. The page lays a placement's items out in a row of its own, so the
+/// spacer adds nothing.
+nonisolated public struct ToolbarSpacer: ToolbarContent {
+    public init(_ sizing: SpacerSizing = .flexible, placement: ToolbarItemPlacement = .automatic) {}
+    nonisolated public var _toolbarItems: [any View] { [] }
+}
+
+/// How much room a `ToolbarSpacer` takes.
+public struct SpacerSizing: Hashable, Sendable {
+    let name: String
+    public static let flexible = SpacerSizing(name: "flexible")
+    public static let fixed = SpacerSizing(name: "fixed")
+}
+
+nonisolated extension View {
+    /// Accepted: the actions are for assistive technologies the page does not bridge.
+    public func accessibilityActions<Content: View>(@ViewBuilder _ content: () -> Content) -> some View { self }
+}
+
+/// The view's tint as a style (`.foregroundStyle(.tint)`): the nearest
+/// `.tint(_:)`, else the accent color, resolved by the page.
+public struct TintShapeStyle: ShapeStyle, Hashable {
+    public init() {}
+    public var _json: _JSON { .object(["name": .string("tint")]) }
+}
+
+extension ShapeStyle where Self == TintShapeStyle {
+    public static var tint: TintShapeStyle { TintShapeStyle() }
+}
+
+private struct _DefaultMinListRowHeightKey: EnvironmentKey {
+    static var defaultValue: CGFloat { 44 }
+}
+
+private struct _DefaultMinListHeaderHeightKey: EnvironmentKey {
+    static var defaultValue: CGFloat? { nil }
+}
+
+extension EnvironmentValues {
+    /// A list row's minimum height, 44 by default: the page sizes a `List`'s
+    /// rows to their content, at least this (the list's `minRowHeight` prop).
+    public var defaultMinListRowHeight: CGFloat {
+        get { self[_DefaultMinListRowHeightKey.self] }
+        set { self[_DefaultMinListRowHeightKey.self] = newValue }
+    }
+
+    /// A list section header's minimum height; recorded.
+    public var defaultMinListHeaderHeight: CGFloat? {
+        get { self[_DefaultMinListHeaderHeightKey.self] }
+        set { self[_DefaultMinListHeaderHeightKey.self] = newValue }
+    }
+}
+
+extension GeometryProxy {
+    /// Zero: the page does not report the safe area to Swift.
+    public var safeAreaInsets: EdgeInsets { EdgeInsets() }
+}
+
+nonisolated extension View {
+    /// The navigation title from a localized key (the key's text: no string tables are loaded).
+    public func navigationTitle(_ titleKey: LocalizedStringKey) -> some View {
+        navigationTitle(Text(titleKey))
+    }
+}
+
+extension Font {
+    /// The same font: digits keep their proportional widths on the page.
+    public func monospacedDigit() -> Font { self }
+}
+
+nonisolated extension View {
+    /// The sheet's detents with the one `selection` names first, so the page
+    /// presents the sheet at it (the page reports no resizing: the binding
+    /// changes only when the app sets it).
+    public func presentationDetents(_ detents: Set<PresentationDetent>, selection: Binding<PresentationDetent>) -> some View {
+        let sorted = detents.sorted { ($0._order, $0.name) < ($1._order, $1.name) }
+        let selected = selection.wrappedValue
+        let ordered = sorted.contains(selected) ? [selected] + sorted.filter { $0 != selected } : sorted
+        return _DetentsView(content: self, detents: ordered.map(\.name))
+    }
+}
+
+extension SearchFieldPlacement {
+    /// When the navigation bar's search field shows.
+    public enum NavigationBarDrawerDisplayMode: Hashable, Sendable {
+        case automatic, always
+    }
+
+    /// The search field in the navigation bar's drawer; the page always shows it there.
+    public static func navigationBarDrawer(displayMode: NavigationBarDrawerDisplayMode) -> SearchFieldPlacement {
+        .navigationBarDrawer
+    }
+}

package/Sources/SwiftUI/API/StrokeStyle.swift

@@ -0,0 +1,30 @@
+/// The line cap of a stroke (CoreGraphics' `CGLineCap`).
+public enum CGLineCap: Int32, Hashable, Sendable {
+    case butt, round, square
+}
+
+/// The line join of a stroke (CoreGraphics' `CGLineJoin`).
+public enum CGLineJoin: Int32, Hashable, Sendable {
+    case miter, round, bevel
+}
+
+/// How a line is stroked. Charts read `lineWidth`; the other fields are kept
+/// for source compatibility.
+public struct StrokeStyle: Equatable, Sendable {
+    public var lineWidth: CGFloat
+    public var lineCap: CGLineCap
+    public var lineJoin: CGLineJoin
+    public var miterLimit: CGFloat
+    public var dash: [CGFloat]
+    public var dashPhase: CGFloat
+
+    public init(lineWidth: CGFloat = 1, lineCap: CGLineCap = .butt, lineJoin: CGLineJoin = .miter,
+                miterLimit: CGFloat = 10, dash: [CGFloat] = [], dashPhase: CGFloat = 0) {
+        self.lineWidth = lineWidth
+        self.lineCap = lineCap
+        self.lineJoin = lineJoin
+        self.miterLimit = miterLimit
+        self.dash = dash
+        self.dashPhase = dashPhase
+    }
+}