@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/API/CustomLayout.swift

@@ -0,0 +1,442 @@
+// The `Layout` protocol, measured by the host. The Swift side has no text
+// metrics, so a custom layout cannot measure its children itself: the
+// renderer measures them (minimum, ideal and maximum size for the proposal
+// it places the `layout` element with) and reports the results in a `layout`
+// event. The runtime then runs `sizeThatFits` / `placeSubviews` and sends the
+// resulting size and frames back as props. See docs/ops-protocol.md (Phase 6).
+
+// MARK: - Public API
+
+/// A size proposed to a view; a `nil` dimension means "whatever you want".
+public struct ProposedViewSize: Equatable, Sendable {
+    public var width: CGFloat?
+    public var height: CGFloat?
+
+    public init(width: CGFloat?, height: CGFloat?) {
+        self.width = width
+        self.height = height
+    }
+
+    public init(_ size: CGSize) {
+        self.init(width: size.width, height: size.height)
+    }
+
+    public static let zero = ProposedViewSize(width: 0, height: 0)
+    public static let unspecified = ProposedViewSize(width: nil, height: nil)
+    public static let infinity = ProposedViewSize(width: .infinity, height: .infinity)
+
+    public func replacingUnspecifiedDimensions(by size: CGSize = CGSize(width: 10, height: 10)) -> CGSize {
+        CGSize(width: width ?? size.width, height: height ?? size.height)
+    }
+
+    var _json: _JSON {
+        .object(["width": _dimensionJSON(width), "height": _dimensionJSON(height)])
+    }
+}
+
+/// The size of a view, as `LayoutSubview.dimensions(in:)` reports it.
+public struct ViewDimensions: Equatable, Sendable {
+    public var width: CGFloat
+    public var height: CGFloat
+
+    init(width: CGFloat, height: CGFloat) {
+        self.width = width
+        self.height = height
+    }
+
+    public subscript(guide: HorizontalAlignment) -> CGFloat {
+        switch guide.name {
+        case "leading": 0
+        case "trailing": width
+        default: width / 2
+        }
+    }
+
+    public subscript(guide: VerticalAlignment) -> CGFloat {
+        switch guide.name {
+        case "top": 0
+        case "bottom": height
+        default: height / 2
+        }
+    }
+}
+
+/// Preferred spacing around a view. The shim has no per-view spacing
+/// preferences: every distance is the system default (8 points).
+public struct ViewSpacing: Equatable, Sendable {
+    public init() {}
+    public static let zero = ViewSpacing()
+
+    public func distance(to next: ViewSpacing, along axis: Axis) -> CGFloat { 8 }
+    public mutating func formUnion(_ other: ViewSpacing, edges: Edge.Set = .all) {}
+    public func union(_ other: ViewSpacing, edges: Edge.Set = .all) -> ViewSpacing { self }
+}
+
+/// Characteristics of a layout the system may take into account.
+public struct LayoutProperties: Sendable {
+    public var stackOrientation: Axis?
+    public init() {}
+}
+
+/// A key for values a subview exposes to its layout via `layoutValue(key:value:)`.
+public protocol LayoutValueKey {
+    associatedtype Value
+    static var defaultValue: Value { get }
+}
+
+nonisolated extension View {
+    /// A value the custom layout around this view reads from its subview
+    /// (`subview[K.self]`). It travels up with the view's elements; the
+    /// value set closest to the view wins.
+    public func layoutValue<K: LayoutValueKey>(key: K.Type, value: K.Value) -> some View {
+        _LayoutValueView(content: self, key: ObjectIdentifier(K.self), value: value)
+    }
+}
+
+/// `.layoutValue(key:value:)`: its content, with the value marked on its elements.
+struct _LayoutValueView<Content: View> {
+    let content: Content
+    let key: ObjectIdentifier
+    let value: Any
+}
+extension _LayoutValueView: _PrimitiveView {}
+extension _LayoutValueView: _GroupView {
+    var _children: [any View] { [content] }
+}
+
+protocol _LayoutValueProviding: _TraitBearing {
+    var _layoutValue: (key: ObjectIdentifier, value: Any) { get }
+}
+extension _LayoutValueView: _LayoutValueProviding {
+    var _layoutValue: (key: ObjectIdentifier, value: Any) { (key, value) }
+}
+
+/// A custom layout's element learns its children's layout values as it is produced.
+protocol _LayoutValuesReceiving {
+    func _receive(childLayoutValues: [[ObjectIdentifier: Any]])
+}
+
+/// A proxy for one child of a custom layout.
+///
+/// The sizes come from the renderer's measurement of the child: its minimum
+/// (proposal 0), ideal (proposal `nil`) and maximum (proposal infinity).
+/// `sizeThatFits` answers from those: the ideal for an unspecified axis,
+/// otherwise the proposal clamped to the minimum and maximum.
+public struct LayoutSubview {
+    let index: Int
+    let min: CGSize
+    let ideal: CGSize
+    let max: CGSize
+    let placements: _LayoutPlacements
+    /// The child's `.layoutValue`s, by key type.
+    var values: [ObjectIdentifier: Any] = [:]
+
+    public func sizeThatFits(_ proposal: ProposedViewSize) -> CGSize {
+        CGSize(
+            width: Self.fit(proposal.width, min: min.width, ideal: ideal.width, max: max.width),
+            height: Self.fit(proposal.height, min: min.height, ideal: ideal.height, max: max.height)
+        )
+    }
+
+    static func fit(_ proposed: CGFloat?, min: CGFloat, ideal: CGFloat, max: CGFloat) -> CGFloat {
+        guard let proposed else { return ideal }
+        let lower = Swift.min(min, max)
+        return Swift.max(lower, Swift.min(proposed, max))
+    }
+
+    public func dimensions(in proposal: ProposedViewSize) -> ViewDimensions {
+        let size = sizeThatFits(proposal)
+        return ViewDimensions(width: size.width, height: size.height)
+    }
+
+    public var spacing: ViewSpacing { ViewSpacing() }
+
+    public var priority: Double { 0 }
+
+    public subscript<K: LayoutValueKey>(key: K.Type) -> K.Value {
+        values[ObjectIdentifier(key)] as? K.Value ?? K.defaultValue
+    }
+
+    /// Records where the child goes. Its size is `sizeThatFits(proposal)` and
+    /// `anchor` says which point of that size sits at `position`.
+    public func place(at position: CGPoint, anchor: UnitPoint = .topLeading, proposal: ProposedViewSize) {
+        let size = sizeThatFits(proposal)
+        let origin = CGPoint(x: position.x - anchor.x * size.width, y: position.y - anchor.y * size.height)
+        placements.frames[index] = CGRect(origin: origin, size: size)
+    }
+}
+
+/// Frames recorded by `LayoutSubview.place`, shared by every proxy of one pass.
+public final class _LayoutPlacements {
+    var frames: [Int: CGRect] = [:]
+    init() {}
+}
+
+/// The children of a custom layout.
+public struct LayoutSubviews: RandomAccessCollection, Equatable {
+    public typealias Element = LayoutSubview
+    public typealias Index = Int
+    public typealias SubSequence = LayoutSubviews
+
+    let subviews: [LayoutSubview]
+    public let startIndex: Int
+    public let endIndex: Int
+
+    init(_ subviews: [LayoutSubview]) {
+        self.subviews = subviews
+        startIndex = 0
+        endIndex = subviews.count
+    }
+
+    private init(_ subviews: [LayoutSubview], range: Range<Int>) {
+        self.subviews = subviews
+        startIndex = range.lowerBound
+        endIndex = range.upperBound
+    }
+
+    public subscript(position: Int) -> LayoutSubview { subviews[position] }
+
+    public subscript(bounds: Range<Int>) -> LayoutSubviews {
+        precondition(bounds.lowerBound >= startIndex && bounds.upperBound <= endIndex, "LayoutSubviews index out of range")
+        return LayoutSubviews(subviews, range: bounds)
+    }
+
+    public static func == (lhs: LayoutSubviews, rhs: LayoutSubviews) -> Bool {
+        lhs.startIndex == rhs.startIndex && lhs.endIndex == rhs.endIndex
+            && lhs.subviews.count == rhs.subviews.count
+            && lhs.subviews.indices.allSatisfy {
+                lhs.subviews[$0].min == rhs.subviews[$0].min
+                    && lhs.subviews[$0].ideal == rhs.subviews[$0].ideal
+                    && lhs.subviews[$0].max == rhs.subviews[$0].max
+            }
+    }
+}
+
+/// A custom container layout. Conforming types compile unchanged against
+/// Apple's SwiftUI; see the file comment for how measurement works here.
+public protocol Layout {
+    associatedtype Cache = Void
+    typealias Subviews = LayoutSubviews
+
+    static var layoutProperties: LayoutProperties { get }
+
+    func makeCache(subviews: Subviews) -> Cache
+    func updateCache(_ cache: inout Cache, subviews: Subviews)
+    func spacing(subviews: Subviews, cache: inout Cache) -> ViewSpacing
+    func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout Cache) -> CGSize
+    func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout Cache)
+    func explicitAlignment(of guide: HorizontalAlignment, in bounds: CGRect, proposal: ProposedViewSize,
+                           subviews: Subviews, cache: inout Cache) -> CGFloat?
+    func explicitAlignment(of guide: VerticalAlignment, in bounds: CGRect, proposal: ProposedViewSize,
+                           subviews: Subviews, cache: inout Cache) -> CGFloat?
+}
+
+extension Layout {
+    public static var layoutProperties: LayoutProperties { LayoutProperties() }
+
+    public func updateCache(_ cache: inout Cache, subviews: Subviews) {
+        cache = makeCache(subviews: subviews)
+    }
+
+    public func spacing(subviews: Subviews, cache: inout Cache) -> ViewSpacing { ViewSpacing() }
+
+    public func explicitAlignment(of guide: HorizontalAlignment, in bounds: CGRect, proposal: ProposedViewSize,
+                                  subviews: Subviews, cache: inout Cache) -> CGFloat? { nil }
+
+    public func explicitAlignment(of guide: VerticalAlignment, in bounds: CGRect, proposal: ProposedViewSize,
+                                  subviews: Subviews, cache: inout Cache) -> CGFloat? { nil }
+}
+
+extension Layout where Cache == Void {
+    public func makeCache(subviews: Subviews) -> Cache { () }
+    public func updateCache(_ cache: inout Cache, subviews: Subviews) {}
+}
+
+extension Layout {
+    /// Uses the layout as a container: `MyLayout { child; child }`.
+    public func callAsFunction<V: View>(@ViewBuilder _ content: () -> V) -> some View {
+        _LayoutView(layout: self, content: content())
+    }
+}
+
+// MARK: - Runtime
+
+/// The result of running a layout for one host measurement; what the `layout`
+/// element's props carry. Values are rounded to 2 decimals when stored so an
+/// unchanged measurement compares equal and emits no `update`.
+struct _LayoutResult: Equatable {
+    var proposal: ProposedViewSize
+    var size: CGSize
+    var frames: [CGRect]
+    /// The layout's own flexibility: `sizeThatFits` for a zero, unspecified and
+    /// infinite proposal. The host reads these when a parent measures the
+    /// layout with a proposal other than the one it answered, instead of
+    /// guessing from the answered size.
+    var sizes: _LayoutSizes
+
+    var _json: [String: _JSON] {
+        [
+            "proposal": proposal._json,
+            "size": .object(["width": .number(size.width), "height": .number(size.height)]),
+            "frames": .array(frames.map {
+                .object(["x": .number($0.minX), "y": .number($0.minY),
+                         "width": .number($0.width), "height": .number($0.height)])
+            }),
+            "sizes": sizes._json,
+        ]
+    }
+}
+
+/// A layout's min / ideal / max sizes. Infinite dimensions serialize as
+/// `"infinity"`, like proposals do.
+struct _LayoutSizes: Equatable {
+    var min: CGSize
+    var ideal: CGSize
+    var max: CGSize
+
+    var _json: _JSON {
+        func size(_ s: CGSize) -> _JSON {
+            .object(["width": _dimensionJSON(s.width), "height": _dimensionJSON(s.height)])
+        }
+        return .object(["min": size(min), "ideal": size(ideal), "max": size(max)])
+    }
+}
+
+/// Holds a layout's cache across measurements without triggering renders,
+/// and its children's layout values as last produced.
+final class _LayoutCacheBox {
+    var cache: Any?
+    var childValues: [[ObjectIdentifier: Any]] = []
+}
+
+/// The element a custom layout renders as: kind `layout`, the children
+/// flattened inside it like a `zstack`'s. The host measures the children and
+/// sends a `layout` event; the handler runs the layout and stores the result
+/// in `State`, so it persists across re-renders and invalidates on change.
+struct _LayoutView<L: Layout, Content: View> {
+    let layout: L
+    let content: Content
+    @State var result: _LayoutResult? = nil
+    @State var cacheBox = _LayoutCacheBox()
+
+    init(layout: L, content: Content) {
+        self.layout = layout
+        self.content = content
+    }
+}
+extension _LayoutView: _PrimitiveView {}
+extension _LayoutView: _HostView {
+    var _kind: String { "layout" }
+
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(result?._json ?? ["proposal": .null, "size": .null, "frames": .null])
+    }
+
+    var _content: [any View] { [content] }
+
+    var _handler: ((_JSON) -> Void)? {
+        let layout = self.layout
+        let resultBox = _result.box
+        let cacheBox = self.cacheBox
+        return { event in
+            guard let (proposal, subviews) = _parseLayoutEvent(event, values: cacheBox.childValues) else { return }
+            let computed = _runLayout(layout, proposal: proposal, subviews: subviews, cacheBox: cacheBox)
+            if computed != resultBox.value { resultBox.value = computed }
+        }
+    }
+}
+
+extension _LayoutView: _LayoutValuesReceiving {
+    func _receive(childLayoutValues: [[ObjectIdentifier: Any]]) {
+        cacheBox.childValues = childLayoutValues
+    }
+}
+
+/// Parses `{"proposal": {...}, "children": [{"min", "ideal", "max"}]}`;
+/// `values` are the children's layout values, in order.
+func _parseLayoutEvent(_ event: _JSON, values: [[ObjectIdentifier: Any]] = []) -> (ProposedViewSize, LayoutSubviews)? {
+    guard case .object(let fields) = event else { return nil }
+    let proposal: ProposedViewSize
+    if case .object(let p)? = fields["proposal"] {
+        proposal = ProposedViewSize(width: _dimension(p["width"]), height: _dimension(p["height"]))
+    } else {
+        proposal = .unspecified
+    }
+    guard case .array(let children)? = fields["children"] else { return nil }
+    let placements = _LayoutPlacements()
+    let subviews = children.enumerated().map { index, child in
+        func size(_ key: String) -> CGSize {
+            guard case .object(let c) = child, case .object(let s)? = c[key] else { return .zero }
+            return CGSize(width: _dimension(s["width"]) ?? 0, height: _dimension(s["height"]) ?? 0)
+        }
+        return LayoutSubview(index: index, min: size("min"), ideal: size("ideal"), max: size("max"),
+                             placements: placements, values: index < values.count ? values[index] : [:])
+    }
+    return (proposal, LayoutSubviews(subviews))
+}
+
+/// Runs `sizeThatFits` and `placeSubviews`; unplaced subviews are centered at
+/// their ideal size, like SwiftUI does.
+func _runLayout<L: Layout>(_ layout: L, proposal: ProposedViewSize, subviews: LayoutSubviews,
+                           cacheBox: _LayoutCacheBox) -> _LayoutResult {
+    var cache: L.Cache
+    if let existing = cacheBox.cache as? L.Cache {
+        cache = existing
+        layout.updateCache(&cache, subviews: subviews)
+    } else {
+        cache = layout.makeCache(subviews: subviews)
+    }
+    // The flexibility probes run before the answer so `placeSubviews` sees the
+    // cache state `sizeThatFits` left for the real proposal.
+    let sizes = _LayoutSizes(
+        min: _rounded(layout.sizeThatFits(proposal: .zero, subviews: subviews, cache: &cache)),
+        ideal: _rounded(layout.sizeThatFits(proposal: .unspecified, subviews: subviews, cache: &cache)),
+        max: _rounded(layout.sizeThatFits(proposal: .infinity, subviews: subviews, cache: &cache))
+    )
+    let size = layout.sizeThatFits(proposal: proposal, subviews: subviews, cache: &cache)
+    let bounds = CGRect(origin: .zero, size: size)
+    layout.placeSubviews(in: bounds, proposal: proposal, subviews: subviews, cache: &cache)
+    cacheBox.cache = cache
+
+    let placements = subviews.first?.placements
+    let frames = subviews.map { subview -> CGRect in
+        if let frame = placements?.frames[subview.index] { return _rounded(frame) }
+        let ideal = subview.ideal
+        return _rounded(CGRect(x: bounds.midX - ideal.width / 2, y: bounds.midY - ideal.height / 2,
+                               width: ideal.width, height: ideal.height))
+    }
+    return _LayoutResult(
+        proposal: proposal,
+        size: CGSize(width: _round2(size.width), height: _round2(size.height)),
+        frames: frames,
+        sizes: sizes
+    )
+}
+
+/// A dimension from an event: a number, the string `"infinity"`, or nothing.
+func _dimension(_ json: _JSON?) -> CGFloat? {
+    switch json {
+    case .number(let n)?: n
+    case .string("infinity")?: .infinity
+    default: nil
+    }
+}
+
+func _dimensionJSON(_ value: CGFloat?) -> _JSON {
+    guard let value else { return .null }
+    return value == .infinity ? .string("infinity") : .number(_round2(value))
+}
+
+/// Rounds to 2 decimals so float noise never flips a snapshot.
+func _round2(_ value: CGFloat) -> CGFloat {
+    guard value.isFinite else { return value }
+    return (value * 100).rounded() / 100
+}
+
+private func _rounded(_ rect: CGRect) -> CGRect {
+    CGRect(x: _round2(rect.minX), y: _round2(rect.minY), width: _round2(rect.width), height: _round2(rect.height))
+}
+
+private func _rounded(_ size: CGSize) -> CGSize {
+    CGSize(width: _round2(size.width), height: _round2(size.height))
+}

package/Sources/SwiftUI/API/CustomToolbarContent.swift

@@ -0,0 +1,46 @@
+// Toolbar content types of the app's own, with a `body` (Ice Cubes'
+// `CancelToolbarItem` reads `@Environment(\.dismiss)` and returns a
+// `ToolbarItem`). Such content becomes a view in the toolbar: when it is
+// rendered, its `@Environment` properties are resolved from the environment
+// where the toolbar is, its `body` runs, and the items it makes are placed
+// like any others.
+
+extension Never: ToolbarContent {
+    nonisolated public var _toolbarItems: [any View] { [] }
+}
+
+/// Content the toolbar reads directly instead of evaluating `body`.
+extension ToolbarContent where Body == Never {
+    public var body: Never { fatalError("\(Self.self) is primitive toolbar content and has no body") }
+}
+
+extension ToolbarContent {
+    /// A view that evaluates `body` in the toolbar's environment.
+    nonisolated public var _toolbarItems: [any View] { [_CustomToolbarContentView(content: self)] }
+}
+
+struct _CustomToolbarContentView<Content: ToolbarContent> {
+    let content: Content
+    @Environment(\.self) private var environment
+}
+
+extension _CustomToolbarContentView: View {
+    var body: some View {
+        // The content is not a view, so the runtime does not resolve its
+        // properties: do it here, with this view's environment.
+        for child in Mirror(reflecting: content).children {
+            (child.value as? any _EnvironmentProperty)?._resolve(in: environment)
+            (child.value as? any _EnvironmentReading)?._resolve(in: environment)
+        }
+        return _ToolbarItemsView(items: content.body._toolbarItems)
+    }
+}
+
+/// The toolbar groups a custom content made, as siblings.
+struct _ToolbarItemsView {
+    let items: [any View]
+}
+extension _ToolbarItemsView: _PrimitiveView {}
+extension _ToolbarItemsView: _GroupView {
+    var _children: [any View] { items }
+}

package/Sources/SwiftUI/API/Decorations.swift

@@ -0,0 +1,92 @@
+/// `.overlay` and `.background` with view content: a `decorated` element
+/// whose first child decides the size and whose second child is drawn over
+/// (`overlay`) or under (`background`) it, aligned inside its box.
+struct _DecoratedView<Content: View, Decoration: View> {
+    let content: Content
+    let decoration: Decoration
+    let role: String
+    let alignment: Alignment
+}
+extension _DecoratedView: _PrimitiveView {}
+extension _DecoratedView: _HostView {
+    var _kind: String { "decorated" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(["role": .string(role), "alignment": .string(alignment._name)])
+    }
+    var _content: [any View] { [content, decoration] }
+}
+
+extension EnvironmentValues {
+    /// `.backgroundStyle(_:)`: the paint `.background(in:)` fills shapes with.
+    var _backgroundStyle: (any ShapeStyle)? {
+        get { self[_BackgroundStyleKey.self] }
+        set { self[_BackgroundStyleKey.self] = newValue }
+    }
+}
+
+private struct _BackgroundStyleKey: EnvironmentKey {
+    static var defaultValue: (any ShapeStyle)? { nil }
+}
+
+/// Fills `shape` with the environment's background style (or the system
+/// background) — `.background(in:)` without an explicit style.
+struct _EnvironmentBackgroundShape<S: Shape> {
+    let shape: S
+}
+extension _EnvironmentBackgroundShape: _PrimitiveView {}
+extension _EnvironmentBackgroundShape: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        let style = environment._backgroundStyle ?? BackgroundStyle()
+        return .object([
+            "shape": .string(shape._name),
+            "cornerRadius": .number(shape._cornerRadius),
+            "fill": style._json,
+            "stroke": .null,
+        ])
+    }
+}
+
+nonisolated extension View {
+    public func overlay<V: View>(alignment: Alignment = .center, @ViewBuilder content: () -> V) -> some View {
+        _DecoratedView(content: self, decoration: content(), role: "overlay", alignment: alignment)
+    }
+
+    /// The pre-iOS 15 spelling, `overlay(view, alignment:)`.
+    @_disfavoredOverload
+    public func overlay<V: View>(_ overlay: V, alignment: Alignment = .center) -> some View {
+        _DecoratedView(content: self, decoration: overlay, role: "overlay", alignment: alignment)
+    }
+
+    public func overlay<S: ShapeStyle>(_ style: S, ignoresSafeAreaEdges edges: Edge.Set = .all) -> some View {
+        _DecoratedView(content: self, decoration: Rectangle().fill(style), role: "overlay", alignment: .center)
+    }
+
+    public func overlay<S: ShapeStyle, T: Shape>(_ style: S, in shape: T, fillStyle: FillStyle = FillStyle()) -> some View {
+        _DecoratedView(content: self, decoration: shape.fill(style), role: "overlay", alignment: .center)
+    }
+
+    public func background<V: View>(alignment: Alignment = .center, @ViewBuilder content: () -> V) -> some View {
+        _DecoratedView(content: self, decoration: content(), role: "background", alignment: alignment)
+    }
+
+    /// The pre-iOS 15 spelling, `background(view, alignment:)`.
+    @_disfavoredOverload
+    public func background<V: View>(_ background: V, alignment: Alignment = .center) -> some View {
+        _DecoratedView(content: self, decoration: background, role: "background", alignment: alignment)
+    }
+
+    /// `shape` filled with `style`, behind the view.
+    public func background<S: ShapeStyle, T: Shape>(_ style: S, in shape: T, fillStyle: FillStyle = FillStyle()) -> some View {
+        _DecoratedView(content: self, decoration: shape.fill(style), role: "background", alignment: .center)
+    }
+
+    /// `shape` filled with the background style (`.backgroundStyle`), behind the view.
+    public func background<T: Shape>(in shape: T, fillStyle: FillStyle = FillStyle()) -> some View {
+        _DecoratedView(content: self, decoration: _EnvironmentBackgroundShape(shape: shape), role: "background", alignment: .center)
+    }
+
+    public func backgroundStyle<S: ShapeStyle>(_ style: S) -> some View {
+        environment(\._backgroundStyle, style)
+    }
+}