@swiftbrowser/swift 0.1.0 → 0.3.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

@@ -94,7 +94,8 @@ extension EnvironmentValues {
     }
 }
 
-extension View {
+nonisolated extension View {
+    @MainActor
     public func labelStyle<S: LabelStyle>(_ style: S) -> some View {
         environment(\._labelStyle, _AnyLabelStyle(style))
     }
@@ -108,10 +109,16 @@ struct _StyledLabel: View {
     @Environment(\._labelStyle) private var style
 
     var body: some View {
-        let configuration = LabelStyleConfiguration(title: .init(view: title), icon: .init(view: icon))
-        if let style {
-            return AnyView(style.make(configuration))
-        }
-        return AnyView(DefaultLabelStyle().makeBody(configuration: configuration))
+        // 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

@@ -10,7 +10,7 @@ public enum TextAlignment: Hashable, Sendable {
     }
 }
 
-extension View {
+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 }
@@ -49,32 +49,66 @@ extension Color: _HostView {
 }
 
 /// A shape drawn as a view, optionally filled or stroked. `inset` strokes
-/// (`strokeBorder`) lie inside the shape's bounds.
+/// (`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)]
-            if s.inset { object["inset"] = .bool(true) }
+            // 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)
+                }
+            } else if let style = strokeStyle, !style.dash.isEmpty {
+                // A built-in shape's border can only be dashed or not: the page
+                // draws CSS dashes for any pattern.
+                object["dash"] = .array(style.dash.map(_JSON.number))
+            }
             stroke = .object(object)
         }
-        return .object([
+        var props: [String: _JSON] = [
             "shape": .string(shape._name),
-            "cornerRadius": .number(shape._cornerRadius),
+            "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)
     }
 }
 
-/// Options for `fill`; accepted for source compatibility.
+/// 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
@@ -85,22 +119,25 @@ public struct FillStyle: Equatable, Sendable {
     }
 }
 
-extension Shape {
+nonisolated extension Shape {
     public func fill<S: ShapeStyle>(_ style: S, style fillStyle: FillStyle = FillStyle()) -> some View {
-        _ShapeView(shape: self, fill: style, stroke: nil)
+        _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)
+        _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))
     }
 
-    public func stroke(lineWidth: CGFloat = 1) -> some View {
-        _ShapeView(shape: self, fill: nil, stroke: (ForegroundStyle(), 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.
@@ -163,3 +200,25 @@ private func _shapeProps(_ shape: some Shape) -> _JSON {
         "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 })
+    }
+}

package/Sources/SwiftUI/API/Lists.swift

@@ -32,7 +32,7 @@ extension ListStyle where Self == GroupedListStyle {
     public static var grouped: GroupedListStyle { GroupedListStyle() }
 }
 
-extension View {
+nonisolated extension View {
     public func listStyle<S: ListStyle>(_ style: S) -> some View {
         environment(\._listStyle, style._name)
     }
@@ -53,6 +53,12 @@ struct _ListSelection {
     let accepts: (AnyHashable) -> Bool
     /// `Set<Value>` selections toggle on tap; `Value?` selections set.
     let isMultiple: Bool
+    /// The whole current selection, for the identity below.
+    let snapshot: () -> AnyHashable
+    /// Set by the runtime: the list and the selection the pass carried, so the
+    /// environments of two passes compare equal while the selection is unchanged
+    /// (the binding is re-created by every pass; see `_Sameness`).
+    var identity: _RuntimeKey?
 
     init<Value: Hashable>(_ binding: Binding<Value?>) {
         get = { binding.wrappedValue.map { AnyHashable($0) } }
@@ -67,6 +73,7 @@ struct _ListSelection {
         }
         accepts = { $0.base is Value }
         isMultiple = false
+        snapshot = { AnyHashable(binding.wrappedValue) }
     }
 
     /// `get` / `set` reduce a multiple selection to one value: the first of the set.
@@ -93,11 +100,12 @@ struct _ListSelection {
         }
         accepts = { $0.base is Value }
         isMultiple = true
+        snapshot = { AnyHashable(binding.wrappedValue) }
     }
 }
 
 /// Lists that carry a selection binding; the runtime puts it in the rows' environment.
-protocol _ListSelectionProviding {
+protocol _ListSelectionProviding: _TraitBearing {
     var _selection: _ListSelection? { get }
 }
 
@@ -198,6 +206,12 @@ extension List: _HostView {
         var props: [String: _JSON] = ["style": .string(environment._listStyle)]
         if environment.editMode?.wrappedValue.isEditing == true { props["editing"] = .bool(true) }
         _refresh(in: environment).addProps(to: &props)
+        // `.scrollDismissesKeyboard` (ScrollModifiers.swift).
+        if environment._scrollDismissesKeyboard { props["dismissesKeyboard"] = .bool(true) }
+        // `.scrollContentBackground(.hidden)` (ScrollViewReader.swift).
+        if environment._scrollContentBackground == .hidden { props["background"] = .string("hidden") }
+        // `.environment(\.defaultMinListRowHeight, 1)`: rows as short as their content.
+        if environment.defaultMinListRowHeight != 44 { props["minRowHeight"] = .number(Double(max(0, environment.defaultMinListRowHeight))) }
         return .object(props)
     }
     var _content: [any View] { [content] }
@@ -211,7 +225,7 @@ extension List: _Refreshing {}
 
 /// `List` and `ScrollView`: hosts whose `refresh` handler the runtime takes
 /// from `_refresh(in:)` (the handler depends on the environment).
-protocol _Refreshing {
+protocol _Refreshing: _TraitBearing {
     func _refresh(in environment: EnvironmentValues) -> _Refresh
 }
 extension List: _ListSelectionProviding {
@@ -224,6 +238,10 @@ public struct Section<Content: View> {
     let header: String?
     let footer: String?
     let content: Content
+    /// Modifiers applied to the section itself (`Section { … }.disabled(x)`)
+    /// style each of its rows, as in SwiftUI, instead of boxing the section
+    /// (a `styled` around a `section` is not a section to the list layout).
+    var rowStyles: [_Style] = []
 
     public init(@ViewBuilder content: () -> Content) {
         self.header = nil
@@ -231,6 +249,14 @@ public struct Section<Content: View> {
         self.content = content()
     }
 
+    /// A header from a localized key.
+    public init(_ titleKey: LocalizedStringKey, @ViewBuilder content: () -> Content) {
+        self.header = titleKey.key
+        self.footer = nil
+        self.content = content()
+    }
+
+    @_disfavoredOverload
     public init<S: StringProtocol>(_ title: S, @ViewBuilder content: () -> Content) {
         self.header = String(title)
         self.footer = nil
@@ -256,14 +282,27 @@ public struct Section<Content: View> {
         self.footer = footer().content
         self.content = content()
     }
+
+    /// A header or footer that is a `Text` (or an optional one) is a string
+    /// prop, as above; any other view is a `sectionheader` / `sectionfooter`
+    /// child (SectionSupplements.swift).
+    var headerView: (any View)?
+    var footerView: (any View)?
 }
-/// Lets pickers look through sections for their options.
-protocol _SectionView {
+/// Lets pickers look through sections for their options, and modifiers
+/// style a section's rows.
+protocol _SectionView: _TraitBearing {
     var _sectionContent: any View { get }
+    func _stylingRows(_ style: _Style) -> any View
 }
 
 extension Section: _SectionView {
     var _sectionContent: any View { content }
+    func _stylingRows(_ style: _Style) -> any View {
+        var copy = self
+        copy.rowStyles.append(style)
+        return copy
+    }
 }
 
 extension Section: _PrimitiveView {}
@@ -272,5 +311,21 @@ extension Section: _HostView {
     func _props(in environment: EnvironmentValues) -> _JSON {
         .object(["header": header.map(_JSON.string) ?? .null, "footer": footer.map(_JSON.string) ?? .null])
     }
-    var _content: [any View] { [content] }
+    var _content: [any View] {
+        // Each style distributes over the rows (`_StyledGroup`); a second one
+        // wraps the already styled rows again.
+        var view: any View = content
+        for style in rowStyles { view = _styledGroup(view, style) }
+        // View headers and footers come first and last, outside the row styles.
+        var children: [any View] = [view]
+        if let headerView { children.insert(_SectionSupplement(kind: "sectionheader", content: headerView), at: 0) }
+        if let footerView { children.append(_SectionSupplement(kind: "sectionfooter", content: footerView)) }
+        return children
+    }
+}
+
+/// `_StyledGroup(content: view, style: style)` for an existential view.
+func _styledGroup(_ view: any View, _ style: _Style) -> any View {
+    func open<V: View>(_ content: V) -> any View { _StyledGroup(content: content, style: style) }
+    return open(view)
 }