@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/SwiftUI/API/TabContent.swift

@@ -0,0 +1,841 @@
+// The iOS 18 tab API: `Tab`, `TabSection`, `TabContent` and its result
+// builder, `TabRole`, placements, styles and customization.
+//
+// Tab content resolves to `_TabEntry`s, one per `Tab`, in declaration order
+// (sections flattened, a `.search` tab moved to the trailing end). Each entry
+// becomes a `_TabEntryView`, which is to the runtime exactly what
+// `content.tabItem { label }.tag(value)` is, so a `TabView` of `Tab`s emits the
+// same `tabview` / `tab` elements as the `.tabItem` API, plus a `tab`'s
+// `badge` and `role` props when they are set. In a regular-width
+// `.sidebarAdaptable` tab view the tabs are a sidebar instead (see
+// `_tabSidebar` in Tabs.swift). See docs/ops-protocol.md, "Tabs (iOS 18)".
+
+import Foundation
+
+/// The content of a `TabView` built with `Tab`s: tabs, sections of tabs,
+/// `ForEach` over them, or a type with a `body`. Like `ChartContent` it is not
+/// main-actor isolated: tabs are created in nonisolated initializers (as in
+/// SwiftUI, where `Tab`'s initializers are `nonisolated`).
+public protocol TabContent<TabValue> {
+    associatedtype TabValue: Hashable
+    associatedtype Body: TabContent
+    @TabContentBuilder<TabValue> var body: Self.Body { get }
+}
+
+extension Never: @preconcurrency TabContent {
+    public typealias TabValue = Never
+}
+
+/// Tab content the runtime reads directly instead of evaluating `body`.
+public protocol _PrimitiveTabContent: TabContent where Body == Never {}
+
+extension _PrimitiveTabContent {
+    public var body: Never { fatalError("\(Self.self) is primitive tab content and has no body") }
+}
+
+// MARK: - Entries
+
+/// What the modifiers on tab content set; an inner modifier overrides an outer one.
+struct _TabModifiers {
+    var badge: String?
+    var hidden = false
+    var placement: TabPlacement?
+    var customizationID: String?
+    var hiddenIn: Set<TabBarPlacement> = []
+}
+
+/// One `Tab`, resolved.
+struct _TabEntry {
+    let content: any View
+    let label: any View
+    let value: AnyHashable?
+    let role: TabRole?
+    let modifiers: _TabModifiers
+    /// Index of the enclosing `TabSection` in `_TabCollector.sections`.
+    let section: Int?
+}
+
+struct _TabCollector {
+    var entries: [_TabEntry] = []
+    /// The sections' headers, in declaration order.
+    var sections: [any View] = []
+    var section: Int?
+}
+
+/// Internal: contributes tab entries.
+protocol _TabContentNode {
+    func _collect(into collector: inout _TabCollector, modifiers: _TabModifiers)
+}
+
+extension TabContent {
+    func _collectAny(into collector: inout _TabCollector, modifiers: _TabModifiers) {
+        if let node = self as? any _TabContentNode {
+            node._collect(into: &collector, modifiers: modifiers)
+        } else {
+            body._collectAny(into: &collector, modifiers: modifiers)
+        }
+    }
+}
+
+/// One tab as a view: to the runtime it is `content.tabItem { label }.tag(value)`
+/// (a `_TabItemProviding` and `_TagProviding` group of the content), and it
+/// carries the badge, role and section for the `tab` element and the sidebar.
+struct _TabEntryView {
+    let entry: _TabEntry
+    /// The section's header, when the tab is in a `TabSection`.
+    let sectionHeader: (any View)?
+    /// The position of the tab in declaration order (the sidebar's row order).
+    let order: Int
+}
+extension _TabEntryView: _PrimitiveView {}
+extension _TabEntryView: _GroupView {
+    var _children: [any View] { [entry.content] }
+}
+extension _TabEntryView: _TabItemProviding {
+    var _tabLabel: any View { entry.label }
+    var _tabContent: any View { entry.content }
+}
+extension _TabEntryView: _TagProviding {
+    /// A tab without a value (`Value == Never`) is only selected by index.
+    var _tag: AnyHashable { entry.value ?? AnyHashable(_UntaggedTab()) }
+    var _tagged: any View { entry.content }
+}
+
+struct _UntaggedTab: Hashable {}
+
+// MARK: - Tab
+
+/// The semantic role of a tab. A `.search` tab sits at the trailing end of the
+/// tab bar; without a title or image of its own it is "Search" with a
+/// magnifying glass.
+public struct TabRole: Hashable, Sendable {
+    let name: String
+    public static let search = TabRole(name: "search")
+}
+
+/// The label of a tab made from a title and an image.
+public struct DefaultTabLabel {
+    let title: Text
+    let systemImage: String?
+    let image: String?
+}
+extension DefaultTabLabel: View {
+    public var body: some View {
+        if let systemImage {
+            Label { title } icon: { Image(systemName: systemImage) }
+        } else if let image {
+            Label { title } icon: { Image(image) }
+        } else {
+            title
+        }
+    }
+}
+
+/// A tab of a `TabView`: its content, a label for the tab bar (or sidebar),
+/// and the `value` the tab view's `selection` takes when it is selected.
+public struct Tab<Value: Hashable, Content: View, Label: View> {
+    let value: Value?
+    let role: TabRole?
+    let content: Content
+    let label: Label
+
+    init(_value value: Value?, role: TabRole?, content: Content, label: Label) {
+        self.value = value
+        self.role = role
+        self.content = content
+        self.label = label
+    }
+}
+extension Tab: _PrimitiveTabContent {
+    public typealias TabValue = Value
+}
+extension Tab: _TabContentNode {
+    func _collect(into collector: inout _TabCollector, modifiers: _TabModifiers) {
+        collector.entries.append(_TabEntry(
+            content: content, label: label, value: value.map { AnyHashable($0) },
+            role: role, modifiers: modifiers, section: collector.section))
+    }
+}
+
+extension DefaultTabLabel {
+    init(_ title: Text, systemImage: String? = nil, image: String? = nil) {
+        self.title = title
+        self.systemImage = systemImage
+        self.image = image
+    }
+}
+
+// Titles, as SwiftUI takes them: a string, a localized key or a resource.
+// `LocalizedStringResource` is declared in FoundationBridge, which depends on
+// this module, so the resource initializers take any `CustomStringConvertible`
+// (disfavored, so strings and keys pick their own overloads): a resource's
+// `description` is its localized text.
+extension Text {
+    init<R: CustomStringConvertible>(_tabResource resource: R) {
+        self.init(verbatim: resource.description)
+    }
+}
+
+extension Tab where Label == DefaultTabLabel {
+    // With a value.
+
+    public nonisolated init<S: StringProtocol>(_ title: S, systemImage: String, value: Value,
+                                               @ViewBuilder content: () -> Content) {
+        self.init(_value: value, role: nil, content: content(), label: DefaultTabLabel(Text(title), systemImage: systemImage))
+    }
+
+    public nonisolated init<S: StringProtocol>(_ title: S, systemImage: String, value: Value, role: TabRole?,
+                                               @ViewBuilder content: () -> Content) {
+        self.init(_value: value, role: role, content: content(), label: DefaultTabLabel(Text(title), systemImage: systemImage))
+    }
+
+    public nonisolated init(_ titleKey: LocalizedStringKey, systemImage: String, value: Value,
+                            @ViewBuilder content: () -> Content) {
+        self.init(_value: value, role: nil, content: content(), label: DefaultTabLabel(Text(titleKey), systemImage: systemImage))
+    }
+
+    public nonisolated init(_ titleKey: LocalizedStringKey, systemImage: String, value: Value, role: TabRole?,
+                            @ViewBuilder content: () -> Content) {
+        self.init(_value: value, role: role, content: content(), label: DefaultTabLabel(Text(titleKey), systemImage: systemImage))
+    }
+
+    @_disfavoredOverload
+    public nonisolated init<R: CustomStringConvertible>(_ titleResource: R, systemImage: String, value: Value,
+                            @ViewBuilder content: () -> Content) {
+        self.init(_value: value, role: nil, content: content(),
+                  label: DefaultTabLabel(Text(_tabResource: titleResource), systemImage: systemImage))
+    }
+
+    @_disfavoredOverload
+    public nonisolated init<R: CustomStringConvertible>(_ titleResource: R, systemImage: String, value: Value, role: TabRole?,
+                            @ViewBuilder content: () -> Content) {
+        self.init(_value: value, role: role, content: content(),
+                  label: DefaultTabLabel(Text(_tabResource: titleResource), systemImage: systemImage))
+    }
+
+    public nonisolated init<S: StringProtocol>(_ title: S, image: String, value: Value, role: TabRole? = nil,
+                                               @ViewBuilder content: () -> Content) {
+        self.init(_value: value, role: role, content: content(), label: DefaultTabLabel(Text(title), image: image))
+    }
+
+    public nonisolated init(_ titleKey: LocalizedStringKey, image: String, value: Value, role: TabRole? = nil,
+                            @ViewBuilder content: () -> Content) {
+        self.init(_value: value, role: role, content: content(), label: DefaultTabLabel(Text(titleKey), image: image))
+    }
+
+    /// A tab with only a role (`Tab(value: .search, role: .search) { … }`):
+    /// its label comes from the role.
+    public nonisolated init(value: Value, role: TabRole, @ViewBuilder content: () -> Content) {
+        self.init(_value: value, role: role, content: content(), label: DefaultTabLabel(Text(verbatim: "")))
+    }
+
+    // With an optional value (`TabView(selection: Binding<T?>)`).
+
+    public nonisolated init<S: StringProtocol, T: Hashable>(_ title: S, systemImage: String, value: T,
+                                                            @ViewBuilder content: () -> Content) where Value == T? {
+        self.init(_value: Optional(value), role: nil, content: content(), label: DefaultTabLabel(Text(title), systemImage: systemImage))
+    }
+
+    public nonisolated init<S: StringProtocol, T: Hashable>(_ title: S, systemImage: String, value: T, role: TabRole?,
+                                                            @ViewBuilder content: () -> Content) where Value == T? {
+        self.init(_value: Optional(value), role: role, content: content(), label: DefaultTabLabel(Text(title), systemImage: systemImage))
+    }
+
+    public nonisolated init<T: Hashable>(_ titleKey: LocalizedStringKey, systemImage: String, value: T,
+                                         @ViewBuilder content: () -> Content) where Value == T? {
+        self.init(_value: Optional(value), role: nil, content: content(), label: DefaultTabLabel(Text(titleKey), systemImage: systemImage))
+    }
+
+    public nonisolated init<T: Hashable>(_ titleKey: LocalizedStringKey, systemImage: String, value: T, role: TabRole?,
+                                         @ViewBuilder content: () -> Content) where Value == T? {
+        self.init(_value: Optional(value), role: role, content: content(), label: DefaultTabLabel(Text(titleKey), systemImage: systemImage))
+    }
+
+    @_disfavoredOverload
+    public nonisolated init<R: CustomStringConvertible, T: Hashable>(_ titleResource: R, systemImage: String, value: T,
+                                         @ViewBuilder content: () -> Content) where Value == T? {
+        self.init(_value: Optional(value), role: nil, content: content(),
+                  label: DefaultTabLabel(Text(_tabResource: titleResource), systemImage: systemImage))
+    }
+
+    @_disfavoredOverload
+    public nonisolated init<R: CustomStringConvertible, T: Hashable>(_ titleResource: R, systemImage: String, value: T,
+                                         role: TabRole?, @ViewBuilder content: () -> Content) where Value == T? {
+        self.init(_value: Optional(value), role: role, content: content(),
+                  label: DefaultTabLabel(Text(_tabResource: titleResource), systemImage: systemImage))
+    }
+}
+
+extension Tab {
+    /// A tab with a custom label.
+    public nonisolated init(value: Value, @ViewBuilder content: () -> Content, @ViewBuilder label: () -> Label) {
+        self.init(_value: value, role: nil, content: content(), label: label())
+    }
+
+    public nonisolated init(value: Value, role: TabRole?, @ViewBuilder content: () -> Content,
+                            @ViewBuilder label: () -> Label) {
+        self.init(_value: value, role: role, content: content(), label: label())
+    }
+
+    public nonisolated init<T: Hashable>(value: T, @ViewBuilder content: () -> Content,
+                                         @ViewBuilder label: () -> Label) where Value == T? {
+        self.init(_value: Optional(value), role: nil, content: content(), label: label())
+    }
+
+    public nonisolated init<T: Hashable>(value: T, role: TabRole?, @ViewBuilder content: () -> Content,
+                                         @ViewBuilder label: () -> Label) where Value == T? {
+        self.init(_value: Optional(value), role: role, content: content(), label: label())
+    }
+}
+
+// Tabs without a value (a `TabView` without a selection binding).
+
+extension Tab where Value == Never, Label == DefaultTabLabel {
+    public nonisolated init<S: StringProtocol>(_ title: S, systemImage: String, @ViewBuilder content: () -> Content) {
+        self.init(_value: nil, role: nil, content: content(), label: DefaultTabLabel(Text(title), systemImage: systemImage))
+    }
+
+    public nonisolated init<S: StringProtocol>(_ title: S, systemImage: String, role: TabRole?,
+                                               @ViewBuilder content: () -> Content) {
+        self.init(_value: nil, role: role, content: content(), label: DefaultTabLabel(Text(title), systemImage: systemImage))
+    }
+
+    public nonisolated init(_ titleKey: LocalizedStringKey, systemImage: String, @ViewBuilder content: () -> Content) {
+        self.init(_value: nil, role: nil, content: content(), label: DefaultTabLabel(Text(titleKey), systemImage: systemImage))
+    }
+
+    public nonisolated init(_ titleKey: LocalizedStringKey, systemImage: String, role: TabRole?,
+                            @ViewBuilder content: () -> Content) {
+        self.init(_value: nil, role: role, content: content(), label: DefaultTabLabel(Text(titleKey), systemImage: systemImage))
+    }
+
+    @_disfavoredOverload
+    public nonisolated init<R: CustomStringConvertible>(_ titleResource: R, systemImage: String,
+                            @ViewBuilder content: () -> Content) {
+        self.init(_value: nil, role: nil, content: content(),
+                  label: DefaultTabLabel(Text(_tabResource: titleResource), systemImage: systemImage))
+    }
+
+    @_disfavoredOverload
+    public nonisolated init<R: CustomStringConvertible>(_ titleResource: R, systemImage: String, role: TabRole?,
+                            @ViewBuilder content: () -> Content) {
+        self.init(_value: nil, role: role, content: content(),
+                  label: DefaultTabLabel(Text(_tabResource: titleResource), systemImage: systemImage))
+    }
+
+    public nonisolated init<S: StringProtocol>(_ title: S, image: String, role: TabRole? = nil,
+                                               @ViewBuilder content: () -> Content) {
+        self.init(_value: nil, role: role, content: content(), label: DefaultTabLabel(Text(title), image: image))
+    }
+
+    public nonisolated init(role: TabRole, @ViewBuilder content: () -> Content) {
+        self.init(_value: nil, role: role, content: content(), label: DefaultTabLabel(Text(verbatim: "")))
+    }
+}
+
+extension Tab where Value == Never {
+    public nonisolated init(@ViewBuilder content: () -> Content, @ViewBuilder label: () -> Label) {
+        self.init(_value: nil, role: nil, content: content(), label: label())
+    }
+
+    public nonisolated init(role: TabRole?, @ViewBuilder content: () -> Content, @ViewBuilder label: () -> Label) {
+        self.init(_value: nil, role: role, content: content(), label: label())
+    }
+}
+
+// MARK: - TabSection
+
+/// A group of tabs. In a tab bar the section's tabs are tabs of their own
+/// (flattened in order); in a regular-width `.sidebarAdaptable` sidebar they
+/// are a list section under the header.
+public struct TabSection<Header: View, Content: TabContent, Footer: View> {
+    let header: Header
+    let content: Content
+    let footer: Footer
+}
+extension TabSection: _PrimitiveTabContent {
+    public typealias TabValue = Content.TabValue
+}
+extension TabSection: _TabContentNode {
+    func _collect(into collector: inout _TabCollector, modifiers: _TabModifiers) {
+        let outer = collector.section
+        collector.sections.append(header)
+        collector.section = collector.sections.count - 1
+        content._collectAny(into: &collector, modifiers: modifiers)
+        collector.section = outer
+    }
+}
+
+extension TabSection where Header == Text, Footer == EmptyView {
+    public nonisolated init<V>(_ titleKey: LocalizedStringKey, @TabContentBuilder<V> content: () -> Content)
+        where V == Content.TabValue {
+        self.init(header: Text(titleKey), content: content(), footer: EmptyView())
+    }
+
+    @_disfavoredOverload
+    public nonisolated init<S: StringProtocol, V>(_ title: S, @TabContentBuilder<V> content: () -> Content)
+        where V == Content.TabValue {
+        self.init(header: Text(title), content: content(), footer: EmptyView())
+    }
+
+    @_disfavoredOverload
+    public nonisolated init<R: CustomStringConvertible, V>(_ titleResource: R,
+                                                           @TabContentBuilder<V> content: () -> Content)
+        where V == Content.TabValue {
+        self.init(header: Text(_tabResource: titleResource), content: content(), footer: EmptyView())
+    }
+}
+
+extension TabSection where Header == EmptyView, Footer == EmptyView {
+    public nonisolated init<V>(@TabContentBuilder<V> content: () -> Content) where V == Content.TabValue {
+        self.init(header: EmptyView(), content: content(), footer: EmptyView())
+    }
+}
+
+extension TabSection where Footer == EmptyView {
+    public nonisolated init<V>(@TabContentBuilder<V> content: () -> Content, @ViewBuilder header: () -> Header)
+        where V == Content.TabValue {
+        self.init(header: header(), content: content(), footer: EmptyView())
+    }
+}
+
+extension TabSection {
+    public nonisolated init<V>(@TabContentBuilder<V> content: () -> Content,
+                               @ViewBuilder header: () -> Header, @ViewBuilder footer: () -> Footer)
+        where V == Content.TabValue {
+        self.init(header: header(), content: content(), footer: footer())
+    }
+
+    /// Actions for the section's header in an iPadOS sidebar: accepted, not shown.
+    public nonisolated func sectionActions<A: View>(@ViewBuilder content: () -> A) -> some TabContent<TabValue> {
+        self
+    }
+}
+
+// MARK: - Structural content
+
+public struct _EmptyTabContent<TabValue: Hashable> {
+    public init() {}
+}
+extension _EmptyTabContent: _PrimitiveTabContent {}
+extension _EmptyTabContent: _TabContentNode {
+    func _collect(into collector: inout _TabCollector, modifiers: _TabModifiers) {}
+}
+
+public struct _TupleTabContent<TabValue: Hashable, T> {
+    let children: [any TabContent]
+}
+extension _TupleTabContent: _PrimitiveTabContent {}
+extension _TupleTabContent: _TabContentNode {
+    func _collect(into collector: inout _TabCollector, modifiers: _TabModifiers) {
+        for child in children { child._collectAny(into: &collector, modifiers: modifiers) }
+    }
+}
+
+public struct _ConditionalTabContent<TrueContent: TabContent, FalseContent: TabContent>
+    where TrueContent.TabValue == FalseContent.TabValue {
+    enum Storage {
+        case trueContent(TrueContent)
+        case falseContent(FalseContent)
+    }
+    let storage: Storage
+}
+extension _ConditionalTabContent: _PrimitiveTabContent {
+    public typealias TabValue = TrueContent.TabValue
+}
+extension _ConditionalTabContent: _TabContentNode {
+    func _collect(into collector: inout _TabCollector, modifiers: _TabModifiers) {
+        switch storage {
+        case .trueContent(let content): content._collectAny(into: &collector, modifiers: modifiers)
+        case .falseContent(let content): content._collectAny(into: &collector, modifiers: modifiers)
+        }
+    }
+}
+
+extension Optional: TabContent where Wrapped: TabContent {
+    public typealias TabValue = Wrapped.TabValue
+    public typealias Body = Never
+    public var body: Never { return fatalError("Optional is primitive tab content and has no body") }
+}
+extension Optional: _TabContentNode where Wrapped: TabContent {
+    func _collect(into collector: inout _TabCollector, modifiers: _TabModifiers) {
+        if case .some(let content) = self { content._collectAny(into: &collector, modifiers: modifiers) }
+    }
+}
+
+public struct _ArrayTabContent<Element: TabContent> {
+    let elements: [Element]
+}
+extension _ArrayTabContent: _PrimitiveTabContent {
+    public typealias TabValue = Element.TabValue
+}
+extension _ArrayTabContent: _TabContentNode {
+    func _collect(into collector: inout _TabCollector, modifiers: _TabModifiers) {
+        for element in elements { element._collectAny(into: &collector, modifiers: modifiers) }
+    }
+}
+
+/// Type-erased tab content.
+public struct AnyTabContent<TabValue: Hashable> {
+    let storage: any TabContent
+    public init<C: TabContent>(_ content: C) where C.TabValue == TabValue { storage = content }
+    public init<C: TabContent>(erasing content: C) where C.TabValue == TabValue { storage = content }
+}
+extension AnyTabContent: _PrimitiveTabContent {}
+extension AnyTabContent: _TabContentNode {
+    func _collect(into collector: inout _TabCollector, modifiers: _TabModifiers) {
+        storage._collectAny(into: &collector, modifiers: modifiers)
+    }
+}
+
+/// `ForEach` over tab content: the tabs of every element, in order.
+extension ForEach: TabContent where Content: TabContent {
+    public typealias TabValue = Content.TabValue
+    public typealias Body = Never
+    public var body: Never { return fatalError("ForEach is primitive tab content and has no body") }
+}
+extension ForEach: _TabContentNode where Content: TabContent {
+    func _collect(into collector: inout _TabCollector, modifiers: _TabModifiers) {
+        for element in data { content(element)._collectAny(into: &collector, modifiers: modifiers) }
+    }
+}
+
+extension ForEach where Content: TabContent {
+    public init<V>(_ data: Data, id: KeyPath<Data.Element, ID>,
+                   @TabContentBuilder<V> content: @escaping (Data.Element) -> Content) where V == Content.TabValue {
+        self.init(_data: data, id: { $0[keyPath: id] }, content: content)
+    }
+}
+
+extension ForEach where Content: TabContent, Data.Element: Identifiable, ID == Data.Element.ID {
+    public init<V>(_ data: Data, @TabContentBuilder<V> content: @escaping (Data.Element) -> Content)
+        where V == Content.TabValue {
+        self.init(_data: data, id: { $0.id }, content: content)
+    }
+}
+
+extension ForEach where Content: TabContent, Data == Range<Int>, ID == Int {
+    public init<V>(_ data: Range<Int>, @TabContentBuilder<V> content: @escaping (Int) -> Content)
+        where V == Content.TabValue {
+        self.init(_data: data, id: { $0 }, content: content)
+    }
+}
+
+// MARK: - TabContentBuilder
+
+@resultBuilder
+public struct TabContentBuilder<SelectionValue: Hashable> {
+    public static func buildBlock() -> _EmptyTabContent<SelectionValue> { _EmptyTabContent() }
+
+    public static func buildBlock<C: TabContent>(_ content: C) -> C where C.TabValue == SelectionValue { content }
+
+    public static func buildBlock<each C: TabContent>(
+        _ content: repeat each C
+    ) -> _TupleTabContent<SelectionValue, (repeat each C)> {
+        var children: [any TabContent] = []
+        for child in repeat each content { children.append(child) }
+        return _TupleTabContent(children: children)
+    }
+
+    public static func buildExpression<C: TabContent>(_ content: C) -> C where C.TabValue == SelectionValue { content }
+
+    public static func buildOptional<C: TabContent>(_ content: C?) -> C? where C.TabValue == SelectionValue { content }
+
+    public static func buildEither<TrueContent: TabContent, FalseContent: TabContent>(
+        first: TrueContent
+    ) -> _ConditionalTabContent<TrueContent, FalseContent>
+        where TrueContent.TabValue == SelectionValue, FalseContent.TabValue == SelectionValue {
+        _ConditionalTabContent(storage: .trueContent(first))
+    }
+
+    public static func buildEither<TrueContent: TabContent, FalseContent: TabContent>(
+        second: FalseContent
+    ) -> _ConditionalTabContent<TrueContent, FalseContent>
+        where TrueContent.TabValue == SelectionValue, FalseContent.TabValue == SelectionValue {
+        _ConditionalTabContent(storage: .falseContent(second))
+    }
+
+    public static func buildArray<C: TabContent>(_ components: [C]) -> _ArrayTabContent<C> where C.TabValue == SelectionValue {
+        _ArrayTabContent(elements: components)
+    }
+
+    public static func buildLimitedAvailability<C: TabContent>(_ content: C) -> AnyTabContent<SelectionValue>
+        where C.TabValue == SelectionValue {
+        AnyTabContent(content)
+    }
+
+    /// A `TabView`'s content: the tab entries of `C` as `_TabEntryView`s.
+    public struct Content<C: TabContent> where C.TabValue == SelectionValue {
+        let content: C
+    }
+}
+extension TabContentBuilder.Content: _PrimitiveView {}
+extension TabContentBuilder.Content: _GroupView {
+    /// The tabs in tab bar order: hidden tabs dropped and `.search` tabs moved
+    /// to the trailing end (where iOS puts the search tab).
+    var _children: [any View] {
+        var collector = _TabCollector()
+        content._collectAny(into: &collector, modifiers: _TabModifiers())
+        let declared = collector.entries.enumerated().filter { !$0.element.modifiers.hidden }
+        let ordered = declared.filter { $0.element.role != .search } + declared.filter { $0.element.role == .search }
+        return ordered.map { order, entry in
+            _TabEntryView(entry: entry, sectionHeader: entry.section.map { collector.sections[$0] }, order: order)
+        }
+    }
+}
+
+// MARK: - Modifiers
+
+/// Tab content with a modifier applied to every tab beneath it.
+public struct _ModifiedTabContent<Content: TabContent> {
+    let content: Content
+    let transform: (inout _TabModifiers) -> Void
+}
+extension _ModifiedTabContent: _PrimitiveTabContent {
+    public typealias TabValue = Content.TabValue
+}
+extension _ModifiedTabContent: _TabContentNode {
+    func _collect(into collector: inout _TabCollector, modifiers: _TabModifiers) {
+        // Outer modifiers run first so that the tab's own (inner) ones win.
+        var modified = modifiers
+        transform(&modified)
+        content._collectAny(into: &collector, modifiers: modified)
+    }
+}
+
+/// Where a tab may appear when the tab bar and sidebar are customizable.
+/// Recorded only: every tab appears in the tab bar (compact) and the sidebar
+/// (regular `.sidebarAdaptable`).
+public struct TabPlacement: Hashable, Sendable {
+    let name: String
+    public static let automatic = TabPlacement(name: "automatic")
+    public static let pinned = TabPlacement(name: "pinned")
+    public static let sidebarOnly = TabPlacement(name: "sidebarOnly")
+}
+
+/// The bar a `TabView` shows its tabs in.
+public struct TabBarPlacement: Hashable, Sendable {
+    let name: String
+    public static let automatic = TabBarPlacement(name: "automatic")
+    public static let tabBar = TabBarPlacement(name: "tabBar")
+    public static let sidebar = TabBarPlacement(name: "sidebar")
+    public static let ornament = TabBarPlacement(name: "ornament")
+    public static let topBar = TabBarPlacement(name: "topBar")
+    public static let bottomBar = TabBarPlacement(name: "bottomBar")
+}
+
+/// The placement a `.sidebarAdaptable` tab view starts in.
+public struct AdaptableTabBarPlacement: Hashable, Sendable {
+    let name: String
+    public static let automatic = AdaptableTabBarPlacement(name: "automatic")
+    public static let tabBar = AdaptableTabBarPlacement(name: "tabBar")
+    public static let sidebar = AdaptableTabBarPlacement(name: "sidebar")
+}
+
+/// Whether the user may reorder or hide a tab or section (recorded only).
+public struct TabCustomizationBehavior: Hashable, Sendable {
+    let name: String
+    public static let automatic = TabCustomizationBehavior(name: "automatic")
+    public static let reorderable = TabCustomizationBehavior(name: "reorderable")
+    public static let disabled = TabCustomizationBehavior(name: "disabled")
+}
+
+extension TabContent {
+    /// A badge on the tab's bar item (a count of 0 shows none).
+    public nonisolated func badge(_ count: Int) -> some TabContent<TabValue> {
+        _ModifiedTabContent(content: self) { $0.badge = count == 0 ? nil : String(count) }
+    }
+
+    public nonisolated func badge(_ label: Text?) -> some TabContent<TabValue> {
+        _ModifiedTabContent(content: self) { $0.badge = label.flatMap { $0.content.isEmpty ? nil : $0.content } }
+    }
+
+    @_disfavoredOverload
+    public nonisolated func badge<S: StringProtocol>(_ label: S?) -> some TabContent<TabValue> {
+        _ModifiedTabContent(content: self) { $0.badge = label.flatMap { $0.isEmpty ? nil : String($0) } }
+    }
+
+    public nonisolated func badge(_ key: LocalizedStringKey?) -> some TabContent<TabValue> {
+        _ModifiedTabContent(content: self) { modifiers in
+            modifiers.badge = key.flatMap { Text($0).content.isEmpty ? nil : Text($0).content }
+        }
+    }
+
+    /// Hides the tab (it is not in the tab bar or the sidebar).
+    public nonisolated func hidden(_ hidden: Bool = true) -> some TabContent<TabValue> {
+        _ModifiedTabContent(content: self) { if hidden { $0.hidden = true } }
+    }
+
+    /// Recorded only (see `TabPlacement`).
+    public nonisolated func tabPlacement(_ placement: TabPlacement) -> some TabContent<TabValue> {
+        _ModifiedTabContent(content: self) { $0.placement = placement }
+    }
+
+    /// The identity of the tab in a `TabViewCustomization` (recorded only).
+    public nonisolated func customizationID(_ id: String) -> some TabContent<TabValue> {
+        _ModifiedTabContent(content: self) { $0.customizationID = id }
+    }
+
+    /// Recorded only: tabs show in the tab bar and the sidebar regardless.
+    public nonisolated func defaultVisibility(_ visibility: Visibility,
+                                              for placements: TabBarPlacement...) -> some TabContent<TabValue> {
+        _ModifiedTabContent(content: self) { modifiers in
+            for placement in placements {
+                if visibility == .hidden {
+                    modifiers.hiddenIn.insert(placement)
+                } else {
+                    modifiers.hiddenIn.remove(placement)
+                }
+            }
+        }
+    }
+
+    /// Accepted; tabs cannot be reordered or hidden by the user.
+    public nonisolated func customizationBehavior(_ behavior: TabCustomizationBehavior,
+                                                  for placements: TabBarPlacement...) -> some TabContent<TabValue> {
+        self
+    }
+
+    public nonisolated func accessibilityIdentifier(_ identifier: String) -> some TabContent<TabValue> { self }
+    public nonisolated func accessibilityLabel(_ label: Text) -> some TabContent<TabValue> { self }
+    public nonisolated func springLoadingBehavior(_ behavior: SpringLoadingBehavior) -> some TabContent<TabValue> { self }
+}
+
+/// Whether drags spring-load a tab (accepted; there is no drag and drop onto tabs).
+public struct SpringLoadingBehavior: Hashable, Sendable {
+    let name: String
+    public static let automatic = SpringLoadingBehavior(name: "automatic")
+    public static let enabled = SpringLoadingBehavior(name: "enabled")
+    public static let disabled = SpringLoadingBehavior(name: "disabled")
+}
+
+// MARK: - Customization
+
+/// The user's customization of a tab view's tabs and sections (visibility and
+/// order). The browser has no customization UI: the value is kept as state
+/// (it is `Codable`, so `@AppStorage` round-trips it) and a tab view shows its
+/// tabs as declared.
+public struct TabViewCustomization: Equatable, Codable, Sendable {
+    var visibility: [String: String] = [:]
+
+    public init() {}
+
+    public subscript(visibility id: String) -> Visibility {
+        get {
+            switch visibility[id] {
+            case "visible": .visible
+            case "hidden": .hidden
+            default: .automatic
+            }
+        }
+        set {
+            switch newValue {
+            case .visible: visibility[id] = "visible"
+            case .hidden: visibility[id] = "hidden"
+            case .automatic: visibility[id] = nil
+            }
+        }
+    }
+
+    public mutating func resetVisibility() { visibility = [:] }
+    public mutating func resetTabOrder() {}
+    public mutating func resetSectionOrder(forIdentifier id: String) {}
+}
+
+// MARK: - Styles
+
+/// How a `TabView` presents its tabs.
+public protocol TabViewStyle {
+    var _name: String { get }
+}
+public struct DefaultTabViewStyle: TabViewStyle {
+    public init() {}
+    public var _name: String { "automatic" }
+}
+/// A tab bar in compact width; a sidebar in regular width.
+public struct SidebarAdaptableTabViewStyle: TabViewStyle {
+    public init() {}
+    public var _name: String { "sidebarAdaptable" }
+}
+public struct TabBarOnlyTabViewStyle: TabViewStyle {
+    public init() {}
+    public var _name: String { "tabBarOnly" }
+}
+/// Accepted; the tabs are still shown with a tab bar.
+public struct PageTabViewStyle: TabViewStyle {
+    public struct IndexDisplayMode: Hashable, Sendable {
+        let name: String
+        public static let automatic = IndexDisplayMode(name: "automatic")
+        public static let always = IndexDisplayMode(name: "always")
+        public static let never = IndexDisplayMode(name: "never")
+    }
+    public init(indexDisplayMode: IndexDisplayMode = .automatic) {}
+    public var _name: String { "page" }
+}
+extension TabViewStyle where Self == DefaultTabViewStyle {
+    public static var automatic: DefaultTabViewStyle { DefaultTabViewStyle() }
+}
+extension TabViewStyle where Self == SidebarAdaptableTabViewStyle {
+    public static var sidebarAdaptable: SidebarAdaptableTabViewStyle { SidebarAdaptableTabViewStyle() }
+}
+extension TabViewStyle where Self == TabBarOnlyTabViewStyle {
+    public static var tabBarOnly: TabBarOnlyTabViewStyle { TabBarOnlyTabViewStyle() }
+}
+extension TabViewStyle where Self == PageTabViewStyle {
+    public static var page: PageTabViewStyle { PageTabViewStyle() }
+    public static func page(indexDisplayMode: PageTabViewStyle.IndexDisplayMode) -> PageTabViewStyle {
+        PageTabViewStyle(indexDisplayMode: indexDisplayMode)
+    }
+}
+
+enum _TabViewStyleKey: EnvironmentKey { static let defaultValue = "automatic" }
+enum _TabBarPlacementKey: EnvironmentKey { static let defaultValue = "automatic" }
+
+extension EnvironmentValues {
+    var _tabViewStyle: String {
+        get { self[_TabViewStyleKey.self] }
+        set { self[_TabViewStyleKey.self] = newValue }
+    }
+
+    /// The `defaultAdaptableTabBarPlacement` / `defaultTabBarPlacement` name.
+    var _tabBarPlacement: String {
+        get { self[_TabBarPlacementKey.self] }
+        set { self[_TabBarPlacementKey.self] = newValue }
+    }
+}
+
+nonisolated extension View {
+    public func tabViewStyle<S: TabViewStyle>(_ style: S) -> some View {
+        environment(\._tabViewStyle, style._name)
+    }
+
+    /// Where a `.sidebarAdaptable` tab view shows its tabs in regular width:
+    /// `.tabBar` keeps the tab bar, anything else is the sidebar.
+    public func defaultAdaptableTabBarPlacement(_ placement: AdaptableTabBarPlacement = .automatic) -> some View {
+        environment(\._tabBarPlacement, placement.name)
+    }
+
+    public func defaultTabBarPlacement(_ placement: TabBarPlacement) -> some View {
+        environment(\._tabBarPlacement, placement.name)
+    }
+
+    /// Accepted; the customization is kept by the app but not applied.
+    public func tabViewCustomization(_ customization: Binding<TabViewCustomization>?) -> some View { self }
+
+    public func tabViewSidebarHeader<V: View>(@ViewBuilder content: () -> V) -> some View { self }
+    public func tabViewSidebarFooter<V: View>(@ViewBuilder content: () -> V) -> some View { self }
+    public func tabViewSidebarBottomBar<V: View>(@ViewBuilder content: () -> V) -> some View { self }
+}
+
+// MARK: - Symbol variants
+
+enum _SymbolVariantsKey: EnvironmentKey { static let defaultValue = SymbolVariants.none }
+
+extension EnvironmentValues {
+    /// The symbol variant the subtree asked for (tab labels set `.fill` on the
+    /// selected tab). Kept for views that read it; symbols draw as named.
+    public var symbolVariants: SymbolVariants {
+        get { self[_SymbolVariantsKey.self] }
+        set { self[_SymbolVariantsKey.self] = newValue }
+    }
+}