@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/API/Table.swift

@@ -0,0 +1,382 @@
+// `Table`, drawn as iOS draws one: a list. In a compact width (an iPhone)
+// each row shows the table's first column only, as on iOS; in a regular
+// width the rows show every column side by side under a row of the column
+// titles, and tapping a sortable column's title sorts by it (the app sorts
+// its rows by the `sortOrder` binding, as with SwiftUI's table). Selection is
+// the list's. A column's `width(_:)` fixes its width; the other columns share
+// the rest.
+//
+// The rows are views (`TableRow`, in `ForEach` and `Section` as in SwiftUI);
+// a row draws the columns the table puts in its environment. Sortable columns
+// and the `sortOrder` forms of `Table` need Foundation's `KeyPathComparator`,
+// so they are FoundationBridge's (Table.swift there).
+
+// MARK: - Columns
+
+/// Columns of a table, made with `TableColumnBuilder`.
+public protocol TableColumnContent<TableRowValue, TableColumnSortComparator> {
+    associatedtype TableRowValue: Identifiable
+    associatedtype TableColumnSortComparator
+    var _tableColumns: [_TableColumn<TableRowValue>] { get }
+}
+
+/// One column: its title, the view it draws for a row, its width and, for a
+/// sortable column, the comparator (a `KeyPathComparator`) its title sorts by.
+public struct _TableColumn<RowValue> {
+    public var title: Text
+    public var content: (RowValue) -> AnyView
+    public var sortComparator: Any?
+    var width: CGFloat?
+    var minWidth: CGFloat?
+    var maxWidth: CGFloat?
+
+    public init(title: Text, sortComparator: Any? = nil, content: @escaping (RowValue) -> AnyView) {
+        self.title = title
+        self.sortComparator = sortComparator
+        self.content = content
+    }
+}
+
+public struct TableColumn<RowValue: Identifiable, Sort, Content: View, Label: View>: TableColumnContent {
+    public typealias TableRowValue = RowValue
+    public typealias TableColumnSortComparator = Sort
+
+    var column: _TableColumn<RowValue>
+    public var _tableColumns: [_TableColumn<RowValue>] { [column] }
+
+    /// A column made elsewhere (FoundationBridge's sortable columns).
+    public init(_column: _TableColumn<RowValue>) { column = _column }
+
+    /// A fixed width (nil: shares the rest of the row).
+    public func width(_ width: CGFloat?) -> TableColumn {
+        var copy = self
+        copy.column.width = width
+        return copy
+    }
+
+    /// Limits on the width; the ideal width is the column's when given.
+    public func width(min: CGFloat? = nil, ideal: CGFloat? = nil, max: CGFloat? = nil) -> TableColumn {
+        var copy = self
+        copy.column.minWidth = min
+        copy.column.maxWidth = max
+        if let ideal, min == nil, max == nil { copy.column.width = ideal }
+        return copy
+    }
+
+    /// Accepted: columns line up with the start of their titles.
+    public func alignment(_ alignment: TableColumnAlignment) -> TableColumn { self }
+    /// Accepted: the browser's table has no column customization.
+    public func customizationID(_ id: String) -> TableColumn { self }
+    public func defaultVisibility(_ visibility: Visibility) -> TableColumn { self }
+    public func disabledCustomizationBehavior(_ behavior: TableColumnCustomizationBehavior) -> TableColumn { self }
+}
+
+extension TableColumn where Sort == Never, Label == Text {
+    public init(_ titleKey: LocalizedStringKey, @ViewBuilder content: @escaping (RowValue) -> Content) {
+        self.init(_column: _TableColumn(title: Text(titleKey)) { AnyView(content($0)) })
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, @ViewBuilder content: @escaping (RowValue) -> Content) {
+        self.init(_column: _TableColumn(title: Text(String(title))) { AnyView(content($0)) })
+    }
+
+    public init(_ text: Text, @ViewBuilder content: @escaping (RowValue) -> Content) {
+        self.init(_column: _TableColumn(title: text) { AnyView(content($0)) })
+    }
+}
+
+public struct TableColumnAlignment: Hashable, Sendable {
+    let name: String
+    public static let automatic = TableColumnAlignment(name: "automatic")
+    public static let leading = TableColumnAlignment(name: "leading")
+    public static let center = TableColumnAlignment(name: "center")
+    public static let trailing = TableColumnAlignment(name: "trailing")
+    public static let numeric = TableColumnAlignment(name: "numeric")
+}
+
+public struct TableColumnCustomizationBehavior: Hashable, Sendable {
+    let name: String
+    public static let all = TableColumnCustomizationBehavior(name: "all")
+    public static let resize = TableColumnCustomizationBehavior(name: "resize")
+    public static let reorder = TableColumnCustomizationBehavior(name: "reorder")
+    public static let visibility = TableColumnCustomizationBehavior(name: "visibility")
+}
+
+/// The columns a `TableColumnBuilder` made.
+public struct _TableColumnGroup<RowValue: Identifiable, Sort>: TableColumnContent {
+    public typealias TableRowValue = RowValue
+    public typealias TableColumnSortComparator = Sort
+    public let _tableColumns: [_TableColumn<RowValue>]
+}
+
+@resultBuilder
+public struct TableColumnBuilder<RowValue: Identifiable, Sort> {
+    /// A column, whose row type is the table's (so its closure's parameter is inferred).
+    public static func buildExpression<ColumnSort, Content, Label>(_ column: TableColumn<RowValue, ColumnSort, Content, Label>)
+    -> [_TableColumn<RowValue>] {
+        column._tableColumns
+    }
+    @_disfavoredOverload
+    public static func buildExpression<Column: TableColumnContent>(_ column: Column) -> [_TableColumn<RowValue>]
+    where Column.TableRowValue == RowValue {
+        column._tableColumns
+    }
+    public static func buildBlock(_ components: [_TableColumn<RowValue>]...) -> [_TableColumn<RowValue>] { components.flatMap { $0 } }
+    public static func buildOptional(_ component: [_TableColumn<RowValue>]?) -> [_TableColumn<RowValue>] { component ?? [] }
+    public static func buildEither(first component: [_TableColumn<RowValue>]) -> [_TableColumn<RowValue>] { component }
+    public static func buildEither(second component: [_TableColumn<RowValue>]) -> [_TableColumn<RowValue>] { component }
+    public static func buildLimitedAvailability(_ component: [_TableColumn<RowValue>]) -> [_TableColumn<RowValue>] { component }
+    public static func buildFinalResult(_ component: [_TableColumn<RowValue>]) -> _TableColumnGroup<RowValue, Sort> {
+        _TableColumnGroup(_tableColumns: component)
+    }
+}
+
+// MARK: - Rows
+
+/// Rows of a table.
+public protocol TableRowContent<TableRowValue> {
+    associatedtype TableRowValue: Identifiable
+}
+
+/// A row of a table: the table's columns drawn for `value`.
+public struct TableRow<Value: Identifiable>: View, TableRowContent {
+    public typealias TableRowValue = Value
+    let value: Value
+    @Environment(\._tableLayout) private var layout
+
+    public init(_ value: Value) { self.value = value }
+
+    public var body: some View {
+        if let layout { layout.row(value) }
+    }
+}
+
+/// The rows of a table made from a collection (`Table(data) { … }`): a
+/// `TableRow` for each element.
+public struct TableForEachContent<Data: RandomAccessCollection>: TableRowContent where Data.Element: Identifiable {
+    public typealias TableRowValue = Data.Element
+    let data: Data
+}
+
+/// What a row draws: the table's columns, all of them or the first.
+struct _TableLayout {
+    struct Column {
+        let width: CGFloat?
+        let minWidth: CGFloat?
+        let maxWidth: CGFloat?
+        let content: (Any) -> AnyView
+    }
+
+    let columns: [Column]
+    let compact: Bool
+
+    @MainActor
+    func row(_ value: Any) -> AnyView {
+        guard let first = columns.first else { return AnyView(EmptyView()) }
+        if compact { return first.content(value) }
+        return AnyView(HStack(spacing: _tableColumnSpacing) {
+            ForEach(columns.indices, id: \.self) { index in
+                _tableCell(columns[index], columns[index].content(value))
+            }
+        })
+    }
+}
+
+let _tableColumnSpacing: CGFloat = 12
+
+/// A cell at its column's width: fixed, or a share of the row. Its own
+/// priority is 0, so a `layoutPriority` inside a cell (Food Truck's first
+/// column has one) does not take the row from the other columns.
+@MainActor
+func _tableCell(_ column: _TableLayout.Column, _ content: some View) -> AnyView {
+    if let width = column.width {
+        return AnyView(content.frame(width: width, alignment: .leading).layoutPriority(0))
+    }
+    return AnyView(content.frame(minWidth: column.minWidth ?? 0, maxWidth: column.maxWidth ?? .infinity, alignment: .leading)
+        .layoutPriority(0))
+}
+
+private struct _TableLayoutKey: EnvironmentKey {
+    static var defaultValue: _TableLayout? { nil }
+}
+
+extension EnvironmentValues {
+    var _tableLayout: _TableLayout? {
+        get { self[_TableLayoutKey.self] }
+        set { self[_TableLayoutKey.self] = newValue }
+    }
+}
+
+// MARK: - Table
+
+/// How a table's column titles sort it: which column sorts it, ascending or
+/// not, and what tapping a title does (FoundationBridge makes one from a
+/// `sortOrder` binding).
+public struct _TableSort {
+    let order: (Int) -> Bool?
+    let tap: (Int) -> Void
+
+    /// `order(i)`: nil when column `i` does not sort the table, else whether it sorts ascending.
+    public init(order: @escaping (Int) -> Bool?, tap: @escaping (Int) -> Void) {
+        self.order = order
+        self.tap = tap
+    }
+}
+
+/// Rows with columns, drawn as a list (see the top of the file).
+public struct Table<Value: Identifiable, Rows, Columns: TableColumnContent>: View where Columns.TableRowValue == Value {
+    let columns: [_TableColumn<Value>]
+    let rows: AnyView
+    let selection: _ListSelection?
+    let sort: _TableSort?
+    @Environment(\.horizontalSizeClass) private var sizeClass
+
+    init(columns: Columns, rows: AnyView, selection: _ListSelection?, sort: _TableSort?) {
+        self.columns = columns._tableColumns
+        self.rows = rows
+        self.selection = selection
+        self.sort = sort
+    }
+
+    /// A table of `rows`, without selection or with one (FoundationBridge's `sortOrder` forms).
+    public init(_columns columns: Columns, rows: some View, sort: _TableSort?) {
+        self.init(columns: columns, rows: AnyView(rows), selection: nil, sort: sort)
+    }
+
+    public init(_columns columns: Columns, rows: some View, selection: Binding<Value.ID?>, sort: _TableSort?) {
+        self.init(columns: columns, rows: AnyView(rows), selection: _ListSelection(selection), sort: sort)
+    }
+
+    public init(_columns columns: Columns, rows: some View, selection: Binding<Set<Value.ID>>, sort: _TableSort?) {
+        self.init(columns: columns, rows: AnyView(rows), selection: _ListSelection(selection), sort: sort)
+    }
+
+    public var body: some View {
+        let compact = sizeClass != .regular
+        let layout = _TableLayout(columns: columns.map { column in
+            _TableLayout.Column(width: column.width, minWidth: column.minWidth, maxWidth: column.maxWidth) { value in
+                column.content(value as! Value)
+            }
+        }, compact: compact)
+        VStack(spacing: 0) {
+            if !compact { header(layout) }
+            List(_selection: selection) { rows }
+                .environment(\._tableLayout, layout)
+        }
+    }
+
+    /// The column titles, a sortable one a button with the sort's chevron.
+    private func header(_ layout: _TableLayout) -> some View {
+        HStack(spacing: _tableColumnSpacing) {
+            ForEach(columns.indices, id: \.self) { index in
+                _tableCell(layout.columns[index], title(index))
+            }
+        }
+        .font(.subheadline.weight(.semibold))
+        .foregroundStyle(.secondary)
+        .padding(.horizontal, 20)
+        .padding(.vertical, 8)
+    }
+
+    @ViewBuilder
+    private func title(_ index: Int) -> some View {
+        let column = columns[index]
+        if let sort, column.sortComparator != nil {
+            Button { sort.tap(index) } label: {
+                HStack(spacing: 4) {
+                    column.title
+                    if let ascending = sort.order(index) {
+                        Image(systemName: ascending ? "chevron.up" : "chevron.down").font(.caption2.weight(.bold))
+                    }
+                }
+            }
+            .buttonStyle(.plain)
+        } else {
+            column.title
+        }
+    }
+}
+
+extension Table {
+    public init(_ data: [Value], @TableColumnBuilder<Value, Never> columns: () -> Columns)
+    where Rows == TableForEachContent<[Value]> {
+        self.init(columns: columns(), rows: AnyView(ForEach(data) { TableRow($0) }), selection: nil, sort: nil)
+    }
+
+    @_disfavoredOverload
+    public init<Data: RandomAccessCollection>(_ data: Data, @TableColumnBuilder<Data.Element, Never> columns: () -> Columns)
+    where Rows == TableForEachContent<Data>, Data.Element == Value {
+        self.init(columns: columns(), rows: AnyView(ForEach(data) { TableRow($0) }), selection: nil, sort: nil)
+    }
+
+    public init(_ data: [Value], selection: Binding<Value.ID?>,
+                                              @TableColumnBuilder<Value, Never> columns: () -> Columns)
+    where Rows == TableForEachContent<[Value]> {
+        self.init(columns: columns(), rows: AnyView(ForEach(data) { TableRow($0) }), selection: _ListSelection(selection), sort: nil)
+    }
+
+    @_disfavoredOverload
+    public init<Data: RandomAccessCollection>(_ data: Data, selection: Binding<Value.ID?>,
+                                              @TableColumnBuilder<Data.Element, Never> columns: () -> Columns)
+    where Rows == TableForEachContent<Data>, Data.Element == Value {
+        self.init(columns: columns(), rows: AnyView(ForEach(data) { TableRow($0) }), selection: _ListSelection(selection), sort: nil)
+    }
+
+    public init(_ data: [Value], selection: Binding<Set<Value.ID>>,
+                                              @TableColumnBuilder<Value, Never> columns: () -> Columns)
+    where Rows == TableForEachContent<[Value]> {
+        self.init(columns: columns(), rows: AnyView(ForEach(data) { TableRow($0) }), selection: _ListSelection(selection), sort: nil)
+    }
+
+    @_disfavoredOverload
+    public init<Data: RandomAccessCollection>(_ data: Data, selection: Binding<Set<Value.ID>>,
+                                              @TableColumnBuilder<Data.Element, Never> columns: () -> Columns)
+    where Rows == TableForEachContent<Data>, Data.Element == Value {
+        self.init(columns: columns(), rows: AnyView(ForEach(data) { TableRow($0) }), selection: _ListSelection(selection), sort: nil)
+    }
+
+    public init(of valueType: Value.Type, @TableColumnBuilder<Value, Never> columns: () -> Columns,
+                @ViewBuilder rows: () -> Rows) where Rows: View {
+        self.init(columns: columns(), rows: AnyView(rows()), selection: nil, sort: nil)
+    }
+
+    public init(of valueType: Value.Type, selection: Binding<Value.ID?>, @TableColumnBuilder<Value, Never> columns: () -> Columns,
+                @ViewBuilder rows: () -> Rows) where Rows: View {
+        self.init(columns: columns(), rows: AnyView(rows()), selection: _ListSelection(selection), sort: nil)
+    }
+
+    public init(of valueType: Value.Type, selection: Binding<Set<Value.ID>>, @TableColumnBuilder<Value, Never> columns: () -> Columns,
+                @ViewBuilder rows: () -> Rows) where Rows: View {
+        self.init(columns: columns(), rows: AnyView(rows()), selection: _ListSelection(selection), sort: nil)
+    }
+}
+
+extension List {
+    /// A list with a selection made already (a table's).
+    init(_selection: _ListSelection?, @ViewBuilder content: () -> Content) {
+        self.content = content()
+        self.selection = _selection
+    }
+}
+
+// MARK: - Styles
+
+public protocol TableStyle {}
+public struct AutomaticTableStyle: TableStyle { public init() {} }
+public struct InsetTableStyle: TableStyle { public init() {} }
+
+extension TableStyle where Self == AutomaticTableStyle {
+    public static var automatic: AutomaticTableStyle { AutomaticTableStyle() }
+}
+
+extension TableStyle where Self == InsetTableStyle {
+    public static var inset: InsetTableStyle { InsetTableStyle() }
+}
+
+nonisolated extension View {
+    /// Accepted: a table is drawn as a list.
+    public func tableStyle<S: TableStyle>(_ style: S) -> some View { self }
+    /// Accepted: the titles show in a regular width only, as on iOS.
+    public func tableColumnHeaders(_ visibility: Visibility) -> some View { self }
+}

package/Sources/SwiftUI/API/Tabs.swift

@@ -0,0 +1,263 @@
+/// A view that switches between child views with a tab bar.
+public struct TabView<SelectionValue: Hashable, Content: View> {
+    let content: Content
+    let selection: Binding<SelectionValue>?
+    @State var selectedIndex = 0
+
+    public init(selection: Binding<SelectionValue>?, @ViewBuilder content: () -> Content) {
+        self.selection = selection
+        self.content = content()
+    }
+}
+
+extension TabView where SelectionValue == Int {
+    public init(@ViewBuilder content: () -> Content) {
+        self.selection = nil
+        self.content = content()
+    }
+}
+
+// The iOS 18 API: `Tab`s (see TabContent.swift) select by their `value`.
+extension TabView {
+    public init<C: TabContent>(selection: Binding<SelectionValue>,
+                               @TabContentBuilder<SelectionValue> content: () -> C)
+        where Content == TabContentBuilder<SelectionValue>.Content<C> {
+        self.selection = selection
+        self.content = TabContentBuilder<SelectionValue>.Content(content: content())
+    }
+}
+
+extension TabView where SelectionValue == Never {
+    public init<C: TabContent>(@TabContentBuilder<Never> content: () -> C)
+        where Content == TabContentBuilder<Never>.Content<C> {
+        self.selection = nil
+        self.content = TabContentBuilder<Never>.Content(content: content())
+    }
+}
+
+protocol _TabViewHost: _TraitBearing {
+    var _tabContent: any View { get }
+    /// Index of the selected tab given the tabs' tags, and a setter.
+    func _selectedIndex(tags: [AnyHashable?]) -> Int
+    func _select(index: Int, tags: [AnyHashable?])
+}
+
+extension TabView: _PrimitiveView {}
+extension TabView: _HostView {
+    var _kind: String { "tabview" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object([:]) }
+    // Children and props are produced by the runtime.
+}
+extension TabView: _TabViewHost {
+    var _tabContent: any View { content }
+
+    func _selectedIndex(tags: [AnyHashable?]) -> Int {
+        if let selection {
+            let current = AnyHashable(selection.wrappedValue)
+            return tags.firstIndex { $0 == current } ?? 0
+        }
+        return min(selectedIndex, max(0, tags.count - 1))
+    }
+
+    func _select(index: Int, tags: [AnyHashable?]) {
+        if let selection {
+            if index < tags.count, let tag = tags[index], let value = tag.base as? SelectionValue {
+                selection.wrappedValue = value
+            }
+        } else {
+            selectedIndex = index
+        }
+    }
+}
+
+/// One tab, produced by the runtime from the TabView's content.
+struct _TabScreenView {
+    let content: any View
+    let title: String
+    let systemImage: String?
+    /// Only the selected tab's `navigationTitle` and `.toolbar` reach the
+    /// enclosing screen (a tab's own `NavigationStack` is flattened into it).
+    var isSelected = true
+    /// A `Tab`'s `.badge` (never set by the `.tabItem` API).
+    var badge: String?
+    /// A `Tab`'s role (`"search"`).
+    var role: String?
+}
+extension _TabScreenView: _PrimitiveView {}
+extension _TabScreenView: _HostView {
+    var _kind: String { "tab" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        var props: [String: _JSON] = ["title": .string(title), "systemImage": systemImage.map(_JSON.string) ?? .null]
+        // Only present when set, so `.tabItem` tabs keep their exact props.
+        if let badge { props["badge"] = .string(badge) }
+        if let role { props["role"] = .string(role) }
+        return .object(props)
+    }
+    var _content: [any View] { [content] }
+}
+
+extension _TabScreenView {
+    /// The tab for one of a tab view's flattened children: its `.tabItem` /
+    /// `Tab` label gives the title and symbol; a `Tab` adds its badge and role,
+    /// and a search tab without a title or symbol is "Search" with a
+    /// magnifying glass.
+    @MainActor
+    init(root: any View, isSelected: Bool) {
+        let label = _tabLabel(of: root)
+        var title = label.map { _textContent(of: $0) } ?? ""
+        var systemImage = label.flatMap { _systemImage(of: $0) }
+        let entry = (root as? _TabEntryView)?.entry
+        if entry?.role == .search {
+            if title.isEmpty { title = "Search" }
+            if systemImage == nil { systemImage = "magnifyingglass" }
+        }
+        self.init(content: root, title: title, systemImage: systemImage, isSelected: isSelected,
+                  badge: entry?.modifiers.badge, role: entry?.role?.name)
+    }
+}
+
+// MARK: - .tabItem and .tag
+
+protocol _TabItemProviding {
+    var _tabLabel: any View { get }
+    var _tabContent: any View { get }
+}
+
+struct _TabItemView<Content: View, Label: View> {
+    let content: Content
+    let label: Label
+}
+extension _TabItemView: _PrimitiveView {}
+extension _TabItemView: _GroupView {
+    var _children: [any View] { [content] }
+}
+extension _TabItemView: _TabItemProviding {
+    var _tabLabel: any View { label }
+    var _tabContent: any View { content }
+}
+
+protocol _TagProviding: _TraitBearing {
+    var _tag: AnyHashable { get }
+    var _tagged: any View { get }
+}
+
+struct _TagView<Content: View, Tag: Hashable> {
+    let content: Content
+    let tag: Tag
+}
+extension _TagView: _PrimitiveView {}
+extension _TagView: _GroupView {
+    var _children: [any View] { [content] }
+}
+extension _TagView: _TagProviding {
+    var _tag: AnyHashable { AnyHashable(tag) }
+    var _tagged: any View { content }
+}
+
+nonisolated extension View {
+    public func tabItem<Label: View>(@ViewBuilder _ label: () -> Label) -> some View {
+        _TabItemView(content: self, label: label())
+    }
+
+    public func tag<Tag: Hashable>(_ tag: Tag) -> some View {
+        _TagView(content: self, tag: tag)
+    }
+}
+
+// MARK: - Sidebar (regular-width `.sidebarAdaptable`)
+
+/// Whether a tab view shows its tabs as a sidebar: `.sidebarAdaptable` in
+/// regular width, unless its default placement is `.tabBar`.
+func _tabViewIsSidebar(_ environment: EnvironmentValues) -> Bool {
+    environment._tabViewStyle == "sidebarAdaptable" && environment.horizontalSizeClass == .regular
+        && environment._tabBarPlacement != "tabBar"
+}
+
+/// One sidebar row: a tab, by its index among the tab view's children.
+struct _TabSidebarRow {
+    let index: Int
+    let title: String
+    let systemImage: String?
+    let badge: String?
+}
+
+/// The rows of one `TabSection` (or of consecutive tabs outside sections).
+struct _TabSidebarGroup {
+    let header: String?
+    let rows: [_TabSidebarRow]
+}
+
+/// A regular-width `.sidebarAdaptable` tab view: a `NavigationSplitView` whose
+/// sidebar is a `List(selection:)` of the tabs in declaration order (a section
+/// per `TabSection`, under its header) and whose detail is the selected tab's
+/// content. Selecting a row selects the tab as a bar item would.
+@MainActor
+func _tabSidebar(roots: [any View], selected: Int, select: @escaping (Int) -> Void) -> any View {
+    let rows = roots.enumerated().map { index, root in
+        let entry = root as? _TabEntryView
+        let tab = _TabScreenView(root: root, isSelected: false)
+        return (order: entry?.order ?? index, section: entry?.entry.section, header: entry?.sectionHeader,
+                row: _TabSidebarRow(index: index, title: tab.title, systemImage: tab.systemImage, badge: tab.badge))
+    }.sorted { $0.order < $1.order }
+    var groups: [_TabSidebarGroup] = []
+    var start = 0
+    while start < rows.count {
+        var end = start + 1
+        while end < rows.count, rows[end].section == rows[start].section { end += 1 }
+        let header = rows[start].header.map { _textContent(of: $0) }
+        groups.append(_TabSidebarGroup(header: header?.isEmpty == false ? header : nil,
+                                       rows: rows[start..<end].map(\.row)))
+        start = end
+    }
+    let detail = roots.indices.contains(selected) ? roots[selected] : EmptyView()
+    return NavigationSplitView {
+        _TabSidebarList(groups: groups, selection: Binding(get: { selected }, set: { if let index = $0 { select(index) } }))
+    } detail: {
+        // Keyed by the tab, so each tab's content has its own state.
+        ForEach([selected], id: \.self) { _ in _TabSidebarDetail(content: detail) }
+    }
+}
+
+struct _TabSidebarList: View {
+    let groups: [_TabSidebarGroup]
+    let selection: Binding<Int?>
+
+    var body: some View {
+        List(selection: selection) {
+            ForEach(groups.indices, id: \.self) { index in
+                if let header = groups[index].header {
+                    Section(header) { _TabSidebarRows(rows: groups[index].rows) }
+                } else {
+                    _TabSidebarRows(rows: groups[index].rows)
+                }
+            }
+        }
+    }
+}
+
+struct _TabSidebarRows: View {
+    let rows: [_TabSidebarRow]
+
+    var body: some View {
+        ForEach(rows, id: \.index) { row in
+            Group {
+                if let systemImage = row.systemImage {
+                    Label(row.title, systemImage: systemImage)
+                } else {
+                    Text(row.title)
+                }
+            }
+            .badge(row.badge)
+            .tag(row.index)
+        }
+    }
+}
+
+/// The selected tab's content in the detail column.
+struct _TabSidebarDetail {
+    let content: any View
+}
+extension _TabSidebarDetail: _PrimitiveView {}
+extension _TabSidebarDetail: _GroupView {
+    var _children: [any View] { [content] }
+}

package/Sources/SwiftUI/API/Tasks.swift

@@ -0,0 +1,35 @@
+/// Views that start an asynchronous task when they appear.
+protocol _TaskStarting: _TraitBearing {
+    /// Identity of the task; when it changes the task restarts.
+    var _taskID: AnyHashable? { get }
+    var _taskAction: @Sendable () async -> Void { get }
+}
+
+struct _TaskView<Content: View> {
+    let content: Content
+    let id: AnyHashable?
+    let action: @Sendable () async -> Void
+}
+extension _TaskView: _PrimitiveView {}
+extension _TaskView: _GroupView {
+    var _children: [any View] { [content] }
+}
+extension _TaskView: _TaskStarting {
+    var _taskID: AnyHashable? { id }
+    var _taskAction: @Sendable () async -> Void { action }
+}
+
+nonisolated extension View {
+    /// Runs `action` in a task when the view appears, cancelling it when the
+    /// view disappears.
+    public func task(priority: TaskPriority = .userInitiated,
+                     @_inheritActorContext _ action: @escaping @Sendable () async -> Void) -> some View {
+        _TaskView(content: self, id: nil, action: action)
+    }
+
+    /// Like `task(_:)`, restarting the task whenever `id` changes.
+    public func task<T: Hashable>(id: T, priority: TaskPriority = .userInitiated,
+                                  @_inheritActorContext _ action: @escaping @Sendable () async -> Void) -> some View {
+        _TaskView(content: self, id: AnyHashable(id), action: action)
+    }
+}