@swiftbrowser/swift 0.0.0-stage → 0.1.0

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,
+        ])
+    }
+}
+
+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)
+    }
+}

package/Sources/SwiftUI/API/EditMode.swift

@@ -0,0 +1,269 @@
+/// Edit mode, `EditButton`, `ForEach.onDelete` / `onMove`, offset sets and
+/// `refreshable`. See docs/ops-protocol.md, "Phase 8: interaction".
+
+// MARK: - Offset sets
+
+/// A set of offsets into a collection, as `onDelete` / `onMove` report and
+/// `remove(atOffsets:)` / `move(fromOffsets:toOffset:)` consume. Foundation's
+/// `IndexSet` is not in FoundationEssentials, so the shim is generic over this
+/// protocol: `FoundationLite.IndexSet` conforms, and `_IndexSetLite` serves
+/// apps that import neither (it is what `onDelete` infers when nothing else
+/// pins the type).
+public protocol _OffsetSet {
+    init(_offsets: [Int])
+    /// The offsets in ascending order, without duplicates.
+    var _offsets: [Int] { get }
+}
+
+/// A minimal `IndexSet`: sorted unique integers.
+public struct _IndexSetLite: _OffsetSet, Hashable, Sendable, Sequence, ExpressibleByArrayLiteral {
+    public private(set) var _offsets: [Int]
+
+    public init(_offsets: [Int]) {
+        self._offsets = Array(Set(_offsets)).sorted()
+    }
+
+    public init() { _offsets = [] }
+    public init(integer: Int) { _offsets = [integer] }
+    public init<S: Sequence>(_ elements: S) where S.Element == Int { self.init(_offsets: Array(elements)) }
+    public init(arrayLiteral elements: Int...) { self.init(_offsets: elements) }
+    public init(integersIn range: Range<Int>) { _offsets = Array(range) }
+
+    public var count: Int { _offsets.count }
+    public var isEmpty: Bool { _offsets.isEmpty }
+    public var first: Int? { _offsets.first }
+    public var last: Int? { _offsets.last }
+    public func contains(_ integer: Int) -> Bool { _offsets.contains(integer) }
+
+    public mutating func insert(_ integer: Int) {
+        guard !contains(integer) else { return }
+        _offsets.append(integer)
+        _offsets.sort()
+    }
+
+    public mutating func remove(_ integer: Int) {
+        _offsets.removeAll { $0 == integer }
+    }
+
+    public func makeIterator() -> IndexingIterator<[Int]> { _offsets.makeIterator() }
+}
+
+extension RangeReplaceableCollection {
+    /// Removes the elements at `offsets` (offsets from `startIndex`).
+    public mutating func remove<O: _OffsetSet>(atOffsets offsets: O) {
+        for offset in offsets._offsets.sorted(by: >) where offset >= 0 && offset < count {
+            remove(at: index(startIndex, offsetBy: offset))
+        }
+    }
+}
+
+extension MutableCollection where Self: RangeReplaceableCollection {
+    /// Moves the elements at `source` so that they start at `destination`
+    /// (an offset into the collection before the move), like Foundation's.
+    public mutating func move<O: _OffsetSet>(fromOffsets source: O, toOffset destination: Int) {
+        let offsets = source._offsets.filter { $0 >= 0 && $0 < count }
+        guard !offsets.isEmpty else { return }
+        let moving = offsets.map { self[index(startIndex, offsetBy: $0)] }
+        let before = offsets.filter { $0 < destination }.count
+        for offset in offsets.sorted(by: >) {
+            remove(at: index(startIndex, offsetBy: offset))
+        }
+        let target = Swift.max(0, Swift.min(destination - before, count))
+        insert(contentsOf: moving, at: index(startIndex, offsetBy: target))
+    }
+}
+
+// MARK: - onDelete / onMove
+
+/// A view built from a collection, like SwiftUI's: `ForEach` and what
+/// `onDelete` / `onMove` return.
+public protocol DynamicViewContent: View {
+    associatedtype Data: Collection
+    var data: Data { get }
+}
+
+extension ForEach: DynamicViewContent where Content: View {}
+
+/// A keyed group whose rows a `List` can delete (and, when the renderer learns
+/// to, move). The runtime wraps each row in a `listrow` with `deletable`.
+protocol _DeletableGroup {
+    /// Calls the group's `onDelete` with the row at `offset`; nil without one.
+    var _delete: ((Int) -> Void)? { get }
+    var _move: ((Int, Int) -> Void)? { get }
+}
+
+public struct _EditableForEach<Base: DynamicViewContent> {
+    let base: Base
+    let delete: ((Int) -> Void)?
+    let move: ((Int, Int) -> Void)?
+}
+extension _EditableForEach: _PrimitiveView {}
+extension _EditableForEach: DynamicViewContent {
+    public var data: Base.Data { base.data }
+}
+extension _EditableForEach: _GroupView {
+    var _children: [any View] { (base as? any _GroupView)?._children ?? [base] }
+    var _keys: [AnyHashable]? { (base as? any _GroupView)?._keys }
+}
+extension _EditableForEach: _DeletableGroup {
+    var _delete: ((Int) -> Void)? { delete }
+    var _move: ((Int, Int) -> Void)? { move }
+}
+
+extension DynamicViewContent {
+    /// Lets a `List` delete the rows: `action` receives the offsets of the
+    /// removed elements in `data`. Pass `nil` to opt out.
+    public func onDelete<O: _OffsetSet>(perform action: ((O) -> Void)?) -> _EditableForEach<Self> {
+        _EditableForEach(base: self, delete: action.map { action in { action(O(_offsets: [$0])) } }, move: nil)
+    }
+
+    /// The offsets default to `_IndexSetLite` when nothing else pins the type.
+    public func onDelete(perform action: ((_IndexSetLite) -> Void)?) -> _EditableForEach<Self> {
+        _EditableForEach(base: self, delete: action.map { action in { action(_IndexSetLite(_offsets: [$0])) } }, move: nil)
+    }
+
+    /// Accepted for source compatibility; the renderer offers no reordering yet.
+    public func onMove<O: _OffsetSet>(perform action: ((O, Int) -> Void)?) -> _EditableForEach<Self> {
+        _EditableForEach(base: self, delete: nil, move: action.map { action in { action(O(_offsets: [$0]), $1) } })
+    }
+
+    public func onMove(perform action: ((_IndexSetLite, Int) -> Void)?) -> _EditableForEach<Self> {
+        _EditableForEach(base: self, delete: nil, move: action.map { action in { action(_IndexSetLite(_offsets: [$0]), $1) } })
+    }
+}
+
+extension _EditableForEach {
+    /// `ForEach(...).onDelete(...).onMove(...)`: the second modifier merges into the first.
+    public func onDelete<O: _OffsetSet>(perform action: ((O) -> Void)?) -> _EditableForEach<Base> {
+        _EditableForEach(base: base, delete: action.map { action in { action(O(_offsets: [$0])) } }, move: move)
+    }
+
+    public func onDelete(perform action: ((_IndexSetLite) -> Void)?) -> _EditableForEach<Base> {
+        _EditableForEach(base: base, delete: action.map { action in { action(_IndexSetLite(_offsets: [$0])) } }, move: move)
+    }
+
+    public func onMove<O: _OffsetSet>(perform action: ((O, Int) -> Void)?) -> _EditableForEach<Base> {
+        _EditableForEach(base: base, delete: delete, move: action.map { action in { action(O(_offsets: [$0]), $1) } })
+    }
+
+    public func onMove(perform action: ((_IndexSetLite, Int) -> Void)?) -> _EditableForEach<Base> {
+        _EditableForEach(base: base, delete: delete, move: action.map { action in { action(_IndexSetLite(_offsets: [$0]), $1) } })
+    }
+}
+
+/// `.deleteDisabled` / `.moveDisabled` on a row.
+protocol _RowEditingDisabling {
+    var _deleteDisabled: Bool { get }
+}
+
+struct _DeleteDisabledView<Content: View> {
+    let content: Content
+    let disabled: Bool
+}
+extension _DeleteDisabledView: _PrimitiveView {}
+extension _DeleteDisabledView: _GroupView {
+    var _children: [any View] { [content] }
+}
+extension _DeleteDisabledView: _RowEditingDisabling {
+    var _deleteDisabled: Bool { disabled }
+}
+
+extension View {
+    public func deleteDisabled(_ isDisabled: Bool) -> some View {
+        _DeleteDisabledView(content: self, disabled: isDisabled)
+    }
+
+    /// Accepted for source compatibility; rows cannot be moved yet.
+    public func moveDisabled(_ isDisabled: Bool) -> some View { self }
+}
+
+// MARK: - Edit mode
+
+/// Whether a view is being edited. Each `navscreen` (and a `List` outside
+/// a navigation stack) owns an edit mode the runtime puts in the environment
+/// as a binding; `EditButton` toggles it and `List` reports it as `editing`.
+public enum EditMode: Hashable, Sendable {
+    case inactive
+    case transient
+    case active
+
+    public var isEditing: Bool { self != .inactive }
+}
+
+enum _EditModeKey: EnvironmentKey { static var defaultValue: Binding<EditMode>? { nil } }
+
+extension EnvironmentValues {
+    public var editMode: Binding<EditMode>? {
+        get { self[_EditModeKey.self] }
+        set { self[_EditModeKey.self] = newValue }
+    }
+}
+
+/// A button that toggles the enclosing edit mode between "Edit" and "Done".
+public struct EditButton: View {
+    @Environment(\.editMode) private var editMode
+
+    public init() {}
+
+    public var body: some View {
+        let isEditing = editMode?.wrappedValue.isEditing == true
+        let mode = editMode
+        return Button(isEditing ? "Done" : "Edit") {
+            mode?.wrappedValue = isEditing ? .inactive : .active
+        }
+    }
+}
+
+// MARK: - Refreshable
+
+enum _RefreshActionKey: EnvironmentKey {
+    static var defaultValue: (@Sendable () async -> Void)? { nil }
+}
+
+extension EnvironmentValues {
+    /// `.refreshable`'s action, read by the `List` / `ScrollView` it wraps.
+    var _refreshAction: (@Sendable () async -> Void)? {
+        get { self[_RefreshActionKey.self] }
+        set { self[_RefreshActionKey.self] = newValue }
+    }
+}
+
+extension View {
+    /// Pull to refresh on the `List` or `ScrollView` this modifies: the view
+    /// shows a spinner (`refreshing`) while `action` runs.
+    public func refreshable(action: @escaping @Sendable () async -> Void) -> some View {
+        environment(\._refreshAction, action)
+    }
+}
+
+/// Shared by `List` and `ScrollView`: the `refreshable` / `refreshing` props
+/// and the `refresh` handler, driven by a `@State` flag on the view.
+struct _Refresh {
+    let action: (@Sendable () async -> Void)?
+    let refreshing: Binding<Bool>
+
+    func addProps(to props: inout [String: _JSON]) {
+        guard action != nil else { return }
+        props["refreshable"] = .bool(true)
+        props["refreshing"] = .bool(refreshing.wrappedValue)
+    }
+
+    @MainActor var handler: ((_JSON) -> Void)? {
+        guard let action else { return nil }
+        // Main-actor closures are Sendable; the binding itself is not.
+        let refreshing = self.refreshing
+        let isRefreshing: @MainActor () -> Bool = { refreshing.wrappedValue }
+        let setRefreshing: @MainActor (Bool) -> Void = { refreshing.wrappedValue = $0 }
+        return { payload in
+            guard case .object(let fields) = payload, case .string("refresh")? = fields["type"] else { return }
+            MainActor.assumeIsolated {
+                guard !isRefreshing() else { return }
+                setRefreshing(true)
+                Task {
+                    await action()
+                    setRefreshing(false)
+                }
+            }
+        }
+    }
+}

package/Sources/SwiftUI/API/Effects.swift

@@ -0,0 +1,290 @@
+/// Visual effects and hints that need no layout logic on the Swift side: the
+/// renderer applies them from the `styled` element's style keys (see
+/// docs/ops-protocol.md, "Phase 6 additions").
+
+public struct Angle: Hashable, Sendable, Comparable {
+    public var radians: Double
+
+    public var degrees: Double {
+        get { radians * 180 / .pi }
+        set { radians = newValue * .pi / 180 }
+    }
+
+    public init() { radians = 0 }
+    public init(radians: Double) { self.radians = radians }
+    public init(degrees: Double) { radians = degrees * .pi / 180 }
+
+    public static func radians(_ radians: Double) -> Angle { Angle(radians: radians) }
+    public static func degrees(_ degrees: Double) -> Angle { Angle(degrees: degrees) }
+    public static let zero = Angle()
+
+    public static func < (lhs: Angle, rhs: Angle) -> Bool { lhs.radians < rhs.radians }
+
+    public static prefix func - (angle: Angle) -> Angle { Angle(radians: -angle.radians) }
+    public static func + (lhs: Angle, rhs: Angle) -> Angle { Angle(radians: lhs.radians + rhs.radians) }
+    public static func - (lhs: Angle, rhs: Angle) -> Angle { Angle(radians: lhs.radians - rhs.radians) }
+    public static func * (lhs: Angle, rhs: Double) -> Angle { Angle(radians: lhs.radians * rhs) }
+    public static func * (lhs: Double, rhs: Angle) -> Angle { Angle(radians: lhs * rhs.radians) }
+    public static func / (lhs: Angle, rhs: Double) -> Angle { Angle(radians: lhs.radians / rhs) }
+    public static func += (lhs: inout Angle, rhs: Angle) { lhs = lhs + rhs }
+    public static func -= (lhs: inout Angle, rhs: Angle) { lhs = lhs - rhs }
+}
+
+/// `.formStyle`: accepted for source compatibility; forms are always grouped.
+public protocol FormStyle {}
+public struct AutomaticFormStyle: FormStyle { public init() {} }
+public struct GroupedFormStyle: FormStyle { public init() {} }
+public struct ColumnsFormStyle: FormStyle { public init() {} }
+extension FormStyle where Self == AutomaticFormStyle {
+    public static var automatic: AutomaticFormStyle { AutomaticFormStyle() }
+}
+extension FormStyle where Self == GroupedFormStyle {
+    public static var grouped: GroupedFormStyle { GroupedFormStyle() }
+}
+extension FormStyle where Self == ColumnsFormStyle {
+    public static var columns: ColumnsFormStyle { ColumnsFormStyle() }
+}
+
+extension Image {
+    public enum Scale: Hashable, Sendable {
+        case small, medium, large
+
+        var name: String {
+            switch self {
+            case .small: "small"
+            case .medium: "medium"
+            case .large: "large"
+            }
+        }
+    }
+}
+
+extension View {
+    /// Translates the rendered view without affecting layout.
+    public func offset(x: CGFloat = 0, y: CGFloat = 0) -> some View {
+        _styled { $0.extras["offset"] = .object(["x": .number(x), "y": .number(y)]) }
+    }
+
+    public func offset(_ offset: CGSize) -> some View {
+        self.offset(x: offset.width, y: offset.height)
+    }
+
+    public func rotationEffect(_ angle: Angle, anchor: UnitPoint = .center) -> some View {
+        _styled {
+            $0.extras["rotation"] = .number(angle.degrees)
+            $0.extras["rotationAnchor"] = anchor._json
+        }
+    }
+
+    public func scaleEffect(_ scale: CGFloat, anchor: UnitPoint = .center) -> some View {
+        scaleEffect(x: scale, y: scale, anchor: anchor)
+    }
+
+    public func scaleEffect(_ scale: CGSize, anchor: UnitPoint = .center) -> some View {
+        scaleEffect(x: scale.width, y: scale.height, anchor: anchor)
+    }
+
+    public func scaleEffect(x: CGFloat = 1, y: CGFloat = 1, anchor: UnitPoint = .center) -> some View {
+        _styled {
+            $0.extras["scale"] = .object(["x": .number(x), "y": .number(y)])
+            $0.extras["scaleAnchor"] = anchor._json
+        }
+    }
+
+    /// Rotates the view in 3D about `axis` through `anchor`: the `rotation3D`
+    /// style hint (angle in degrees; the renderer applies the perspective).
+    public func rotation3DEffect(_ angle: Angle, axis: (x: CGFloat, y: CGFloat, z: CGFloat),
+                                 anchor: UnitPoint = .center, anchorZ: CGFloat = 0,
+                                 perspective: CGFloat = 1) -> some View {
+        _styled {
+            $0.extras["rotation3D"] = .object([
+                "angle": .number(angle.degrees),
+                "axis": .object(["x": .number(axis.x), "y": .number(axis.y), "z": .number(axis.z)]),
+                "anchor": anchor._json,
+                "perspective": .number(perspective),
+            ])
+        }
+    }
+
+    /// A Gaussian blur of `radius` points (`opaque` is accepted and ignored).
+    public func blur(radius: CGFloat, opaque: Bool = false) -> some View {
+        _styled { $0.extras["blur"] = .number(radius) }
+    }
+
+    /// `false` makes the subtree ignore pointer events (`hitTesting: false`).
+    public func allowsHitTesting(_ enabled: Bool) -> some View {
+        _styled { if !enabled { $0.extras["hitTesting"] = .bool(false) } }
+    }
+
+    /// Lets the view extend under the safe area on `edges`: the
+    /// `ignoresSafeArea` hint, `"all"` or the list of edges. `regions` is accepted
+    /// and ignored (the browser has no keyboard safe area).
+    public func ignoresSafeArea(_ regions: SafeAreaRegions = .all, edges: Edge.Set = .all) -> some View {
+        _styled {
+            if edges == .all {
+                $0.extras["ignoresSafeArea"] = .string("all")
+            } else {
+                let names = Edge.allCases.filter { edges.contains(Edge.Set(rawValue: 1 << $0.rawValue)) }.map(\.name)
+                $0.extras["ignoresSafeArea"] = .array(names.map(_JSON.string))
+            }
+        }
+    }
+
+    public func shadow(color: Color = Color(white: 0, opacity: 0.33), radius: CGFloat, x: CGFloat = 0, y: CGFloat = 0) -> some View {
+        _styled {
+            $0.extras["shadow"] = .object([
+                "color": color._json, "radius": .number(radius), "x": .number(x), "y": .number(y),
+            ])
+        }
+    }
+
+    public func clipped(antialiased: Bool = false) -> some View {
+        _styled { $0.extras["clipped"] = .bool(true) }
+    }
+
+    /// Keeps the view's layout but draws nothing.
+    public func hidden() -> some View {
+        _styled { $0.extras["hidden"] = .bool(true) }
+    }
+
+    /// Masks the view with a paint: a `Color` or gradient mask becomes the
+    /// `mask` style hint (its alpha clips the view). Any other mask view is
+    /// not supported and leaves the view unmasked.
+    public func mask<Mask: View>(alignment: Alignment = .center, @ViewBuilder _ mask: () -> Mask) -> some View {
+        self.mask(mask())
+    }
+
+    public func mask<Mask: View>(_ mask: Mask) -> some View {
+        _styled {
+            if let style = mask as? any ShapeStyle { $0.extras["mask"] = style._json }
+        }
+    }
+
+    /// Fixes the view's center at a point in its parent's coordinate space; the
+    /// view then fills the proposed space.
+    public func position(x: CGFloat, y: CGFloat) -> some View {
+        _styled { $0.extras["position"] = .object(["x": .number(x), "y": .number(y)]) }
+    }
+
+    public func position(_ position: CGPoint) -> some View {
+        self.position(x: position.x, y: position.y)
+    }
+
+    /// The accent color for controls in the subtree (gauges, toggles, buttons).
+    public func tint(_ tint: Color?) -> some View {
+        _styled { $0.extras["tint"] = tint?._json ?? .null }
+    }
+
+    public func imageScale(_ scale: Image.Scale) -> some View {
+        _styled { $0.extras["imageScale"] = .string(scale.name) }
+    }
+
+    // MARK: List rows
+
+    /// Trailing text in a list row.
+    public func badge(_ count: Int) -> some View {
+        _styled { $0.extras["badge"] = count == 0 ? .null : .string(String(count)) }
+    }
+
+    public func badge<S: StringProtocol>(_ label: S?) -> some View {
+        _styled { $0.extras["badge"] = label.map { .string(String($0)) } ?? .null }
+    }
+
+    public func badge(_ label: Text?) -> some View {
+        _styled { $0.extras["badge"] = label.map { .string($0.content) } ?? .null }
+    }
+
+    public func listRowInsets(_ insets: EdgeInsets?) -> some View {
+        _styled { $0.extras["listRowInsets"] = insets?._json ?? .null }
+    }
+
+    // MARK: Accepted without effect (yet)
+
+    public func listRowBackground<V: View>(_ view: V?) -> some View { self }
+    public func listItemTint(_ tint: Color?) -> some View { self }
+    public func formStyle<S: FormStyle>(_ style: S) -> some View { self }
+    public func headerProminence(_ prominence: Prominence) -> some View { self }
+    public func containerShape<T: Shape>(_ shape: T) -> some View { self }
+    public func symbolVariant(_ variant: SymbolVariants) -> some View { self }
+    public func symbolRenderingMode(_ mode: SymbolRenderingMode?) -> some View { self }
+    public func blendMode(_ mode: BlendMode) -> some View { self }
+    public func contentTransition(_ transition: ContentTransition) -> some View { self }
+    public func textSelection<S: TextSelectability>(_ selectability: S) -> some View { self }
+    public func toolbarRole(_ role: ToolbarRole) -> some View { self }
+    public func controlSize(_ size: ControlSize) -> some View { self }
+}
+
+public enum Prominence: Hashable, Sendable { case standard, increased }
+
+/// `.controlSize`: accepted for source compatibility; controls keep one size.
+public enum ControlSize: Hashable, CaseIterable, Sendable { case mini, small, regular, large, extraLarge }
+
+public struct SymbolVariants: Hashable, Sendable {
+    let name: String
+    public static let none = SymbolVariants(name: "none")
+    public static let circle = SymbolVariants(name: "circle")
+    public static let square = SymbolVariants(name: "square")
+    public static let rectangle = SymbolVariants(name: "rectangle")
+    public static let fill = SymbolVariants(name: "fill")
+    public static let slash = SymbolVariants(name: "slash")
+}
+
+public enum SymbolRenderingMode: Hashable, Sendable { case monochrome, multicolor, hierarchical, palette }
+
+public enum BlendMode: Hashable, Sendable {
+    case normal, multiply, screen, overlay, darken, lighten, colorDodge, colorBurn, softLight, hardLight,
+         difference, exclusion, hue, saturation, color, luminosity, sourceAtop, destinationOver,
+         destinationOut, plusDarker, plusLighter
+}
+
+public struct SafeAreaRegions: OptionSet, Sendable {
+    public let rawValue: UInt
+    public init(rawValue: UInt) { self.rawValue = rawValue }
+    public static let container = SafeAreaRegions(rawValue: 1)
+    public static let keyboard = SafeAreaRegions(rawValue: 2)
+    public static let all: SafeAreaRegions = [.container, .keyboard]
+}
+
+public struct ContentTransition: Hashable, Sendable {
+    let name: String
+    public static let identity = ContentTransition(name: "identity")
+    public static let opacity = ContentTransition(name: "opacity")
+    public static let interpolate = ContentTransition(name: "interpolate")
+    public static func numericText(countsDown: Bool = false) -> ContentTransition { ContentTransition(name: "numericText") }
+}
+
+public protocol TextSelectability {}
+public struct EnabledTextSelectability: TextSelectability { public init() {} }
+public struct DisabledTextSelectability: TextSelectability { public init() {} }
+extension TextSelectability where Self == EnabledTextSelectability {
+    public static var enabled: EnabledTextSelectability { EnabledTextSelectability() }
+}
+extension TextSelectability where Self == DisabledTextSelectability {
+    public static var disabled: DisabledTextSelectability { DisabledTextSelectability() }
+}
+
+public enum ToolbarRole: Hashable, Sendable { case automatic, navigationStack, browser, editor }
+
+// MARK: - Tap gesture
+
+/// `.onTapGesture`: a `tapgesture` element whose tap event runs the action.
+struct _TapGestureView<Content: View> {
+    let content: Content
+    let action: @MainActor () -> Void
+}
+extension _TapGestureView: _PrimitiveView {}
+extension _TapGestureView: _HostView {
+    var _kind: String { "tapgesture" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object([:]) }
+    var _content: [any View] { [content] }
+    var _handler: ((_JSON) -> Void)? {
+        let action = self.action
+        return { _ in MainActor.assumeIsolated { action() } }
+    }
+}
+
+extension View {
+    public func onTapGesture(count: Int = 1, perform action: @escaping @MainActor () -> Void) -> some View {
+        _TapGestureView(content: self, action: action)
+    }
+}