@swiftbrowser/swift 0.0.0-stage → 0.1.0

package/Sources/SwiftUI/API/Modifiers.swift

@@ -0,0 +1,243 @@
+/// How `aspectRatio` fits content into the proposed space.
+public enum ContentMode: Hashable, Sendable {
+    case fit, fill
+}
+
+/// The style a `styled` element applies to the box around its child.
+/// See docs/ops-protocol.md.
+struct _Style: Equatable {
+    struct Frame: Equatable {
+        var width: CGFloat?
+        var height: CGFloat?
+        var minWidth: CGFloat?
+        var maxWidth: CGFloat?
+        var minHeight: CGFloat?
+        var maxHeight: CGFloat?
+        var alignment: Alignment = .center
+
+        var _json: _JSON {
+            func dimension(_ value: CGFloat?) -> _JSON? {
+                guard let value else { return nil }
+                return value == .infinity ? .string("infinity") : .number(value)
+            }
+            var object: [String: _JSON] = ["alignment": .string(alignment._name)]
+            if let v = dimension(width) { object["width"] = v }
+            if let v = dimension(height) { object["height"] = v }
+            if let v = dimension(minWidth) { object["minWidth"] = v }
+            if let v = dimension(maxWidth) { object["maxWidth"] = v }
+            if let v = dimension(minHeight) { object["minHeight"] = v }
+            if let v = dimension(maxHeight) { object["maxHeight"] = v }
+            return .object(object)
+        }
+    }
+
+    var padding: EdgeInsets?
+    var font: Font?
+    var foreground: (any ShapeStyle)?
+    var background: (any ShapeStyle)?
+    var frame: Frame?
+    var cornerRadius: CGFloat?
+    var opacity: Double?
+    var disabled: Bool?
+    var layoutPriority: Double?
+    /// `-1` clears an inherited limit (`lineLimit(nil)`).
+    var lineLimit: Int?
+    var multilineTextAlignment: TextAlignment?
+    var fixedSize: (horizontal: Bool, vertical: Bool)?
+    var transition: AnyTransition?
+    /// `.aspectRatio` / `.scaledToFit` / `.scaledToFill`; a nil ratio means the
+    /// child's ideal size decides.
+    var aspectRatio: (ratio: CGFloat?, contentMode: ContentMode)?
+    /// Hints with no layout logic in Swift (`offset`, `rotation`, `shadow`,
+    /// `badge`, `tint`, ...), passed through to the renderer by key.
+    var extras: [String: _JSON] = [:]
+
+    static func == (lhs: _Style, rhs: _Style) -> Bool { lhs._json == rhs._json }
+
+    var _json: _JSON {
+        var object: [String: _JSON] = [:]
+        if let padding { object["padding"] = padding._json }
+        if let font { object["font"] = font._json }
+        if let foreground { object["foreground"] = foreground._json }
+        if let background { object["background"] = background._json }
+        if let frame { object["frame"] = frame._json }
+        if let cornerRadius { object["cornerRadius"] = .number(cornerRadius) }
+        if let opacity { object["opacity"] = .number(opacity) }
+        if let disabled { object["disabled"] = .bool(disabled) }
+        if let layoutPriority { object["layoutPriority"] = .number(layoutPriority) }
+        if let lineLimit { object["lineLimit"] = lineLimit < 0 ? .null : .number(Double(lineLimit)) }
+        if let multilineTextAlignment { object["multilineTextAlignment"] = .string(multilineTextAlignment.name) }
+        if let fixedSize {
+            object["fixedSize"] = .object(["horizontal": .bool(fixedSize.horizontal), "vertical": .bool(fixedSize.vertical)])
+        }
+        if let transition { object["transition"] = transition._json }
+        if let aspectRatio {
+            object["aspectRatio"] = .object([
+                "ratio": aspectRatio.ratio.map(_JSON.number) ?? .null,
+                "contentMode": .string(aspectRatio.contentMode == .fit ? "fit" : "fill"),
+            ])
+        }
+        for (key, value) in extras { object[key] = value }
+        return .object(object)
+    }
+}
+
+/// The view a modifier produces. Nesting preserves modifier order.
+public struct _StyledView<Content: View> {
+    let content: Content
+    let style: _Style
+}
+extension _StyledView: _PrimitiveView {}
+extension _StyledView: _HostView {
+    var _kind: String { "styled" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object(["style": style._json]) }
+    var _content: [any View] { [content] }
+}
+
+/// A modifier applied to a group (`ForEach`, `Group`, a tuple, a conditional)
+/// styles each of the group's views, as in SwiftUI, instead of wrapping the
+/// group in one box. Single views still get one `styled` element.
+public struct _StyledGroup<Content: View> {
+    let content: Content
+    let style: _Style
+}
+extension _StyledGroup: _PrimitiveView {}
+extension _StyledGroup: _GroupView {
+    var _children: [any View] {
+        if let group = content as? any _GroupView, group._children.count != 1 || group._keys != nil {
+            return group._children.map { _StyledView(content: AnyView($0), style: style) }
+        }
+        return [_StyledView(content: content, style: style)]
+    }
+
+    var _keys: [AnyHashable]? {
+        if let group = content as? any _GroupView, group._children.count != 1 || group._keys != nil {
+            return group._keys
+        }
+        return nil
+    }
+}
+
+extension View {
+    func _styled(_ configure: (inout _Style) -> Void) -> _StyledGroup<Self> {
+        var style = _Style()
+        configure(&style)
+        return _StyledGroup(content: self, style: style)
+    }
+
+    // MARK: Padding
+
+    public func padding(_ edges: Edge.Set = .all, _ length: CGFloat? = nil) -> some View {
+        let amount = length ?? 16
+        return _styled {
+            $0.padding = EdgeInsets(
+                top: edges.contains(.top) ? amount : 0,
+                leading: edges.contains(.leading) ? amount : 0,
+                bottom: edges.contains(.bottom) ? amount : 0,
+                trailing: edges.contains(.trailing) ? amount : 0
+            )
+        }
+    }
+
+    public func padding(_ length: CGFloat) -> some View {
+        padding(.all, length)
+    }
+
+    public func padding(_ insets: EdgeInsets) -> some View {
+        _styled { $0.padding = insets }
+    }
+
+    // MARK: Typography
+
+    public func font(_ font: Font?) -> some View {
+        _styled { $0.font = font }
+    }
+
+    public func fontWeight(_ weight: Font.Weight?) -> some View {
+        _styled { $0.font = weight.map { Font(size: nil, weight: $0, design: nil) } }
+    }
+
+    public func bold(_ isActive: Bool = true) -> some View {
+        _styled { $0.font = isActive ? Font(size: nil, weight: .bold, design: nil) : nil }
+    }
+
+    // MARK: Color
+
+    public func foregroundStyle<S: ShapeStyle>(_ style: S) -> some View {
+        _styled { $0.foreground = style }
+    }
+
+    public func foregroundColor(_ color: Color?) -> some View {
+        _styled { $0.foreground = color }
+    }
+
+    /// Hierarchical foreground styles: the primary style paints everything.
+    public func foregroundStyle<S1: ShapeStyle, S2: ShapeStyle>(_ primary: S1, _ secondary: S2) -> some View {
+        _styled { $0.foreground = primary }
+    }
+
+    public func foregroundStyle<S1: ShapeStyle, S2: ShapeStyle, S3: ShapeStyle>(_ primary: S1, _ secondary: S2,
+                                                                                 _ tertiary: S3) -> some View {
+        _styled { $0.foreground = primary }
+    }
+
+    /// A paint behind the view: a color, gradient or material filling its box.
+    public func background<S: ShapeStyle>(_ style: S, ignoresSafeAreaEdges edges: Edge.Set = .all) -> some View {
+        _styled { $0.background = style }
+    }
+
+    /// The system background color behind the view.
+    public func background(ignoresSafeAreaEdges edges: Edge.Set = .all) -> some View {
+        _styled { $0.background = BackgroundStyle() }
+    }
+
+    public func opacity(_ opacity: Double) -> some View {
+        _styled { $0.opacity = opacity }
+    }
+
+    // MARK: Layout
+
+    public func frame(width: CGFloat? = nil, height: CGFloat? = nil, alignment: Alignment = .center) -> some View {
+        _styled { $0.frame = _Style.Frame(width: width, height: height, alignment: alignment) }
+    }
+
+    public func frame(minWidth: CGFloat? = nil, idealWidth: CGFloat? = nil, maxWidth: CGFloat? = nil,
+                      minHeight: CGFloat? = nil, idealHeight: CGFloat? = nil, maxHeight: CGFloat? = nil,
+                      alignment: Alignment = .center) -> some View {
+        _styled {
+            $0.frame = _Style.Frame(width: idealWidth, height: idealHeight,
+                                    minWidth: minWidth, maxWidth: maxWidth,
+                                    minHeight: minHeight, maxHeight: maxHeight,
+                                    alignment: alignment)
+        }
+    }
+
+    /// Constrains the view to an aspect ratio: `fit` is the largest such box
+    /// inside the proposal, `fill` the smallest covering it. A nil ratio uses
+    /// the child's ideal size (what `Image.resizable().scaledToFit()` wants).
+    public func aspectRatio(_ aspectRatio: CGFloat? = nil, contentMode: ContentMode) -> some View {
+        _styled { $0.aspectRatio = (aspectRatio, contentMode) }
+    }
+
+    public func aspectRatio(_ aspectRatio: CGSize, contentMode: ContentMode) -> some View {
+        _styled { $0.aspectRatio = (aspectRatio.height == 0 ? nil : aspectRatio.width / aspectRatio.height, contentMode) }
+    }
+
+    public func scaledToFit() -> some View { aspectRatio(nil, contentMode: .fit) }
+
+    public func scaledToFill() -> some View { aspectRatio(nil, contentMode: .fill) }
+
+    /// Identity and compositing hints; accepted for source compatibility and
+    /// currently without effect on the rendered tree.
+    public func id<ID: Hashable>(_ id: ID) -> some View { self }
+
+    public func compositingGroup() -> some View { self }
+
+    public func cornerRadius(_ radius: CGFloat, antialiased: Bool = true) -> some View {
+        _styled { $0.cornerRadius = radius }
+    }
+
+    public func clipShape<S: Shape>(_ shape: S) -> some View {
+        _styled { $0.cornerRadius = shape._cornerRadius }
+    }
+}

package/Sources/SwiftUI/API/Navigation.swift

@@ -0,0 +1,371 @@
+/// 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 {
+    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 {
+    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)
+    }
+}
+
+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 {
+    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 {
+    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<S: StringProtocol>(_ title: S, @ViewBuilder destination: () -> Destination) {
+        self.destination = destination()
+        self.value = nil
+        self.label = Text(title)
+    }
+
+    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() }
+}
+
+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 {
+    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 {
+    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 }
+}
+
+extension View {
+    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)
+    }
+}