@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/SwiftUI/API/ShapeStyle.swift

@@ -3,10 +3,39 @@
 /// docs/ops-protocol.md, "Phase 6 additions"): a `Color`'s own forms, or
 /// `{"hierarchical": 1...4}`, `{"linearGradient": {...}}`,
 /// `{"radialGradient": {...}}`, `{"colorGradient": color}`, `{"material": name}`.
+///
+/// A style of an app's own (iOS 17) implements `resolve(in:)`, returning a
+/// style it is made of; it is encoded as that style, resolved in the page's
+/// environment (its color scheme, Dynamic Type size…): a change of those
+/// renders every view again. An `.environment(_:_:)` of an ancestor is not
+/// seen.
 public protocol ShapeStyle: Sendable {
+    associatedtype Resolved: ShapeStyle = Never
+    func resolve(in environment: EnvironmentValues) -> Resolved
     var _json: _JSON { get }
 }
 
+extension ShapeStyle where Resolved == Never {
+    public func resolve(in environment: EnvironmentValues) -> Never {
+        fatalError("\(Self.self) is a built-in ShapeStyle; it has no resolved style")
+    }
+}
+
+extension ShapeStyle {
+    /// An app's own style: the style it resolves to in the page's environment.
+    public var _json: _JSON { resolve(in: EnvironmentValues._page)._json }
+}
+
+extension Never: ShapeStyle {
+    public var _json: _JSON { .null }
+}
+
+extension EnvironmentValues {
+    /// The environment the page sets (the runtime's base), which an app's
+    /// own `ShapeStyle` resolves in.
+    nonisolated(unsafe) static var _page = EnvironmentValues()
+}
+
 extension Color: ShapeStyle {}
 
 // MARK: - Hierarchical (.primary ... .quaternary)
@@ -33,6 +62,38 @@ extension ShapeStyle where Self == HierarchicalShapeStyle {
     public static var quaternary: HierarchicalShapeStyle { .quaternary }
 }
 
+/// iOS 17's fill style (`.fill`, `.fill.secondary`…): UIKit's system fill
+/// colors, from `systemFill` to `quaternarySystemFill`.
+public struct FillShapeStyle: ShapeStyle, Hashable {
+    let level: Int
+
+    public init() { level = 1 }
+    init(level: Int) { self.level = level }
+
+    public var secondary: FillShapeStyle { FillShapeStyle(level: 2) }
+    public var tertiary: FillShapeStyle { FillShapeStyle(level: 3) }
+    public var quaternary: FillShapeStyle { FillShapeStyle(level: 4) }
+
+    public var _json: _JSON {
+        let names = ["systemFill", "secondarySystemFill", "tertiarySystemFill", "quaternarySystemFill"]
+        return .object(["name": .string(names[max(0, min(3, level - 1))])])
+    }
+}
+
+extension ShapeStyle where Self == FillShapeStyle {
+    public static var fill: FillShapeStyle { FillShapeStyle() }
+}
+
+/// The separator color (`.separator`, iOS 17).
+public struct SeparatorShapeStyle: ShapeStyle, Hashable {
+    public init() {}
+    public var _json: _JSON { .object(["name": .string("separator")]) }
+}
+
+extension ShapeStyle where Self == SeparatorShapeStyle {
+    public static var separator: SeparatorShapeStyle { SeparatorShapeStyle() }
+}
+
 /// The view's background color (`.background` as a style).
 public struct BackgroundStyle: ShapeStyle, Hashable {
     public init() {}
@@ -99,11 +160,16 @@ public struct Gradient: Equatable, Sendable {
         }
     }
 
-    var _json: _JSON {
+    var _stopsJSON: _JSON {
         .array(stops.map { .object(["color": $0.color._json, "location": .number($0.location)]) })
     }
 }
 
+/// A gradient as a style paints from top to bottom, as SwiftUI draws it.
+extension Gradient: ShapeStyle {
+    public var _json: _JSON { LinearGradient(gradient: self, startPoint: .top, endPoint: .bottom)._json }
+}
+
 /// `Color.gradient`: a subtle vertical gradient derived from one color.
 public struct AnyGradient: ShapeStyle, Equatable {
     let color: Color
@@ -136,7 +202,7 @@ public struct LinearGradient: ShapeStyle, Equatable {
 
     public var _json: _JSON {
         .object(["linearGradient": .object([
-            "stops": gradient._json,
+            "stops": gradient._stopsJSON,
             "start": startPoint._json,
             "end": endPoint._json,
         ])])
@@ -166,7 +232,7 @@ public struct RadialGradient: ShapeStyle, Equatable {
 
     public var _json: _JSON {
         .object(["radialGradient": .object([
-            "stops": gradient._json,
+            "stops": gradient._stopsJSON,
             "center": center._json,
             "startRadius": .number(startRadius),
             "endRadius": .number(endRadius),
@@ -234,8 +300,9 @@ extension AnyGradient: _HostView {
 
 // MARK: - Shadows
 
-/// A shadow a style can carry (`.shadow(.drop(...))`). The renderer has no
-/// per-style shadows, so a shadowed style paints as its base style.
+/// A shadow a style can carry (`.shadow(.drop(...))`). A drop shadow is the
+/// style's `shadow` key, which a shape filled with the style draws (a CSS
+/// `drop-shadow`); an inner shadow, and a shadow on text, are not drawn.
 public struct ShadowStyle: Equatable, Sendable {
     public enum Kind: Equatable, Sendable { case drop, inner }
 
@@ -257,9 +324,21 @@ public struct ShadowStyle: Equatable, Sendable {
 }
 
 extension ShapeStyle {
-    /// Approximation: the shadow is dropped and the style paints as before.
+    /// The style with a shadow (see `ShadowStyle`).
     public func shadow(_ style: ShadowStyle) -> AnyShapeStyle {
-        AnyShapeStyle(_json: _json)
+        guard style.kind == .drop, case .object(var object) = _json else { return AnyShapeStyle(_json: _json) }
+        object["shadow"] = .object([
+            "color": style.color._json, "radius": .number(style.radius), "x": .number(style.x), "y": .number(style.y),
+        ])
+        return AnyShapeStyle(_json: .object(object))
+    }
+}
+
+extension ShapeStyle where Self == AnyShapeStyle {
+    /// The foreground style with a shadow: a shape filled with it under a
+    /// view casts the view's shadow (`.background(.shadow(.drop(…)), in: shape)`).
+    public static func shadow(_ style: ShadowStyle) -> AnyShapeStyle {
+        ForegroundStyle().shadow(style)
     }
 }
 
@@ -274,6 +353,11 @@ public struct Material: ShapeStyle, Hashable {
     public static let thickMaterial = Material(name: "thick")
     public static let ultraThickMaterial = Material(name: "ultraThick")
     public static let bar = Material(name: "regular")
+    public static let ultraThin = Material(name: "ultraThin")
+    public static let thin = Material(name: "thin")
+    public static let regular = Material(name: "regular")
+    public static let thick = Material(name: "thick")
+    public static let ultraThick = Material(name: "ultraThick")
 
     public var _json: _JSON { .object(["material": .string(name)]) }
 }
@@ -297,6 +381,20 @@ public struct AnyShapeStyle: ShapeStyle {
     init(_json: _JSON) { self._json = _json }
 }
 
+/// The lower levels of any style (iOS 17): the style at the opacities of
+/// the secondary, tertiary and quaternary label colors.
+extension ShapeStyle {
+    public var secondary: AnyShapeStyle { opacity(0.6) }
+    public var tertiary: AnyShapeStyle { opacity(0.3) }
+    public var quaternary: AnyShapeStyle { opacity(0.18) }
+}
+
+extension ShapeStyle {
+    /// The style blended with what is behind it. The page paints the style
+    /// as it is (a blend mode is the view's, `View.blendMode(_:)`).
+    public func blendMode(_ mode: BlendMode) -> AnyShapeStyle { AnyShapeStyle(self) }
+}
+
 /// Opacity on any style: wraps the style's JSON with an `opacity` multiplier.
 extension ShapeStyle {
     public func opacity(_ opacity: Double) -> AnyShapeStyle {

package/Sources/SwiftUI/API/ShapeTrim.swift

@@ -0,0 +1,78 @@
+/// `Shape.trim(from:to:)` and strokes with a `StrokeStyle`.
+///
+/// A trimmed shape keeps the part of its outline between two fractions of
+/// its path. The `shape` element carries `"trim": {"from": a, "to": b}` and the
+/// page masks the shape's box with a conic gradient around its center, from
+/// the 3 o'clock position clockwise, where SwiftUI's circle path starts. For a
+/// circle (a progress ring) that is the exact trim; for other shapes it keeps
+/// the same angles, not the same length of outline (an approximation). An
+/// untrimmed shape's props are unchanged.
+///
+/// `stroke(_:style:)` draws `lineWidth` like `stroke(_:lineWidth:)`. A
+/// built-in shape's stroke is a CSS border, so its caps, joins and dashes
+/// are not drawn; a custom shape's path is stroked with all of them.
+
+/// A shape with a trim: what `_ShapeView` reads to send `trim`.
+protocol _TrimmedShape {
+    var _trimFrom: CGFloat { get }
+    var _trimTo: CGFloat { get }
+}
+
+/// `shape.trim(from:to:)`: the part of the shape's outline between the fractions.
+nonisolated public struct _TrimmedShapeView<Base: Shape>: Shape, _TrimmedShape {
+    public let base: Base
+    let from: CGFloat
+    let to: CGFloat
+
+    public var _name: String { base._name }
+    public var _cornerRadius: CGFloat { base._cornerRadius }
+    public func path(in rect: CGRect) -> Path { base.path(in: rect).trimmedPath(from: from, to: to) }
+    var _trimFrom: CGFloat { from }
+    var _trimTo: CGFloat { to }
+}
+
+extension _TrimmedShapeView: View {
+    public typealias Body = Never
+    public var body: Never { fatalError("A trimmed shape is a primitive view") }
+}
+extension _TrimmedShapeView: _PrimitiveView {}
+extension _TrimmedShapeView: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        // As a bare shape: filled with the foreground (`fill: null`, no stroke).
+        _ShapeView(shape: self, fill: nil, stroke: nil)._props(in: environment)
+    }
+}
+
+nonisolated extension Shape {
+    /// The part of the outline between `startFraction` and `endFraction` (0…1).
+    public func trim(from startFraction: CGFloat = 0, to endFraction: CGFloat = 1) -> _TrimmedShapeView<Self> {
+        _TrimmedShapeView(base: self, from: max(0, min(1, startFraction)), to: max(0, min(1, endFraction)))
+    }
+
+    /// The outline in `content`, `style.lineWidth` wide (a custom shape's
+    /// caps, joins and dashes are drawn; a built-in shape's are not).
+    public func stroke<S: ShapeStyle>(_ content: S, style: StrokeStyle, antialiased: Bool = true) -> some View {
+        _ShapeView(shape: self, fill: nil, stroke: (content, style.lineWidth, false), strokeStyle: style)
+    }
+
+    /// The outline in the foreground style, `style.lineWidth` wide.
+    public func stroke(style: StrokeStyle) -> some View {
+        _ShapeView(shape: self, fill: nil, stroke: (ForegroundStyle(), style.lineWidth, false), strokeStyle: style)
+    }
+
+    /// The outline inside the shape's bounds, `style.lineWidth` wide.
+    public func strokeBorder<S: ShapeStyle>(_ content: S, style: StrokeStyle, antialiased: Bool = true) -> some View {
+        _ShapeView(shape: self, fill: nil, stroke: (content, style.lineWidth, true), strokeStyle: style)
+    }
+
+    /// The outline inside the shape's bounds in the foreground style.
+    public func strokeBorder(style: StrokeStyle, antialiased: Bool = true) -> some View {
+        _ShapeView(shape: self, fill: nil, stroke: (ForegroundStyle(), style.lineWidth, true), strokeStyle: style)
+    }
+}
+
+extension _TrimmedShape {
+    /// The `trim` prop.
+    var _trimJSON: _JSON { .object(["from": .number(_trimFrom), "to": .number(_trimTo)]) }
+}

package/Sources/SwiftUI/API/Sharing.swift

@@ -0,0 +1,193 @@
+import Foundation
+
+// `ShareLink`: a button that asks the page to share its items. The page uses
+// the Web Share API (`navigator.share`) and, where the browser has none or
+// refuses, downloads them instead: an image item as its file, text and links
+// as a `.txt` (docs/ops-protocol.md, "Sharing"). The request is a `share`
+// host request; its answer is ignored, as SwiftUI gives the app no result.
+
+// `Transferable` is CoreTransferable's, which SwiftUI re-exports
+// (Transfer.swift): `String` and `URL` items are shared as text and links,
+// asset-catalog and `UIImage` `Image`s as files, and any other item as the
+// bytes or the file its first exporting representation gives (a symbol
+// image has no file to share).
+
+/// The title (and image) a share sheet shows for the shared item.
+public struct SharePreview<Image: Transferable, Icon: Transferable> {
+    let title: String
+    let image: Image?
+    let icon: Icon?
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, image: Image, icon: Icon) {
+        self.title = String(title); self.image = image; self.icon = icon
+    }
+
+    public init(_ titleKey: LocalizedStringKey, image: Image, icon: Icon) {
+        self.init(titleKey.key, image: image, icon: icon)
+    }
+}
+
+extension SharePreview where Image == Never, Icon == Never {
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S) { self.title = String(title); self.image = nil; self.icon = nil }
+    public init(_ titleKey: LocalizedStringKey) { self.init(titleKey.key) }
+}
+
+extension SharePreview where Icon == Never {
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, image: Image) { self.title = String(title); self.image = image; self.icon = nil }
+    public init(_ titleKey: LocalizedStringKey, image: Image) { self.init(titleKey.key, image: image) }
+}
+
+extension SharePreview where Image == Never {
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, icon: Icon) { self.title = String(title); self.image = nil; self.icon = icon }
+    public init(_ titleKey: LocalizedStringKey, icon: Icon) { self.init(titleKey.key, icon: icon) }
+}
+
+/// The label of a `ShareLink` without one of its own.
+public struct DefaultShareLinkLabel: View {
+    let title: String
+    public var body: some View {
+        Label(title, systemImage: "square.and.arrow.up")
+    }
+}
+
+public struct ShareLink<Data: RandomAccessCollection, PreviewImage: Transferable, PreviewIcon: Transferable, Label: View>: View
+where Data.Element: Transferable {
+    let items: Data
+    let subject: Text?
+    let message: Text?
+    let previewTitle: String?
+    let label: Label
+
+    init(items: Data, subject: Text?, message: Text?, previewTitle: String?, label: Label) {
+        self.items = items
+        self.subject = subject
+        self.message = message
+        self.previewTitle = previewTitle
+        self.label = label
+    }
+
+    public var body: some View {
+        let params = sharePayload
+        let sources = bitmapSources
+        let others = _UncheckedSendableBox(transferItems)
+        let title = subject?.content ?? previewTitle
+        return Button {
+            for source in sources { _Runtime.shared._sendImageSource(source) }
+            Task { @MainActor in
+                // Other `Transferable` items export first (Transfer.swift);
+                // without them the request leaves within the tap.
+                let params = others.value.isEmpty ? params : await _ShareExport.payload(params, adding: others.value, title: title)
+                _ = try? await _Runtime.shared._hostRequest(kind: "share", params: params)
+            }
+        } label: {
+            label
+        }
+    }
+
+    /// The sources of the bitmap (`UIImage`) items, which the page needs
+    /// before it can draw them into files.
+    var bitmapSources: [_ImageSource] {
+        items.compactMap { item in
+            guard let image = item as? Image, case .bitmap(let recipe, _, _) = image.source else { return nil }
+            return recipe.source
+        }
+    }
+
+    /// The items that are not a `String`, a `URL` or an `Image`: they share
+    /// what their representations export (`_ShareExport`).
+    var transferItems: [any Transferable] {
+        items.compactMap { item in item is String || item is URL || item is Image ? nil : item }
+    }
+
+    /// `{title, text, url, images, bitmaps}`: the Web Share API's fields,
+    /// images as asset-catalog names the page resolves to their files,
+    /// bitmaps (`Image(uiImage:)`) as recipes the page draws into PNG files.
+    var sharePayload: _JSON {
+        var texts: [String] = []
+        var url: String?
+        var images: [_JSON] = []
+        var bitmaps: [_JSON] = []
+        if let message { texts.append(message.content) }
+        for item in items {
+            switch item {
+            case let string as String: texts.append(string)
+            case let link as URL: if url == nil { url = link.absoluteString } else { texts.append(link.absoluteString) }
+            case let image as Image:
+                if case .named(let name) = image.source { images.append(.string(name)) }
+                else if case .url(let link, _, _) = image.source, url == nil { url = link }
+                else if case .bitmap(let recipe, _, _) = image.source, recipe.source != nil { bitmaps.append(recipe.json) }
+            default: break
+            }
+        }
+        var fields: [String: _JSON] = [:]
+        if let title = subject?.content ?? previewTitle { fields["title"] = .string(title) }
+        if !texts.isEmpty { fields["text"] = .string(texts.joined(separator: "\n")) }
+        if let url { fields["url"] = .string(url) }
+        if !images.isEmpty { fields["images"] = .array(images) }
+        if !bitmaps.isEmpty { fields["bitmaps"] = .array(bitmaps) }
+        return .object(fields)
+    }
+}
+
+// MARK: One item
+
+extension ShareLink {
+    public init<Item: Transferable>(item: Item, subject: Text? = nil, message: Text? = nil, @ViewBuilder label: () -> Label)
+    where Data == CollectionOfOne<Item>, PreviewImage == Never, PreviewIcon == Never {
+        self.init(items: CollectionOfOne(item), subject: subject, message: message, previewTitle: nil, label: label())
+    }
+
+    public init<Item: Transferable>(item: Item, subject: Text? = nil, message: Text? = nil,
+                                    preview: SharePreview<PreviewImage, PreviewIcon>, @ViewBuilder label: () -> Label)
+    where Data == CollectionOfOne<Item> {
+        self.init(items: CollectionOfOne(item), subject: subject, message: message, previewTitle: preview.title, label: label())
+    }
+}
+
+extension ShareLink where Label == DefaultShareLinkLabel {
+    public init<Item: Transferable>(item: Item, subject: Text? = nil, message: Text? = nil)
+    where Data == CollectionOfOne<Item>, PreviewImage == Never, PreviewIcon == Never {
+        self.init(items: CollectionOfOne(item), subject: subject, message: message, previewTitle: nil, label: DefaultShareLinkLabel(title: "Share"))
+    }
+
+    public init<Item: Transferable>(item: Item, subject: Text? = nil, message: Text? = nil,
+                                    preview: SharePreview<PreviewImage, PreviewIcon>)
+    where Data == CollectionOfOne<Item> {
+        self.init(items: CollectionOfOne(item), subject: subject, message: message, previewTitle: preview.title, label: DefaultShareLinkLabel(title: "Share"))
+    }
+
+    public init<Item: Transferable>(_ titleKey: LocalizedStringKey, item: Item, subject: Text? = nil, message: Text? = nil)
+    where Data == CollectionOfOne<Item>, PreviewImage == Never, PreviewIcon == Never {
+        self.init(items: CollectionOfOne(item), subject: subject, message: message, previewTitle: nil, label: DefaultShareLinkLabel(title: titleKey.key))
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol, Item: Transferable>(_ title: S, item: Item, subject: Text? = nil, message: Text? = nil)
+    where Data == CollectionOfOne<Item>, PreviewImage == Never, PreviewIcon == Never {
+        self.init(items: CollectionOfOne(item), subject: subject, message: message, previewTitle: nil, label: DefaultShareLinkLabel(title: String(title)))
+    }
+
+    public init<Item: Transferable>(_ titleKey: LocalizedStringKey, item: Item, subject: Text? = nil, message: Text? = nil,
+                                    preview: SharePreview<PreviewImage, PreviewIcon>)
+    where Data == CollectionOfOne<Item> {
+        self.init(items: CollectionOfOne(item), subject: subject, message: message, previewTitle: preview.title, label: DefaultShareLinkLabel(title: titleKey.key))
+    }
+}
+
+// MARK: Several items
+
+extension ShareLink where PreviewImage == Never, PreviewIcon == Never {
+    public init(items: Data, subject: Text? = nil, message: Text? = nil, @ViewBuilder label: () -> Label) {
+        self.init(items: items, subject: subject, message: message, previewTitle: nil, label: label())
+    }
+}
+
+extension ShareLink where PreviewImage == Never, PreviewIcon == Never, Label == DefaultShareLinkLabel {
+    public init(items: Data, subject: Text? = nil, message: Text? = nil) {
+        self.init(items: items, subject: subject, message: message, previewTitle: nil, label: DefaultShareLinkLabel(title: "Share"))
+    }
+}

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
+}