@swiftbrowser/swift 0.0.0-stage → 0.1.0

package/Sources/SwiftUI/API/Phase8Controls.swift

@@ -0,0 +1,394 @@
+/// `Stepper`, `Slider`, `DatePicker` and `TextEditor`: the `stepper`,
+/// `slider`, `datepicker` and `texteditor` elements (docs/ops-protocol.md,
+/// Phase 8). Each control's handler receives the event's `value`.
+
+// MARK: - Stepper
+
+/// Increments or decrements a value. Kind `stepper`, props `canIncrement` /
+/// `canDecrement`; the child is the label (dropped by `labelsHidden`). A
+/// `step` event with `1` / `-1` applies the step within the bounds.
+public struct Stepper<Label: View> {
+    let label: Label
+    let increment: () -> Void
+    let decrement: () -> Void
+    let canIncrement: Bool
+    let canDecrement: Bool
+    let onEditingChanged: (Bool) -> Void
+
+    public init(@ViewBuilder label: () -> Label,
+                onIncrement: (() -> Void)?,
+                onDecrement: (() -> Void)?,
+                onEditingChanged: @escaping (Bool) -> Void = { _ in }) {
+        self.label = label()
+        increment = onIncrement ?? {}
+        decrement = onDecrement ?? {}
+        canIncrement = onIncrement != nil
+        canDecrement = onDecrement != nil
+        self.onEditingChanged = onEditingChanged
+    }
+
+    public init<V: Strideable>(value: Binding<V>, in bounds: ClosedRange<V>, step: V.Stride = 1,
+                               @ViewBuilder label: () -> Label,
+                               onEditingChanged: @escaping (Bool) -> Void = { _ in }) {
+        self.label = label()
+        increment = { value.wrappedValue = min(value.wrappedValue.advanced(by: step), bounds.upperBound) }
+        decrement = { value.wrappedValue = max(value.wrappedValue.advanced(by: -step), bounds.lowerBound) }
+        canIncrement = value.wrappedValue < bounds.upperBound
+        canDecrement = value.wrappedValue > bounds.lowerBound
+        self.onEditingChanged = onEditingChanged
+    }
+
+    public init<V: Strideable>(value: Binding<V>, step: V.Stride = 1,
+                               @ViewBuilder label: () -> Label,
+                               onEditingChanged: @escaping (Bool) -> Void = { _ in }) {
+        self.label = label()
+        increment = { value.wrappedValue = value.wrappedValue.advanced(by: step) }
+        decrement = { value.wrappedValue = value.wrappedValue.advanced(by: -step) }
+        canIncrement = true
+        canDecrement = true
+        self.onEditingChanged = onEditingChanged
+    }
+}
+
+extension Stepper where Label == Text {
+    public init<S: StringProtocol>(_ title: S, onIncrement: (() -> Void)?, onDecrement: (() -> Void)?,
+                                   onEditingChanged: @escaping (Bool) -> Void = { _ in }) {
+        self.init(label: { Text(title) }, onIncrement: onIncrement, onDecrement: onDecrement,
+                  onEditingChanged: onEditingChanged)
+    }
+
+    public init<S: StringProtocol, V: Strideable>(_ title: S, value: Binding<V>, in bounds: ClosedRange<V>,
+                                                  step: V.Stride = 1,
+                                                  onEditingChanged: @escaping (Bool) -> Void = { _ in }) {
+        self.init(value: value, in: bounds, step: step, label: { Text(title) }, onEditingChanged: onEditingChanged)
+    }
+
+    public init<S: StringProtocol, V: Strideable>(_ title: S, value: Binding<V>, step: V.Stride = 1,
+                                                  onEditingChanged: @escaping (Bool) -> Void = { _ in }) {
+        self.init(value: value, step: step, label: { Text(title) }, onEditingChanged: onEditingChanged)
+    }
+
+    public init(_ titleKey: LocalizedStringKey, onIncrement: (() -> Void)?, onDecrement: (() -> Void)?,
+                onEditingChanged: @escaping (Bool) -> Void = { _ in }) {
+        self.init(label: { Text(titleKey) }, onIncrement: onIncrement, onDecrement: onDecrement,
+                  onEditingChanged: onEditingChanged)
+    }
+
+    public init<V: Strideable>(_ titleKey: LocalizedStringKey, value: Binding<V>, in bounds: ClosedRange<V>,
+                               step: V.Stride = 1, onEditingChanged: @escaping (Bool) -> Void = { _ in }) {
+        self.init(value: value, in: bounds, step: step, label: { Text(titleKey) }, onEditingChanged: onEditingChanged)
+    }
+
+    public init<V: Strideable>(_ titleKey: LocalizedStringKey, value: Binding<V>, step: V.Stride = 1,
+                               onEditingChanged: @escaping (Bool) -> Void = { _ in }) {
+        self.init(value: value, step: step, label: { Text(titleKey) }, onEditingChanged: onEditingChanged)
+    }
+}
+
+extension Stepper: _PrimitiveView {}
+extension Stepper: _HostView {
+    var _kind: String { "stepper" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(["canIncrement": .bool(canIncrement), "canDecrement": .bool(canDecrement)])
+    }
+    var _content: [any View] { Label.self is EmptyView.Type ? [] : [_GaugeLabel(label: label)] }
+    var _handler: ((_JSON) -> Void)? {
+        let increment = self.increment
+        let decrement = self.decrement
+        let canIncrement = self.canIncrement
+        let canDecrement = self.canDecrement
+        let onEditingChanged = self.onEditingChanged
+        return { payload in
+            guard case .number(let direction) = payload, direction != 0 else { return }
+            if direction > 0, !canIncrement { return }
+            if direction < 0, !canDecrement { return }
+            onEditingChanged(true)
+            direction > 0 ? increment() : decrement()
+            onEditingChanged(false)
+        }
+    }
+}
+
+// MARK: - Slider
+
+/// Selects a value from a range. Kind `slider`, props `value`, `min`, `max`,
+/// `step` (null when free) and `labels`, which names the children present in
+/// order: `"label"`, `"min"` (minimumValueLabel), `"max"` (maximumValueLabel).
+public struct Slider<Label: View, ValueLabel: View> {
+    let value: Double
+    let bounds: ClosedRange<Double>
+    let step: Double?
+    let set: (Double) -> Void
+    let label: Label
+    let minimumValueLabel: ValueLabel
+    let maximumValueLabel: ValueLabel
+    let onEditingChanged: (Bool) -> Void
+
+    init<V: BinaryFloatingPoint>(value: Binding<V>, in bounds: ClosedRange<V>, step: V.Stride?,
+                                 label: Label, minimumValueLabel: ValueLabel, maximumValueLabel: ValueLabel,
+                                 onEditingChanged: @escaping (Bool) -> Void) where V.Stride: BinaryFloatingPoint {
+        self.value = Double(value.wrappedValue)
+        self.bounds = Double(bounds.lowerBound)...Double(bounds.upperBound)
+        self.step = step.map { Double($0) }
+        let range = bounds
+        set = { value.wrappedValue = min(max(V($0), range.lowerBound), range.upperBound) }
+        self.label = label
+        self.minimumValueLabel = minimumValueLabel
+        self.maximumValueLabel = maximumValueLabel
+        self.onEditingChanged = onEditingChanged
+    }
+
+    public init<V: BinaryFloatingPoint>(value: Binding<V>, in bounds: ClosedRange<V>, step: V.Stride? = nil,
+                                        @ViewBuilder label: () -> Label,
+                                        @ViewBuilder minimumValueLabel: () -> ValueLabel,
+                                        @ViewBuilder maximumValueLabel: () -> ValueLabel,
+                                        onEditingChanged: @escaping (Bool) -> Void = { _ in })
+    where V.Stride: BinaryFloatingPoint {
+        self.init(value: value, in: bounds, step: step, label: label(),
+                  minimumValueLabel: minimumValueLabel(), maximumValueLabel: maximumValueLabel(),
+                  onEditingChanged: onEditingChanged)
+    }
+}
+
+extension Slider where ValueLabel == EmptyView {
+    public init<V: BinaryFloatingPoint>(value: Binding<V>, in bounds: ClosedRange<V>, step: V.Stride? = nil,
+                                        @ViewBuilder label: () -> Label,
+                                        onEditingChanged: @escaping (Bool) -> Void = { _ in })
+    where V.Stride: BinaryFloatingPoint {
+        self.init(value: value, in: bounds, step: step, label: label(),
+                  minimumValueLabel: EmptyView(), maximumValueLabel: EmptyView(),
+                  onEditingChanged: onEditingChanged)
+    }
+}
+
+extension Slider where Label == EmptyView, ValueLabel == EmptyView {
+    public init<V: BinaryFloatingPoint>(value: Binding<V>, in bounds: ClosedRange<V> = 0...1, step: V.Stride? = nil,
+                                        onEditingChanged: @escaping (Bool) -> Void = { _ in })
+    where V.Stride: BinaryFloatingPoint {
+        self.init(value: value, in: bounds, step: step, label: EmptyView(),
+                  minimumValueLabel: EmptyView(), maximumValueLabel: EmptyView(),
+                  onEditingChanged: onEditingChanged)
+    }
+}
+
+extension Slider: _PrimitiveView {}
+extension Slider: _HostView {
+    var _kind: String { "slider" }
+
+    private var hasValueLabels: Bool { !(ValueLabel.self is EmptyView.Type) }
+
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        var labels: [_JSON] = []
+        if !(Label.self is EmptyView.Type), !environment.labelsHidden { labels.append(.string("label")) }
+        if hasValueLabels { labels += [.string("min"), .string("max")] }
+        return .object([
+            "value": .number(value),
+            "min": .number(bounds.lowerBound),
+            "max": .number(bounds.upperBound),
+            "step": step.map(_JSON.number) ?? .null,
+            "labels": .array(labels),
+        ])
+    }
+
+    var _content: [any View] {
+        var children: [any View] = []
+        if !(Label.self is EmptyView.Type) { children.append(_GaugeLabel(label: label)) }
+        if hasValueLabels { children += [minimumValueLabel, maximumValueLabel] }
+        return children
+    }
+
+    var _handler: ((_JSON) -> Void)? {
+        let set = self.set
+        let onEditingChanged = self.onEditingChanged
+        return { payload in
+            guard case .number(let value) = payload else { return }
+            onEditingChanged(true)
+            set(value)
+            onEditingChanged(false)
+        }
+    }
+}
+
+// MARK: - DatePicker
+
+/// A value a `DatePicker` can select: a point in time as seconds since 1970
+/// (UTC). `FoundationLite` conforms `Date`; the shim itself has no date type.
+public protocol _DatePickerValue {
+    var _secondsSince1970: Double { get }
+    init(_secondsSince1970: Double)
+}
+
+/// Which parts of a date a `DatePicker` shows.
+public struct DatePickerComponents: OptionSet, Sendable {
+    public let rawValue: UInt
+    public init(rawValue: UInt) { self.rawValue = rawValue }
+    public static let hourAndMinute = DatePickerComponents(rawValue: 1 << 0)
+    public static let date = DatePickerComponents(rawValue: 1 << 1)
+
+    var _name: String {
+        if self == .date { return "date" }
+        if self == .hourAndMinute { return "hourAndMinute" }
+        return "dateAndTime"
+    }
+}
+
+/// Picks a date and/or time. Kind `datepicker`, props `seconds`, `components`,
+/// `min`, `max`; the child is the label (dropped by `labelsHidden`). A `date`
+/// event carries the new seconds since 1970.
+public struct DatePicker<Label: View> {
+    let label: Label
+    let seconds: Double
+    let minimum: Double?
+    let maximum: Double?
+    let components: DatePickerComponents
+    let set: (Double) -> Void
+
+    init<V: _DatePickerValue>(selection: Binding<V>, minimum: Double?, maximum: Double?,
+                              displayedComponents: DatePickerComponents, label: Label) {
+        self.label = label
+        seconds = selection.wrappedValue._secondsSince1970
+        self.minimum = minimum
+        self.maximum = maximum
+        components = displayedComponents
+        set = { value in
+            var clamped = value
+            if let minimum { clamped = max(clamped, minimum) }
+            if let maximum { clamped = min(clamped, maximum) }
+            selection.wrappedValue = V(_secondsSince1970: clamped)
+        }
+    }
+
+    public init<V: _DatePickerValue>(selection: Binding<V>,
+                                     displayedComponents: DatePickerComponents = [.hourAndMinute, .date],
+                                     @ViewBuilder label: () -> Label) {
+        self.init(selection: selection, minimum: nil, maximum: nil, displayedComponents: displayedComponents,
+                  label: label())
+    }
+
+    public init<V: _DatePickerValue>(selection: Binding<V>, in range: ClosedRange<V>,
+                                     displayedComponents: DatePickerComponents = [.hourAndMinute, .date],
+                                     @ViewBuilder label: () -> Label) {
+        self.init(selection: selection, minimum: range.lowerBound._secondsSince1970,
+                  maximum: range.upperBound._secondsSince1970, displayedComponents: displayedComponents,
+                  label: label())
+    }
+
+    public init<V: _DatePickerValue>(selection: Binding<V>, in range: PartialRangeFrom<V>,
+                                     displayedComponents: DatePickerComponents = [.hourAndMinute, .date],
+                                     @ViewBuilder label: () -> Label) {
+        self.init(selection: selection, minimum: range.lowerBound._secondsSince1970, maximum: nil,
+                  displayedComponents: displayedComponents, label: label())
+    }
+
+    public init<V: _DatePickerValue>(selection: Binding<V>, in range: PartialRangeThrough<V>,
+                                     displayedComponents: DatePickerComponents = [.hourAndMinute, .date],
+                                     @ViewBuilder label: () -> Label) {
+        self.init(selection: selection, minimum: nil, maximum: range.upperBound._secondsSince1970,
+                  displayedComponents: displayedComponents, label: label())
+    }
+}
+
+extension DatePicker where Label == Text {
+    public init<S: StringProtocol, V: _DatePickerValue>(_ title: S, selection: Binding<V>,
+                                                        displayedComponents: DatePickerComponents = [.hourAndMinute, .date]) {
+        self.init(selection: selection, displayedComponents: displayedComponents) { Text(title) }
+    }
+
+    public init<S: StringProtocol, V: _DatePickerValue>(_ title: S, selection: Binding<V>, in range: ClosedRange<V>,
+                                                        displayedComponents: DatePickerComponents = [.hourAndMinute, .date]) {
+        self.init(selection: selection, in: range, displayedComponents: displayedComponents) { Text(title) }
+    }
+
+    public init<S: StringProtocol, V: _DatePickerValue>(_ title: S, selection: Binding<V>, in range: PartialRangeFrom<V>,
+                                                        displayedComponents: DatePickerComponents = [.hourAndMinute, .date]) {
+        self.init(selection: selection, in: range, displayedComponents: displayedComponents) { Text(title) }
+    }
+
+    public init<S: StringProtocol, V: _DatePickerValue>(_ title: S, selection: Binding<V>, in range: PartialRangeThrough<V>,
+                                                        displayedComponents: DatePickerComponents = [.hourAndMinute, .date]) {
+        self.init(selection: selection, in: range, displayedComponents: displayedComponents) { Text(title) }
+    }
+
+    public init<V: _DatePickerValue>(_ titleKey: LocalizedStringKey, selection: Binding<V>,
+                                     displayedComponents: DatePickerComponents = [.hourAndMinute, .date]) {
+        self.init(selection: selection, displayedComponents: displayedComponents) { Text(titleKey) }
+    }
+
+    public init<V: _DatePickerValue>(_ titleKey: LocalizedStringKey, selection: Binding<V>, in range: ClosedRange<V>,
+                                     displayedComponents: DatePickerComponents = [.hourAndMinute, .date]) {
+        self.init(selection: selection, in: range, displayedComponents: displayedComponents) { Text(titleKey) }
+    }
+
+    public init<V: _DatePickerValue>(_ titleKey: LocalizedStringKey, selection: Binding<V>, in range: PartialRangeFrom<V>,
+                                     displayedComponents: DatePickerComponents = [.hourAndMinute, .date]) {
+        self.init(selection: selection, in: range, displayedComponents: displayedComponents) { Text(titleKey) }
+    }
+
+    public init<V: _DatePickerValue>(_ titleKey: LocalizedStringKey, selection: Binding<V>, in range: PartialRangeThrough<V>,
+                                     displayedComponents: DatePickerComponents = [.hourAndMinute, .date]) {
+        self.init(selection: selection, in: range, displayedComponents: displayedComponents) { Text(titleKey) }
+    }
+}
+
+extension DatePicker: _PrimitiveView {}
+extension DatePicker: _HostView {
+    var _kind: String { "datepicker" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object([
+            "seconds": .number(seconds),
+            "components": .string(components._name),
+            "min": minimum.map(_JSON.number) ?? .null,
+            "max": maximum.map(_JSON.number) ?? .null,
+        ])
+    }
+    var _content: [any View] { Label.self is EmptyView.Type ? [] : [_GaugeLabel(label: label)] }
+    var _handler: ((_JSON) -> Void)? {
+        let set = self.set
+        return { payload in
+            if case .number(let seconds) = payload { set(seconds) }
+        }
+    }
+}
+
+/// `.datePickerStyle`: accepted for source compatibility; pickers are compact.
+public protocol DatePickerStyle {}
+public struct DefaultDatePickerStyle: DatePickerStyle { public init() {} }
+public struct CompactDatePickerStyle: DatePickerStyle { public init() {} }
+public struct GraphicalDatePickerStyle: DatePickerStyle { public init() {} }
+public struct WheelDatePickerStyle: DatePickerStyle { public init() {} }
+extension DatePickerStyle where Self == DefaultDatePickerStyle {
+    public static var automatic: DefaultDatePickerStyle { DefaultDatePickerStyle() }
+}
+extension DatePickerStyle where Self == CompactDatePickerStyle {
+    public static var compact: CompactDatePickerStyle { CompactDatePickerStyle() }
+}
+extension DatePickerStyle where Self == GraphicalDatePickerStyle {
+    public static var graphical: GraphicalDatePickerStyle { GraphicalDatePickerStyle() }
+}
+extension DatePickerStyle where Self == WheelDatePickerStyle {
+    public static var wheel: WheelDatePickerStyle { WheelDatePickerStyle() }
+}
+
+extension View {
+    public func datePickerStyle<S: DatePickerStyle>(_ style: S) -> some View { self }
+}
+
+// MARK: - TextEditor
+
+/// Multi-line editable text. Kind `texteditor`, props `text`; `text` events
+/// set the binding, as for `textfield`.
+public struct TextEditor {
+    let text: Binding<String>
+    public init(text: Binding<String>) { self.text = text }
+}
+extension TextEditor: _PrimitiveView {}
+extension TextEditor: _HostView {
+    var _kind: String { "texteditor" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object(["text": .string(text.wrappedValue)]) }
+    var _handler: ((_JSON) -> Void)? {
+        let text = self.text
+        return { payload in
+            if case .string(let value) = payload { text.wrappedValue = value }
+        }
+    }
+}

package/Sources/SwiftUI/API/Picker.swift

@@ -0,0 +1,176 @@
+// MARK: - Picker styles
+
+public protocol PickerStyle {
+    var _name: String { get }
+}
+public struct DefaultPickerStyle: PickerStyle {
+    public init() {}
+    public var _name: String { "menu" }
+}
+public struct SegmentedPickerStyle: PickerStyle {
+    public init() {}
+    public var _name: String { "segmented" }
+}
+public struct MenuPickerStyle: PickerStyle {
+    public init() {}
+    public var _name: String { "menu" }
+}
+public struct InlinePickerStyle: PickerStyle {
+    public init() {}
+    public var _name: String { "inline" }
+}
+public struct WheelPickerStyle: PickerStyle {
+    public init() {}
+    public var _name: String { "menu" }
+}
+extension PickerStyle where Self == DefaultPickerStyle {
+    public static var automatic: DefaultPickerStyle { DefaultPickerStyle() }
+}
+extension PickerStyle where Self == SegmentedPickerStyle {
+    public static var segmented: SegmentedPickerStyle { SegmentedPickerStyle() }
+}
+extension PickerStyle where Self == MenuPickerStyle {
+    public static var menu: MenuPickerStyle { MenuPickerStyle() }
+}
+extension PickerStyle where Self == InlinePickerStyle {
+    public static var inline: InlinePickerStyle { InlinePickerStyle() }
+}
+extension PickerStyle where Self == WheelPickerStyle {
+    public static var wheel: WheelPickerStyle { WheelPickerStyle() }
+}
+
+extension View {
+    public func pickerStyle<S: PickerStyle>(_ style: S) -> some View {
+        environment(\._pickerStyle, style._name)
+    }
+}
+
+enum _PickerStyleKey: EnvironmentKey { static let defaultValue = "menu" }
+enum _ListStyleKey: EnvironmentKey { static let defaultValue = "insetGrouped" }
+
+extension EnvironmentValues {
+    var _pickerStyle: String {
+        get { self[_PickerStyleKey.self] }
+        set { self[_PickerStyleKey.self] = newValue }
+    }
+
+    var _listStyle: String {
+        get { self[_ListStyleKey.self] }
+        set { self[_ListStyleKey.self] = newValue }
+    }
+}
+
+// MARK: - Picker
+
+protocol _PickerHost {
+    var _labelView: any View { get }
+    var _options: any View { get }
+    func _selectedIndex(tags: [AnyHashable?]) -> Int
+    func _select(index: Int, tags: [AnyHashable?])
+}
+
+/// A control for selecting one of several options. Options are the content's
+/// children; each option's label is its text, and its identity is its `tag`
+/// (or its `ForEach` id).
+public struct Picker<Label: View, SelectionValue: Hashable, Content: View> {
+    let label: any View
+    let selection: Binding<SelectionValue>
+    let content: Content
+
+    public init(selection: Binding<SelectionValue>, @ViewBuilder content: () -> Content,
+                @ViewBuilder label: () -> Label) {
+        self.label = label()
+        self.selection = selection
+        self.content = content()
+    }
+}
+
+extension Picker where Label == Text {
+    public init<S: StringProtocol>(_ title: S, selection: Binding<SelectionValue>,
+                                   @ViewBuilder content: () -> Content) {
+        self.label = Text(title)
+        self.selection = selection
+        self.content = content()
+    }
+}
+
+extension Picker: _PrimitiveView {}
+extension Picker: _HostView {
+    var _kind: String { "picker" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object([:]) }
+    // Options, selection and the handler are produced by the runtime.
+}
+extension Picker: _PickerHost {
+    var _labelView: any View { label }
+    var _options: any View { content }
+
+    func _selectedIndex(tags: [AnyHashable?]) -> Int {
+        let current = AnyHashable(selection.wrappedValue)
+        return tags.firstIndex { $0 == current } ?? 0
+    }
+
+    func _select(index: Int, tags: [AnyHashable?]) {
+        guard index < tags.count, let tag = tags[index], let value = tag.base as? SelectionValue else { return }
+        selection.wrappedValue = value
+    }
+}
+
+/// The plain text of a label view: the first `Text` found, if any.
+@MainActor
+func _textContent(of view: any View) -> String {
+    if let text = view as? Text { return text.content }
+    if let label = view as? any _TabItemProviding { return _textContent(of: label._tabLabel) }
+    if let tagged = view as? any _TagProviding { return _textContent(of: tagged._tagged) }
+    if let group = view as? any _GroupView {
+        for child in group._children {
+            let text = _textContent(of: child)
+            if !text.isEmpty { return text }
+        }
+        return ""
+    }
+    if let host = view as? any _HostView {
+        for child in host._content {
+            let text = _textContent(of: child)
+            if !text.isEmpty { return text }
+        }
+        return ""
+    }
+    func open<V: View>(_ view: V) -> any View { view.body }
+    return _textContent(of: open(view))
+}
+
+/// The first system image name in a label view, if any.
+@MainActor
+func _systemImage(of view: any View) -> String? {
+    if let image = view as? Image { return image.systemName }
+    if let label = view as? any _TabItemProviding { return _systemImage(of: label._tabLabel) }
+    if let tagged = view as? any _TagProviding { return _systemImage(of: tagged._tagged) }
+    if let group = view as? any _GroupView {
+        for child in group._children {
+            if let name = _systemImage(of: child) { return name }
+        }
+        return nil
+    }
+    if let host = view as? any _HostView {
+        for child in host._content {
+            if let name = _systemImage(of: child) { return name }
+        }
+        return nil
+    }
+    func open<V: View>(_ view: V) -> any View { view.body }
+    return _systemImage(of: open(view))
+}
+
+// MARK: - Form
+
+/// A container for grouped controls, drawn as a grouped list.
+public struct Form<Content: View> {
+    let content: Content
+    public init(@ViewBuilder content: () -> Content) { self.content = content() }
+}
+extension Form: _PrimitiveView {}
+extension Form: _HostView {
+    var _kind: String { "list" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object(["style": .string("grouped")]) }
+    var _content: [any View] { [content] }
+}

package/Sources/SwiftUI/API/Presentation.swift

@@ -0,0 +1,109 @@
+/// A height a sheet can rest at.
+public struct PresentationDetent: Hashable, Sendable {
+    let name: String
+    public static let medium = PresentationDetent(name: "medium")
+    public static let large = PresentationDetent(name: "large")
+}
+
+/// Views that present a sheet. The runtime mounts the sheet content as a
+/// second child and emits it as a root-level `sheet` element while presented.
+protocol _SheetPresenting {
+    var _isPresented: Binding<Bool> { get }
+    var _onDismiss: (@MainActor () -> Void)? { get }
+    var _base: any View { get }
+    var _sheetContent: any View { get }
+    /// `.fullScreenCover`: the sheet's detents are `["full"]`.
+    var _fullScreen: Bool { get }
+}
+
+struct _SheetView<Base: View, Content: View> {
+    let base: Base
+    let isPresented: Binding<Bool>
+    let onDismiss: (@MainActor () -> Void)?
+    let content: Content
+    var fullScreen = false
+}
+extension _SheetView: _PrimitiveView {}
+extension _SheetView: _GroupView {
+    // Only the base is a regular child; the runtime adds the sheet content.
+    var _children: [any View] { [base] }
+}
+extension _SheetView: _SheetPresenting {
+    var _isPresented: Binding<Bool> { isPresented }
+    var _onDismiss: (@MainActor () -> Void)? { onDismiss }
+    var _base: any View { base }
+    var _sheetContent: any View { content }
+    var _fullScreen: Bool { fullScreen }
+}
+
+protocol _DetentsModifying {
+    var _detents: [String] { get }
+}
+
+struct _DetentsView<Content: View> {
+    let content: Content
+    let detents: [String]
+}
+extension _DetentsView: _PrimitiveView {}
+extension _DetentsView: _GroupView {
+    var _children: [any View] { [content] }
+}
+extension _DetentsView: _DetentsModifying {
+    var _detents: [String] { detents }
+}
+
+extension View {
+    /// Presents a sheet when `isPresented` is true.
+    public func sheet<Content: View>(isPresented: Binding<Bool>,
+                                     onDismiss: (@MainActor () -> Void)? = nil,
+                                     @ViewBuilder content: () -> Content) -> some View {
+        _SheetView(base: self, isPresented: isPresented, onDismiss: onDismiss, content: content())
+    }
+
+    /// Presents a sheet for a non-nil item; dismissing sets it back to nil.
+    public func sheet<Item: Identifiable, Content: View>(item: Binding<Item?>,
+                                                         onDismiss: (@MainActor () -> Void)? = nil,
+                                                         @ViewBuilder content: @escaping (Item) -> Content) -> some View {
+        let isPresented = Binding<Bool>(
+            get: { item.wrappedValue != nil },
+            set: { if !$0 { item.wrappedValue = nil } }
+        )
+        return _SheetView(base: self, isPresented: isPresented, onDismiss: onDismiss,
+                          content: _ItemSheetContent(item: item, content: content))
+    }
+
+    /// Presents a sheet that fills the screen (`detents: ["full"]`).
+    public func fullScreenCover<Content: View>(isPresented: Binding<Bool>,
+                                               onDismiss: (@MainActor () -> Void)? = nil,
+                                               @ViewBuilder content: () -> Content) -> some View {
+        _SheetView(base: self, isPresented: isPresented, onDismiss: onDismiss, content: content(), fullScreen: true)
+    }
+
+    public func fullScreenCover<Item: Identifiable, Content: View>(item: Binding<Item?>,
+                                                                   onDismiss: (@MainActor () -> Void)? = nil,
+                                                                   @ViewBuilder content: @escaping (Item) -> Content) -> some View {
+        let isPresented = Binding<Bool>(
+            get: { item.wrappedValue != nil },
+            set: { if !$0 { item.wrappedValue = nil } }
+        )
+        return _SheetView(base: self, isPresented: isPresented, onDismiss: onDismiss,
+                          content: _ItemSheetContent(item: item, content: content), fullScreen: true)
+    }
+
+    public func presentationDetents(_ detents: Set<PresentationDetent>) -> some View {
+        let order = ["medium", "large"]
+        return _DetentsView(content: self, detents: order.filter { name in detents.contains { $0.name == name } })
+    }
+}
+
+/// The content of `.sheet(item:)`, built from the current item (empty once it is nil).
+struct _ItemSheetContent<Item: Identifiable, Content: View>: View {
+    let item: Binding<Item?>
+    let content: (Item) -> Content
+
+    var body: some View {
+        if let value = item.wrappedValue {
+            content(value)
+        }
+    }
+}