@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/API/GroupBoxAndControlGroup.swift

@@ -0,0 +1,130 @@
+/// `GroupBox`, `ControlGroup` and `ImageRenderer`.
+///
+/// - `GroupBox` is drawn as iOS draws its default style: the label in the
+///   headline font above the content, 8 points apart, inside 16 points of
+///   padding on a secondary-system-background rounded rectangle (radius 8).
+///   `.groupBoxStyle` is accepted; every box uses that look.
+/// - `ControlGroup` groups related controls. On iOS a menu shows them as a
+///   row of compact buttons; here its content is a group: in a menu or a
+///   context menu each control is an item of its own, elsewhere they flow in
+///   the enclosing stack. Its label is not drawn.
+/// - `ImageRenderer` would rasterize a view. Only the page draws views, so
+///   `cgImage` and `uiImage` are nil (a share-as-image feature has nothing
+///   to share); its settings are kept.
+
+// MARK: - GroupBox
+
+public struct GroupBox<Label: View, Content: View>: View {
+    let label: Label
+    let content: Content
+
+    public init(@ViewBuilder content: () -> Content, @ViewBuilder label: () -> Label) {
+        self.content = content()
+        self.label = label()
+    }
+
+    public init(label: Label, @ViewBuilder content: () -> Content) {
+        self.label = label
+        self.content = content()
+    }
+
+    public var body: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            label.font(.headline)
+            content
+        }
+        .padding(16)
+        .background(Color(semantic: "secondarySystemBackground"), in: RoundedRectangle(cornerRadius: 8))
+    }
+}
+
+extension GroupBox where Label == EmptyView {
+    public init(@ViewBuilder content: () -> Content) {
+        self.init(label: EmptyView(), content: content)
+    }
+}
+
+extension GroupBox where Label == Text {
+    public init(_ titleKey: LocalizedStringKey, @ViewBuilder content: () -> Content) {
+        self.init(label: Text(titleKey), content: content)
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, @ViewBuilder content: () -> Content) {
+        self.init(label: Text(title), content: content)
+    }
+}
+
+/// A group box's look; accepted (see the file comment).
+public protocol GroupBoxStyle {}
+public struct DefaultGroupBoxStyle: GroupBoxStyle { public init() {} }
+extension GroupBoxStyle where Self == DefaultGroupBoxStyle {
+    public static var automatic: DefaultGroupBoxStyle { DefaultGroupBoxStyle() }
+}
+
+nonisolated extension View {
+    public func groupBoxStyle<S: GroupBoxStyle>(_ style: S) -> some View { self }
+}
+
+// MARK: - ControlGroup
+
+public struct ControlGroup<Content: View> {
+    let content: Content
+
+    public init(@ViewBuilder content: () -> Content) {
+        self.content = content()
+    }
+
+    /// The label (shown by a collapsed group on iOS) is not drawn.
+    public init<L: View>(@ViewBuilder content: () -> Content, @ViewBuilder label: () -> L) {
+        self.content = content()
+    }
+
+    public init(_ titleKey: LocalizedStringKey, @ViewBuilder content: () -> Content) {
+        self.content = content()
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, @ViewBuilder content: () -> Content) {
+        self.content = content()
+    }
+
+    public init(_ titleKey: LocalizedStringKey, systemImage: String, @ViewBuilder content: () -> Content) {
+        self.content = content()
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, systemImage: String, @ViewBuilder content: () -> Content) {
+        self.content = content()
+    }
+}
+
+extension ControlGroup: View {
+    public typealias Body = Never
+    public var body: Never { fatalError("ControlGroup is a primitive view") }
+}
+extension ControlGroup: _PrimitiveView {}
+extension ControlGroup: _GroupView {
+    var _children: [any View] { [content] }
+}
+
+// MARK: - ImageRenderer
+
+/// Renders a view to an image: never, in the browser (see the file comment).
+@MainActor
+public final class ImageRenderer<Content: View>: ObservableObject {
+    public var content: Content
+    public var label: String?
+    public var proposedSize = ProposedViewSize.unspecified
+    public var scale: CGFloat = 1
+    public var isOpaque = false
+
+    public init(content: Content) {
+        self.content = content
+    }
+
+    /// Nil: only the page draws views.
+    public var cgImage: CGImage? { nil }
+    /// Nil: only the page draws views.
+    public var uiImage: UIImage? { nil }
+}

package/Sources/SwiftUI/API/KeyPress.swift

@@ -0,0 +1,54 @@
+// Focus and key presses for views that are not text fields: `.focusable()`,
+// `.focusEffectDisabled()` and `.onKeyPress`. They serve a hardware
+// keyboard on an iPad or a Mac. The page shows an iPhone and sends the app
+// no key events outside text inputs, so, like the pointer modifiers
+// (PointerAndKeyboard.swift), these are accepted and do nothing: a key-press
+// action is never called (Ice Cubes' media viewer pages with its swipes
+// instead of the arrow keys).
+
+/// A key press a view handles.
+public struct KeyPress: Sendable {
+    /// Whether the press was dealt with; an ignored one goes to the parent.
+    public enum Result: Sendable, Hashable { case handled, ignored }
+
+    /// The phases of a press an action hears.
+    public struct Phases: OptionSet, Hashable, Sendable {
+        public let rawValue: Int
+        public init(rawValue: Int) { self.rawValue = rawValue }
+        public static let down = Phases(rawValue: 1 << 0)
+        public static let `repeat` = Phases(rawValue: 1 << 1)
+        public static let up = Phases(rawValue: 1 << 2)
+        public static let all: Phases = [.down, .repeat, .up]
+    }
+
+    public let phase: Phases
+    public let key: KeyEquivalent
+    public let characters: String
+    public let modifiers: EventModifiers
+}
+
+/// How a focusable view is used.
+public struct FocusInteractions: OptionSet, Hashable, Sendable {
+    public let rawValue: Int
+    public init(rawValue: Int) { self.rawValue = rawValue }
+    public static let activate = FocusInteractions(rawValue: 1 << 0)
+    public static let edit = FocusInteractions(rawValue: 1 << 1)
+    public static let automatic: FocusInteractions = [.activate, .edit]
+}
+
+nonisolated extension View {
+    /// Accepted: the view takes no keyboard focus on the page.
+    public func focusable(_ isFocusable: Bool = true) -> some View { self }
+    public func focusable(_ isFocusable: Bool = true, interactions: FocusInteractions) -> some View { self }
+    /// Accepted: the page draws no focus ring for such views.
+    public func focusEffectDisabled(_ disabled: Bool = true) -> some View { self }
+
+    /// Accepted; the action is never called (no key events reach the app).
+    public func onKeyPress(_ key: KeyEquivalent, action: @escaping () -> KeyPress.Result) -> some View { self }
+    public func onKeyPress(_ key: KeyEquivalent, phases: KeyPress.Phases,
+                           action: @escaping (KeyPress) -> KeyPress.Result) -> some View { self }
+    public func onKeyPress(keys: Set<KeyEquivalent>, phases: KeyPress.Phases = [.down, .repeat],
+                           action: @escaping (KeyPress) -> KeyPress.Result) -> some View { self }
+    public func onKeyPress(phases: KeyPress.Phases = [.down, .repeat],
+                           action: @escaping (KeyPress) -> KeyPress.Result) -> some View { self }
+}

package/Sources/SwiftUI/API/LabelStyle.swift

@@ -0,0 +1,124 @@
+/// `LabelStyle`: how a `Label` arranges its title and icon. `Label.body`
+/// consults the environment's style (set by `.labelStyle`).
+public protocol LabelStyle {
+    associatedtype Body: View
+    typealias Configuration = LabelStyleConfiguration
+    @ViewBuilder @MainActor func makeBody(configuration: Configuration) -> Body
+}
+
+public struct LabelStyleConfiguration {
+    public struct Title: View {
+        let view: any View
+        public var body: some View { AnyView(view) }
+    }
+
+    public struct Icon: View {
+        let view: any View
+        public var body: some View { AnyView(view) }
+    }
+
+    public let title: Title
+    public let icon: Icon
+}
+
+public struct DefaultLabelStyle: LabelStyle {
+    public init() {}
+    public func makeBody(configuration: Configuration) -> some View {
+        HStack(spacing: 8) {
+            configuration.icon
+            configuration.title
+        }
+    }
+}
+
+public struct TitleAndIconLabelStyle: LabelStyle {
+    public init() {}
+    public func makeBody(configuration: Configuration) -> some View {
+        HStack(spacing: 8) {
+            configuration.icon
+            configuration.title
+        }
+    }
+}
+
+public struct IconOnlyLabelStyle: LabelStyle {
+    public init() {}
+    public func makeBody(configuration: Configuration) -> some View { configuration.icon }
+}
+
+public struct TitleOnlyLabelStyle: LabelStyle {
+    public init() {}
+    public func makeBody(configuration: Configuration) -> some View { configuration.title }
+}
+
+extension LabelStyle where Self == DefaultLabelStyle {
+    public static var automatic: DefaultLabelStyle { DefaultLabelStyle() }
+}
+extension LabelStyle where Self == TitleAndIconLabelStyle {
+    public static var titleAndIcon: TitleAndIconLabelStyle { TitleAndIconLabelStyle() }
+}
+extension LabelStyle where Self == IconOnlyLabelStyle {
+    public static var iconOnly: IconOnlyLabelStyle { IconOnlyLabelStyle() }
+}
+extension LabelStyle where Self == TitleOnlyLabelStyle {
+    public static var titleOnly: TitleOnlyLabelStyle { TitleOnlyLabelStyle() }
+}
+
+/// Type-erased style stored in the environment.
+struct _AnyLabelStyle {
+    let make: @MainActor (LabelStyleConfiguration) -> any View
+
+    @MainActor
+    init<S: LabelStyle>(_ style: S) {
+        make = { configuration in style.makeBody(configuration: configuration) }
+    }
+
+    nonisolated init(make: @escaping @MainActor (LabelStyleConfiguration) -> any View) {
+        self.make = make
+    }
+
+    /// Usable from nonisolated code (toolbars build their children there).
+    nonisolated static var iconOnly: _AnyLabelStyle {
+        _AnyLabelStyle(make: { configuration in IconOnlyLabelStyle().makeBody(configuration: configuration) })
+    }
+}
+
+private struct _LabelStyleKey: EnvironmentKey {
+    static var defaultValue: _AnyLabelStyle? { nil }
+}
+
+extension EnvironmentValues {
+    var _labelStyle: _AnyLabelStyle? {
+        get { self[_LabelStyleKey.self] }
+        set { self[_LabelStyleKey.self] = newValue }
+    }
+}
+
+nonisolated extension View {
+    @MainActor
+    public func labelStyle<S: LabelStyle>(_ style: S) -> some View {
+        environment(\._labelStyle, _AnyLabelStyle(style))
+    }
+}
+
+/// Resolves a label through the environment's style. `Label.body` returns
+/// this so the style is read where the label is mounted.
+struct _StyledLabel: View {
+    let title: any View
+    let icon: any View
+    @Environment(\._labelStyle) private var style
+
+    var body: some View {
+        // The icon is marked so a list row can tint it (the title keeps the
+        // row's primary color), as iOS does for labels in lists.
+        let markedIcon = AnyView(icon)._styled { $0.extras["labelIcon"] = .bool(true) }
+        let configuration = LabelStyleConfiguration(title: .init(view: title), icon: .init(view: markedIcon))
+        let styled = style?.make(configuration) ?? DefaultLabelStyle().makeBody(configuration: configuration)
+        // As on iOS, the title stays the label's accessibility label when the
+        // style shows only the icon (a toolbar button), so an event script
+        // can name the button by it.
+        let titleText = _textContent(of: title)
+        if titleText.isEmpty { return AnyView(styled) }
+        return AnyView(AnyView(styled).accessibilityLabel(titleText))
+    }
+}

package/Sources/SwiftUI/API/Layout.swift

@@ -0,0 +1,220 @@
+public enum TextAlignment: Hashable, Sendable {
+    case leading, center, trailing
+
+    var name: String {
+        switch self {
+        case .leading: "leading"
+        case .center: "center"
+        case .trailing: "trailing"
+        }
+    }
+}
+
+nonisolated extension View {
+    /// Sets the priority by which a parent stack hands out space.
+    public func layoutPriority(_ value: Double) -> some View {
+        _styled { $0.layoutPriority = value }
+    }
+
+    /// Limits the number of lines text in this view can occupy.
+    public func lineLimit(_ number: Int?) -> some View {
+        _styled { $0.lineLimit = number ?? -1 }
+    }
+
+    /// `reservesSpace` is accepted and ignored: the text takes the lines it needs, up to `limit`.
+    public func lineLimit(_ limit: Int, reservesSpace: Bool) -> some View {
+        _styled { $0.lineLimit = limit }
+    }
+
+    public func multilineTextAlignment(_ alignment: TextAlignment) -> some View {
+        _styled { $0.multilineTextAlignment = alignment }
+    }
+
+    /// Fixes the view at its ideal size on the given axes.
+    public func fixedSize(horizontal: Bool, vertical: Bool) -> some View {
+        _styled { $0.fixedSize = (horizontal, vertical) }
+    }
+
+    public func fixedSize() -> some View {
+        fixedSize(horizontal: true, vertical: true)
+    }
+}
+
+// MARK: - Color and shapes as views
+
+extension Color: _PrimitiveView {}
+extension Color: _HostView {
+    var _kind: String { "color" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object(["color": _json]) }
+}
+
+/// A shape drawn as a view, optionally filled or stroked. `inset` strokes
+/// (`strokeBorder`) lie inside the shape's bounds. A custom shape (`"path"`)
+/// is drawn from its path (Shape.swift), with the fill rule and the whole
+/// stroke style; a built-in shape is drawn by name.
+public struct _ShapeView<S: Shape> {
+    let shape: S
+    let fill: (any ShapeStyle)?
+    let stroke: (style: any ShapeStyle, lineWidth: CGFloat, inset: Bool)?
+    var eoFill = false
+    var strokeStyle: StrokeStyle? = nil
+}
+extension _ShapeView: _PrimitiveView {}
+extension _ShapeView: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        // A stroked shape filled with a style is its outline in that style.
+        if stroke == nil, let stroked = shape as? any _Stroked {
+            return stroked._outlineProps(style: fill ?? ForegroundStyle(), in: environment)
+        }
+        let drawsPath = shape._name == "path"
+        var stroke: _JSON = .null
+        if let s = self.stroke {
+            var object: [String: _JSON] = ["color": s.style._json, "lineWidth": .number(s.lineWidth)]
+            // A path is inset by the Swift side (Shape.swift); the page strokes it as is.
+            if s.inset && !drawsPath { object["inset"] = .bool(true) }
+            if drawsPath, let style = strokeStyle {
+                object["lineCap"] = .string(["butt", "round", "square"][Int(style.lineCap.rawValue)])
+                object["lineJoin"] = .string(["miter", "round", "bevel"][Int(style.lineJoin.rawValue)])
+                object["miterLimit"] = .number(style.miterLimit)
+                if !style.dash.isEmpty {
+                    object["dash"] = .array(style.dash.map(_JSON.number))
+                    object["dashPhase"] = .number(style.dashPhase)
+                }
+            }
+            stroke = .object(object)
+        }
+        var props: [String: _JSON] = [
+            "shape": .string(shape._name),
+            "cornerRadius": .number(_resolvedCornerRadius(shape, in: environment)),
+            "fill": fill?._json ?? .null,
+            "stroke": stroke,
+        ]
+        if drawsPath {
+            // The page reports the size the path is drawn for; the runtime
+            // adds the path (`_pathProps`).
+            props["reportsSize"] = .bool(true)
+            if eoFill { props["fillRule"] = .string("evenodd") }
+        } else if let trimmed = shape as? _TrimmedShape {
+            // `.trim(from:to:)` of a built-in shape (ShapeTrim.swift); a path is trimmed itself.
+            props["trim"] = trimmed._trimJSON
+        }
+        return .object(props)
+    }
+}
+
+/// How a shape is filled: `eoFill` uses the even-odd rule (a path's
+/// overlapping parts cancel out) rather than the non-zero winding rule.
+public struct FillStyle: Equatable, Sendable {
+    public var isEOFilled: Bool
+    public var isAntialiased: Bool
+
+    public init(eoFill: Bool = false, antialiased: Bool = true) {
+        isEOFilled = eoFill
+        isAntialiased = antialiased
+    }
+}
+
+nonisolated extension Shape {
+    public func fill<S: ShapeStyle>(_ style: S, style fillStyle: FillStyle = FillStyle()) -> some View {
+        _ShapeView(shape: self, fill: style, stroke: nil, eoFill: fillStyle.isEOFilled)
+    }
+
+    /// Filled with the foreground style.
+    public func fill(style: FillStyle = FillStyle()) -> some View {
+        _ShapeView(shape: self, fill: ForegroundStyle(), stroke: nil, eoFill: style.isEOFilled)
+    }
+
+    public func stroke<S: ShapeStyle>(_ style: S, lineWidth: CGFloat = 1) -> some View {
+        _ShapeView(shape: self, fill: nil, stroke: (style, lineWidth, false))
+    }
+
+    /// The outline as a shape (iOS 17), so it can be filled or passed where a
+    /// shape goes (`.overlay(.bar, in: .capsule.stroke())`); as a view it is
+    /// the outline in the foreground style.
+    public func stroke(lineWidth: CGFloat = 1, antialiased: Bool = true) -> _StrokedShape<Self> {
+        _StrokedShape(base: self, lineWidth: lineWidth)
+    }
+
+    /// A stroke drawn inside the shape's bounds.
+    public func strokeBorder<S: ShapeStyle>(_ style: S, lineWidth: CGFloat = 1, antialiased: Bool = true) -> some View {
+        _ShapeView(shape: self, fill: nil, stroke: (style, lineWidth, true))
+    }
+
+    public func strokeBorder(lineWidth: CGFloat = 1, antialiased: Bool = true) -> some View {
+        _ShapeView(shape: self, fill: nil, stroke: (ForegroundStyle(), lineWidth, true))
+    }
+}
+
+extension Rectangle: View {
+    public typealias Body = Never
+    public var body: Never { fatalError("Rectangle is a primitive view") }
+}
+extension RoundedRectangle: View {
+    public typealias Body = Never
+    public var body: Never { fatalError("RoundedRectangle is a primitive view") }
+}
+extension Circle: View {
+    public typealias Body = Never
+    public var body: Never { fatalError("Circle is a primitive view") }
+}
+extension Capsule: View {
+    public typealias Body = Never
+    public var body: Never { fatalError("Capsule is a primitive view") }
+}
+extension Ellipse: View {
+    public typealias Body = Never
+    public var body: Never { fatalError("Ellipse is a primitive view") }
+}
+
+extension Rectangle: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON { _shapeProps(self) }
+}
+extension RoundedRectangle: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON { _shapeProps(self) }
+}
+extension Circle: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON { _shapeProps(self) }
+}
+extension Capsule: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON { _shapeProps(self) }
+}
+extension Ellipse: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON { _shapeProps(self) }
+}
+
+private func _shapeProps(_ shape: some Shape) -> _JSON {
+    .object([
+        "shape": .string(shape._name),
+        "cornerRadius": .number(shape._cornerRadius),
+        "fill": .null,
+        "stroke": .null,
+    ])
+}
+
+/// A shape's outline as a shape (`shape.stroke(lineWidth:)`, iOS 17): drawn,
+/// or filled with a style, as the base shape stroked with that style.
+nonisolated public struct _StrokedShape<Base: Shape>: Shape {
+    let base: Base
+    let lineWidth: CGFloat
+
+    public var _name: String { base._name }
+    public var _cornerRadius: CGFloat { base._cornerRadius }
+    /// The base's path: a custom shape's outline is drawn from it.
+    public func path(in rect: CGRect) -> Path { base.path(in: rect) }
+}
+
+protocol _Stroked {
+    func _outlineProps(style: any ShapeStyle, in environment: EnvironmentValues) -> _JSON
+}
+
+extension _StrokedShape: _Stroked {
+    func _outlineProps(style: any ShapeStyle, in environment: EnvironmentValues) -> _JSON {
+        _ShapeView(shape: base, fill: nil, stroke: (style, lineWidth, false))._props(in: environment)
+    }
+}

package/Sources/SwiftUI/API/LazyStacks.swift

@@ -0,0 +1,49 @@
+// `LazyVStack` and `LazyHStack`: the same `vstack` / `hstack` elements as
+// `VStack` and `HStack`, whose `ForEach` rows are built as they come near the
+// visible area (Runtime/LazyRows.swift), as a `List`'s are.
+// `pinnedViews` is accepted: section headers and footers scroll with their
+// rows instead of sticking to the scroll view's edge.
+
+public struct LazyVStack<Content: View> {
+    let alignment: HorizontalAlignment
+    let spacing: CGFloat?
+    let content: Content
+
+    public init(alignment: HorizontalAlignment = .center, spacing: CGFloat? = nil,
+                pinnedViews: PinnedScrollableViews = .init(), @ViewBuilder content: () -> Content) {
+        self.alignment = alignment
+        self.spacing = spacing
+        self.content = content()
+    }
+}
+extension LazyVStack: _PrimitiveView {}
+extension LazyVStack: _HostView {
+    var _kind: String { "vstack" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(["spacing": spacing.map(_JSON.number) ?? .null, "alignment": .string(alignment.name)])
+    }
+    var _content: [any View] { [content] }
+}
+extension LazyVStack: _ScrollTargetContainer {}
+
+public struct LazyHStack<Content: View> {
+    let alignment: VerticalAlignment
+    let spacing: CGFloat?
+    let content: Content
+
+    public init(alignment: VerticalAlignment = .center, spacing: CGFloat? = nil,
+                pinnedViews: PinnedScrollableViews = .init(), @ViewBuilder content: () -> Content) {
+        self.alignment = alignment
+        self.spacing = spacing
+        self.content = content()
+    }
+}
+extension LazyHStack: _PrimitiveView {}
+extension LazyHStack: _HostView {
+    var _kind: String { "hstack" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(["spacing": spacing.map(_JSON.number) ?? .null, "alignment": .string(alignment.name)])
+    }
+    var _content: [any View] { [content] }
+}
+extension LazyHStack: _ScrollTargetContainer {}

package/Sources/SwiftUI/API/LegacyAlert.swift

@@ -0,0 +1,97 @@
+// SwiftUI's first alert API, still common in packages: `Alert` values with
+// `Alert.Button`s, shown by `.alert(isPresented:content:)` or
+// `.alert(item:content:)`, and `@Environment(\.presentationMode)`. An
+// `Alert` becomes the same `alert` element as the newer `.alert(_:isPresented:
+// actions:message:)` (Alert.swift): each button is a `Button` with its role.
+
+/// An alert: a title, an optional message and up to two buttons.
+public struct Alert {
+    let title: Text
+    let message: Text?
+    let buttons: [Button]
+
+    public init(title: Text, message: Text? = nil, dismissButton: Button? = nil) {
+        self.title = title
+        self.message = message
+        buttons = dismissButton.map { [$0] } ?? []
+    }
+
+    public init(title: Text, message: Text? = nil, primaryButton: Button, secondaryButton: Button) {
+        self.title = title
+        self.message = message
+        buttons = [primaryButton, secondaryButton]
+    }
+
+    /// An alert button: a label, a role and an action.
+    public struct Button {
+        let label: Text
+        let role: ButtonRole?
+        let action: (() -> Void)?
+
+        public static func `default`(_ label: Text, action: (() -> Void)? = {}) -> Button {
+            Button(label: label, role: nil, action: action)
+        }
+
+        public static func cancel(_ label: Text, action: (() -> Void)? = {}) -> Button {
+            Button(label: label, role: .cancel, action: action)
+        }
+
+        /// "Cancel".
+        public static func cancel(_ action: (() -> Void)? = {}) -> Button {
+            Button(label: Text("Cancel"), role: .cancel, action: action)
+        }
+
+        public static func destructive(_ label: Text, action: (() -> Void)? = {}) -> Button {
+            Button(label: label, role: .destructive, action: action)
+        }
+    }
+
+    /// The buttons as views; "OK" when the alert has none, as SwiftUI shows.
+    @MainActor var actions: [SwiftUI.Button<Text>] {
+        let buttons = self.buttons.isEmpty ? [Button.default(Text("OK"))] : self.buttons
+        return buttons.map { button in
+            let action = button.action
+            return SwiftUI.Button(role: button.role, action: { action?() }) { button.label }
+        }
+    }
+}
+
+extension View {
+    /// Shows the alert `content` makes while `isPresented` is true.
+    public func alert(isPresented: Binding<Bool>, content: () -> Alert) -> some View {
+        let alert = content()
+        return _AlertView(base: self, isPresented: isPresented, title: alert.title.content,
+                          message: alert.message?.content, style: "alert",
+                          actions: ForEach(Array(alert.actions.enumerated()), id: \.offset) { $0.element })
+    }
+
+    /// Shows the alert `content` makes from `item` while it is non-nil;
+    /// dismissing sets it back to nil.
+    public func alert<Item: Identifiable>(item: Binding<Item?>, content: (Item) -> Alert) -> some View {
+        let presented = Binding(get: { item.wrappedValue != nil }, set: { if !$0 { item.wrappedValue = nil } })
+        let alert = item.wrappedValue.map(content) ?? Alert(title: Text(""))
+        return _AlertView(base: self, isPresented: presented, title: alert.title.content,
+                          message: alert.message?.content, style: "alert",
+                          actions: ForEach(Array(alert.actions.enumerated()), id: \.offset) { $0.element })
+    }
+}
+
+// MARK: - Presentation mode
+
+/// Whether the view is presented, and how to dismiss it: `dismiss()` is the
+/// environment's `dismiss` action.
+public struct PresentationMode {
+    let dismissAction: DismissAction
+
+    /// True: the shim does not track this for the view.
+    public var isPresented: Bool { true }
+
+    @MainActor public mutating func dismiss() { dismissAction() }
+}
+
+extension EnvironmentValues {
+    public var presentationMode: Binding<PresentationMode> {
+        let mode = PresentationMode(dismissAction: dismiss)
+        return Binding(get: { mode }, set: { _ in })
+    }
+}