@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/API/Navigation.swift

@@ -0,0 +1,386 @@
+/// A screen pushed onto a `NavigationStack`.
+struct _PushedScreen {
+    let view: any View
+}
+
+/// A type-erased list of values pushed onto a navigation stack.
+public struct NavigationPath: Equatable {
+    var values: [AnyHashable] = []
+
+    public init() {}
+
+    public init<S: Sequence>(_ elements: S) where S.Element: Hashable {
+        values = elements.map { AnyHashable($0) }
+    }
+
+    public var count: Int { values.count }
+    public var isEmpty: Bool { values.isEmpty }
+
+    public mutating func append<V: Hashable>(_ value: V) { values.append(AnyHashable(value)) }
+
+    public mutating func removeLast(_ k: Int = 1) {
+        values.removeLast(min(k, values.count))
+    }
+}
+
+protocol _NavigationStackView: _TraitBearing {
+    var _root: any View { get }
+    var _pushedBox: _StateBox<[_PushedScreen]> { get }
+    /// Value-based path, when the stack was created with one.
+    var _path: _PathBinding? { get }
+}
+
+/// Reads and writes a navigation path of any element type as `AnyHashable`s.
+struct _PathBinding {
+    let get: () -> [AnyHashable]
+    let set: ([AnyHashable]) -> Void
+}
+
+/// A view that displays a root view and lets you push views onto it.
+public struct NavigationStack<Data, Content: View> {
+    let root: Content
+    let path: _PathBinding?
+    @State var pushed: [_PushedScreen] = []
+
+    public init(@ViewBuilder root: () -> Content) where Data == NavigationPath {
+        self.root = root()
+        self.path = nil
+    }
+
+    public init(path: Binding<NavigationPath>, @ViewBuilder root: () -> Content) where Data == NavigationPath {
+        self.root = root()
+        self.path = _PathBinding(
+            get: { path.wrappedValue.values },
+            set: { path.wrappedValue.values = $0 }
+        )
+    }
+
+    public init<Element: Hashable>(path: Binding<[Element]>, @ViewBuilder root: () -> Content)
+    where Data == [Element] {
+        self.root = root()
+        self.path = _PathBinding(
+            get: { path.wrappedValue.map { AnyHashable($0) } },
+            set: { path.wrappedValue = $0.compactMap { $0.base as? Element } }
+        )
+    }
+}
+extension NavigationStack: _PrimitiveView {}
+extension NavigationStack: _HostView {
+    var _kind: String { "navstack" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object([:]) }
+    // Children are produced by the runtime from `pushed`.
+}
+extension NavigationStack: _NavigationStackView {
+    var _root: any View { root }
+    var _pushedBox: _StateBox<[_PushedScreen]> { _pushed.box }
+    var _path: _PathBinding? { path }
+}
+
+/// A pushed screen whose view is resolved from a value through the enclosing
+/// stack's `navigationDestination(for:)` registrations.
+struct _PathScreenValue {
+    let value: AnyHashable
+}
+extension _PathScreenValue: _PrimitiveView {}
+extension _PathScreenValue: _GroupView {
+    // Resolved by the runtime through the stack's registrations.
+    var _children: [any View] { [] }
+}
+
+protocol _DestinationRegistering: _TraitBearing {
+    var _destinationType: ObjectIdentifier { get }
+    var _destinationTypeName: String { get }
+    func _destination(for value: Any) -> (any View)?
+}
+
+struct _DestinationView<Content: View, Value: Hashable, Destination: View> {
+    let content: Content
+    let builder: (Value) -> Destination
+}
+extension _DestinationView: _PrimitiveView {}
+extension _DestinationView: _GroupView {
+    var _children: [any View] { [content] }
+}
+extension _DestinationView: _DestinationRegistering {
+    var _destinationType: ObjectIdentifier { ObjectIdentifier(Value.self) }
+    var _destinationTypeName: String { String(describing: Value.self) }
+    func _destination(for value: Any) -> (any View)? {
+        guard let value = value as? Value else { return nil }
+        return builder(value)
+    }
+}
+
+nonisolated extension View {
+    /// Associates a destination view with values of `data`'s type pushed by
+    /// `NavigationLink(value:)` or appended to the stack's path.
+    public func navigationDestination<D: Hashable, C: View>(for data: D.Type,
+                                                            @ViewBuilder destination: @escaping (D) -> C) -> some View {
+        _DestinationView(content: self, builder: destination)
+    }
+}
+
+protocol _NavigationValueLinkView: _TraitBearing {
+    var _value: AnyHashable? { get }
+}
+
+extension NavigationLink where Destination == Never {
+    /// A link that pushes `value` onto the enclosing stack's path.
+    public init<P: Hashable>(value: P?, @ViewBuilder label: () -> Label) {
+        self.destination = nil
+        self.value = value.map { AnyHashable($0) }
+        self.label = label()
+    }
+}
+
+extension NavigationLink where Label == Text, Destination == Never {
+    public init<S: StringProtocol, P: Hashable>(_ title: S, value: P?) {
+        self.destination = nil
+        self.value = value.map { AnyHashable($0) }
+        self.label = Text(title)
+    }
+}
+
+extension NavigationLink: _NavigationValueLinkView {
+    var _value: AnyHashable? { value }
+}
+
+/// One screen of a navigation stack. Created by the runtime, never by apps.
+struct _NavScreenView {
+    let content: any View
+    let depth: Int
+}
+extension _NavScreenView: _PrimitiveView {}
+extension _NavScreenView: _HostView {
+    var _kind: String { "navscreen" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object(["depth": .number(Double(depth))]) }
+    var _content: [any View] { [content] }
+}
+
+protocol _NavigationLinkView: _TraitBearing {
+    var _destination: any View { get }
+}
+
+/// A control that pushes its destination onto the enclosing navigation stack.
+public struct NavigationLink<Label: View, Destination: View> {
+    let destination: Destination?
+    let value: AnyHashable?
+    let label: Label
+
+    public init(@ViewBuilder destination: () -> Destination, @ViewBuilder label: () -> Label) {
+        self.destination = destination()
+        self.value = nil
+        self.label = label()
+    }
+
+    public init(destination: Destination, @ViewBuilder label: () -> Label) {
+        self.destination = destination
+        self.value = nil
+        self.label = label()
+    }
+}
+
+extension NavigationLink where Label == Text {
+    public init(_ titleKey: LocalizedStringKey, @ViewBuilder destination: () -> Destination) {
+        self.destination = destination()
+        self.value = nil
+        self.label = Text(titleKey)
+    }
+
+    public init(_ titleKey: LocalizedStringKey, destination: Destination) {
+        self.destination = destination
+        self.value = nil
+        self.label = Text(titleKey)
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, @ViewBuilder destination: () -> Destination) {
+        self.destination = destination()
+        self.value = nil
+        self.label = Text(title)
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, destination: Destination) {
+        self.destination = destination
+        self.value = nil
+        self.label = Text(title)
+    }
+}
+extension NavigationLink: _PrimitiveView {}
+extension NavigationLink: _HostView {
+    var _kind: String { "navlink" }
+    /// `selected` marks the row of a `List(selection:)` whose value is the
+    /// current selection (see docs/ops-protocol.md, Phase 7); omitted otherwise.
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        if let value, let selection = environment._listSelection, selection.get() == value {
+            return .object(["selected": .bool(true)])
+        }
+        return .object([:])
+    }
+    var _content: [any View] { [label] }
+    // The handler is supplied by the runtime, which knows the enclosing stack.
+}
+extension NavigationLink: _NavigationLinkView {
+    var _destination: any View { destination ?? EmptyView() }
+}
+
+// MARK: - NavigationSplitView
+
+/// Which columns of a `NavigationSplitView` are shown. Accepted for source
+/// compatibility; the shim shows the sidebar and the detail (see below).
+public struct NavigationSplitViewVisibility: Hashable, Sendable {
+    let name: String
+    public static let automatic = NavigationSplitViewVisibility(name: "automatic")
+    public static let all = NavigationSplitViewVisibility(name: "all")
+    public static let doubleColumn = NavigationSplitViewVisibility(name: "doubleColumn")
+    public static let detailOnly = NavigationSplitViewVisibility(name: "detailOnly")
+}
+
+/// `.navigationSplitViewStyle`: accepted for source compatibility.
+public protocol NavigationSplitViewStyle {}
+public struct AutomaticNavigationSplitViewStyle: NavigationSplitViewStyle { public init() {} }
+public struct BalancedNavigationSplitViewStyle: NavigationSplitViewStyle { public init() {} }
+public struct ProminentDetailNavigationSplitViewStyle: NavigationSplitViewStyle { public init() {} }
+extension NavigationSplitViewStyle where Self == AutomaticNavigationSplitViewStyle {
+    public static var automatic: AutomaticNavigationSplitViewStyle { AutomaticNavigationSplitViewStyle() }
+}
+extension NavigationSplitViewStyle where Self == BalancedNavigationSplitViewStyle {
+    public static var balanced: BalancedNavigationSplitViewStyle { BalancedNavigationSplitViewStyle() }
+}
+extension NavigationSplitViewStyle where Self == ProminentDetailNavigationSplitViewStyle {
+    public static var prominentDetail: ProminentDetailNavigationSplitViewStyle { ProminentDetailNavigationSplitViewStyle() }
+}
+
+nonisolated extension View {
+    public func navigationSplitViewColumnWidth(_ width: CGFloat) -> some View { self }
+    public func navigationSplitViewColumnWidth(min: CGFloat? = nil, ideal: CGFloat, max: CGFloat? = nil) -> some View { self }
+    public func navigationSplitViewStyle<S: NavigationSplitViewStyle>(_ style: S) -> some View { self }
+}
+
+/// The runtime's view of a split view (see Runtime.swift): by size class it
+/// renders a `navsplit` of two stacks (regular) or one stack rooted at the
+/// sidebar that pushes the detail while the sidebar's list selection is set
+/// (compact). The sidebar's `List(selection:)` is found as it is reconciled.
+protocol _NavigationSplitHost: _TraitBearing {
+    var _sidebar: any View { get }
+    var _detail: any View { get }
+    /// Screens pushed from the compact detail (links inside it).
+    var _pushedBox: _StateBox<[_PushedScreen]> { get }
+}
+
+/// A two-column navigation interface: a sidebar whose list selection drives
+/// the detail column. The optional middle `content` column is treated as part
+/// of the detail and not shown.
+public struct NavigationSplitView<Sidebar: View, Content: View, Detail: View> {
+    let sidebar: Sidebar
+    let detail: Detail
+    @State var pushed: [_PushedScreen] = []
+
+    public init(@ViewBuilder sidebar: () -> Sidebar, @ViewBuilder detail: () -> Detail) where Content == EmptyView {
+        self.sidebar = sidebar()
+        self.detail = detail()
+    }
+
+    public init(@ViewBuilder sidebar: () -> Sidebar, @ViewBuilder content: () -> Content,
+                @ViewBuilder detail: () -> Detail) {
+        self.sidebar = sidebar()
+        _ = content()
+        self.detail = detail()
+    }
+
+    /// The visibility binding is accepted and ignored.
+    public init(columnVisibility: Binding<NavigationSplitViewVisibility>,
+                @ViewBuilder sidebar: () -> Sidebar, @ViewBuilder detail: () -> Detail) where Content == EmptyView {
+        self.sidebar = sidebar()
+        self.detail = detail()
+    }
+
+    public init(columnVisibility: Binding<NavigationSplitViewVisibility>,
+                @ViewBuilder sidebar: () -> Sidebar, @ViewBuilder content: () -> Content,
+                @ViewBuilder detail: () -> Detail) {
+        self.sidebar = sidebar()
+        _ = content()
+        self.detail = detail()
+    }
+}
+extension NavigationSplitView: _PrimitiveView {}
+extension NavigationSplitView: _HostView {
+    var _kind: String { "navsplit" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object([:]) }
+    // Children are produced by the runtime from the size class.
+}
+extension NavigationSplitView: _NavigationSplitHost {
+    var _sidebar: any View { sidebar }
+    var _detail: any View { detail }
+    var _pushedBox: _StateBox<[_PushedScreen]> { _pushed.box }
+}
+
+/// Marks the sidebar subtree of a split view: value links there select
+/// instead of pushing, and the sidebar's `List(selection:)` registers its
+/// binding with the split view's node (`split`) as it is reconciled.
+struct _SplitSidebarView {
+    let content: any View
+    unowned let split: _MountedNode
+}
+extension _SplitSidebarView: _PrimitiveView {}
+extension _SplitSidebarView: _GroupView {
+    var _children: [any View] { [content] }
+}
+extension _SplitSidebarView: _EnvironmentModifying {
+    func _apply(to environment: inout EnvironmentValues) { environment._splitSidebar = true }
+}
+
+// MARK: - Titles
+
+public enum NavigationBarItem {
+    public enum TitleDisplayMode: Hashable, Sendable {
+        case automatic, inline, large
+
+        var name: String {
+            switch self {
+            case .automatic: "automatic"
+            case .inline: "inline"
+            case .large: "large"
+            }
+        }
+    }
+}
+
+protocol _NavigationTitleModifying: _TraitBearing {
+    var _title: String? { get }
+    var _displayMode: String? { get }
+}
+
+struct _NavigationTitleView<Content: View> {
+    let content: Content
+    let title: String?
+    let displayMode: String?
+}
+extension _NavigationTitleView: _PrimitiveView {}
+extension _NavigationTitleView: _GroupView {
+    var _children: [any View] { [content] }
+}
+extension _NavigationTitleView: _NavigationTitleModifying {
+    var _title: String? { title }
+    var _displayMode: String? { displayMode }
+}
+
+nonisolated extension View {
+    @_disfavoredOverload
+    public func navigationTitle<S: StringProtocol>(_ title: S) -> some View {
+        _NavigationTitleView(content: self, title: String(title), displayMode: nil)
+    }
+
+    public func navigationTitle(_ title: Text) -> some View {
+        _NavigationTitleView(content: self, title: title._content, displayMode: nil)
+    }
+
+    /// An editable title (iOS 16): the browser shows the bound value and does not edit it.
+    public func navigationTitle(_ title: Binding<String>) -> some View {
+        _NavigationTitleView(content: self, title: title.wrappedValue, displayMode: nil)
+    }
+
+    public func navigationBarTitleDisplayMode(_ mode: NavigationBarItem.TitleDisplayMode) -> some View {
+        _NavigationTitleView(content: self, title: nil, displayMode: mode.name)
+    }
+}

package/Sources/SwiftUI/API/NavigationDestinationBindings.swift

@@ -0,0 +1,55 @@
+/// `navigationDestination(isPresented:destination:)` (iOS 16) and
+/// `navigationDestination(item:destination:)` (iOS 17): a destination shown
+/// while a binding says so. The runtime pushes only screens a link or a path
+/// names, so here the destination is presented as a sheet, in a navigation
+/// stack of its own (an approximation: it slides up instead of in, and is
+/// dismissed by swiping it down or with a Back button in its bar). Dismissing
+/// it sets `isPresented` to false, or `item` to nil, as popping does on iOS.
+nonisolated extension View {
+    @MainActor
+    public func navigationDestination<V: View>(isPresented: Binding<Bool>, @ViewBuilder destination: () -> V) -> some View {
+        sheet(isPresented: isPresented) {
+            _PresentedDestination(isPresented: isPresented) { destination() }
+        }
+    }
+
+    @MainActor
+    public func navigationDestination<D: Hashable, C: View>(item: Binding<D?>,
+                                                            @ViewBuilder destination: @escaping (D) -> C) -> some View {
+        let isPresented = Binding<Bool>(
+            get: { item.wrappedValue != nil },
+            set: { if !$0 { item.wrappedValue = nil } }
+        )
+        return sheet(isPresented: isPresented) {
+            _PresentedDestination(isPresented: isPresented) {
+                if let value = item.wrappedValue { destination(value) }
+            }
+        }
+    }
+}
+
+/// A presented destination: its own stack with a Back button.
+struct _PresentedDestination<Content: View>: View {
+    let isPresented: Binding<Bool>
+    let content: Content
+
+    init(isPresented: Binding<Bool>, @ViewBuilder content: () -> Content) {
+        self.isPresented = isPresented
+        self.content = content()
+    }
+
+    var body: some View {
+        NavigationStack {
+            content
+                .toolbar {
+                    ToolbarItem(placement: .topBarLeading) {
+                        Button {
+                            isPresented.wrappedValue = false
+                        } label: {
+                            Label("Back", systemImage: "chevron.backward")
+                        }
+                    }
+                }
+        }
+    }
+}