@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/API/Lists.swift

@@ -0,0 +1,331 @@
+// MARK: - List
+
+public protocol ListStyle {
+    var _name: String { get }
+}
+public struct DefaultListStyle: ListStyle {
+    public init() {}
+    public var _name: String { "insetGrouped" }
+}
+public struct PlainListStyle: ListStyle {
+    public init() {}
+    public var _name: String { "plain" }
+}
+public struct InsetGroupedListStyle: ListStyle {
+    public init() {}
+    public var _name: String { "insetGrouped" }
+}
+public struct GroupedListStyle: ListStyle {
+    public init() {}
+    public var _name: String { "grouped" }
+}
+extension ListStyle where Self == DefaultListStyle {
+    public static var automatic: DefaultListStyle { DefaultListStyle() }
+}
+extension ListStyle where Self == PlainListStyle {
+    public static var plain: PlainListStyle { PlainListStyle() }
+}
+extension ListStyle where Self == InsetGroupedListStyle {
+    public static var insetGrouped: InsetGroupedListStyle { InsetGroupedListStyle() }
+}
+extension ListStyle where Self == GroupedListStyle {
+    public static var grouped: GroupedListStyle { GroupedListStyle() }
+}
+
+nonisolated extension View {
+    public func listStyle<S: ListStyle>(_ style: S) -> some View {
+        environment(\._listStyle, style._name)
+    }
+}
+
+/// A `List(selection:)` binding with its value type erased. Rows read it from
+/// the environment (`_listSelection`): a `NavigationLink(value:)` row whose
+/// value equals `get()` is the selected row, and in a `NavigationSplitView`
+/// sidebar tapping such a row calls `set` instead of pushing.
+struct _ListSelection {
+    let get: () -> AnyHashable?
+    let set: (AnyHashable?) -> Void
+    /// Whether the row with this value is selected.
+    let contains: (AnyHashable) -> Bool
+    /// Adds or removes a value (a `Set` selection; for an optional, selects or clears).
+    let toggle: (AnyHashable) -> Void
+    /// Whether a `.tag` / link value is of the selection's value type.
+    let accepts: (AnyHashable) -> Bool
+    /// `Set<Value>` selections toggle on tap; `Value?` selections set.
+    let isMultiple: Bool
+    /// The whole current selection, for the identity below.
+    let snapshot: () -> AnyHashable
+    /// Set by the runtime: the list and the selection the pass carried, so the
+    /// environments of two passes compare equal while the selection is unchanged
+    /// (the binding is re-created by every pass; see `_Sameness`).
+    var identity: _RuntimeKey?
+
+    init<Value: Hashable>(_ binding: Binding<Value?>) {
+        get = { binding.wrappedValue.map { AnyHashable($0) } }
+        set = { binding.wrappedValue = $0?.base as? Value }
+        contains = { binding.wrappedValue.map { AnyHashable($0) } == $0 }
+        toggle = { value in
+            if binding.wrappedValue.map({ AnyHashable($0) }) == value {
+                binding.wrappedValue = nil
+            } else {
+                binding.wrappedValue = value.base as? Value
+            }
+        }
+        accepts = { $0.base is Value }
+        isMultiple = false
+        snapshot = { AnyHashable(binding.wrappedValue) }
+    }
+
+    /// `get` / `set` reduce a multiple selection to one value: the first of the set.
+    init<Value: Hashable>(_ binding: Binding<Set<Value>>) {
+        get = { binding.wrappedValue.first.map { AnyHashable($0) } }
+        set = { value in
+            if let value = value?.base as? Value {
+                binding.wrappedValue = [value]
+            } else {
+                binding.wrappedValue = []
+            }
+        }
+        contains = { value in
+            guard let value = value.base as? Value else { return false }
+            return binding.wrappedValue.contains(value)
+        }
+        toggle = { value in
+            guard let value = value.base as? Value else { return }
+            if binding.wrappedValue.contains(value) {
+                binding.wrappedValue.remove(value)
+            } else {
+                binding.wrappedValue.insert(value)
+            }
+        }
+        accepts = { $0.base is Value }
+        isMultiple = true
+        snapshot = { AnyHashable(binding.wrappedValue) }
+    }
+}
+
+/// Lists that carry a selection binding; the runtime puts it in the rows' environment.
+protocol _ListSelectionProviding: _TraitBearing {
+    var _selection: _ListSelection? { get }
+}
+
+enum _ListSelectionKey: EnvironmentKey { static var defaultValue: _ListSelection? { nil } }
+enum _SplitSidebarKey: EnvironmentKey { static let defaultValue = false }
+
+extension EnvironmentValues {
+    /// The enclosing `List(selection:)`'s binding, for its rows.
+    var _listSelection: _ListSelection? {
+        get { self[_ListSelectionKey.self] }
+        set { self[_ListSelectionKey.self] = newValue }
+    }
+
+    /// True inside a `NavigationSplitView`'s sidebar, where value links select
+    /// instead of pushing.
+    var _splitSidebar: Bool {
+        get { self[_SplitSidebarKey.self] }
+        set { self[_SplitSidebarKey.self] = newValue }
+    }
+}
+
+public struct List<Content: View> {
+    let content: Content
+    let selection: _ListSelection?
+    /// `.refreshable`: true while the action runs.
+    @State var refreshing = false
+
+    public init(@ViewBuilder content: () -> Content) {
+        self.content = content()
+        self.selection = nil
+    }
+
+    public init<Value: Hashable>(selection: Binding<Value?>, @ViewBuilder content: () -> Content) {
+        self.content = content()
+        self.selection = _ListSelection(selection)
+    }
+
+    public init<Value: Hashable>(selection: Binding<Set<Value>>, @ViewBuilder content: () -> Content) {
+        self.content = content()
+        self.selection = _ListSelection(selection)
+    }
+}
+
+extension List {
+    public init<Data: RandomAccessCollection, ID: Hashable, RowContent: View>(
+        _ data: Data, id: KeyPath<Data.Element, ID>,
+        @ViewBuilder rowContent: @escaping (Data.Element) -> RowContent
+    ) where Content == ForEach<Data, ID, RowContent> {
+        self.content = ForEach(data, id: id, content: rowContent)
+        self.selection = nil
+    }
+
+    public init<Data: RandomAccessCollection, RowContent: View>(
+        _ data: Data, @ViewBuilder rowContent: @escaping (Data.Element) -> RowContent
+    ) where Data.Element: Identifiable, Content == ForEach<Data, Data.Element.ID, RowContent> {
+        self.content = ForEach(data, content: rowContent)
+        self.selection = nil
+    }
+
+    public init<Data: RandomAccessCollection, ID: Hashable, Value: Hashable, RowContent: View>(
+        _ data: Data, id: KeyPath<Data.Element, ID>, selection: Binding<Value?>,
+        @ViewBuilder rowContent: @escaping (Data.Element) -> RowContent
+    ) where Content == ForEach<Data, ID, RowContent> {
+        self.content = ForEach(data, id: id, content: rowContent)
+        self.selection = _ListSelection(selection)
+    }
+
+    public init<Data: RandomAccessCollection, Value: Hashable, RowContent: View>(
+        _ data: Data, selection: Binding<Value?>,
+        @ViewBuilder rowContent: @escaping (Data.Element) -> RowContent
+    ) where Data.Element: Identifiable, Content == ForEach<Data, Data.Element.ID, RowContent> {
+        self.content = ForEach(data, content: rowContent)
+        self.selection = _ListSelection(selection)
+    }
+
+    public init<Data: RandomAccessCollection, ID: Hashable, Value: Hashable, RowContent: View>(
+        _ data: Data, id: KeyPath<Data.Element, ID>, selection: Binding<Set<Value>>,
+        @ViewBuilder rowContent: @escaping (Data.Element) -> RowContent
+    ) where Content == ForEach<Data, ID, RowContent> {
+        self.content = ForEach(data, id: id, content: rowContent)
+        self.selection = _ListSelection(selection)
+    }
+
+    public init<Data: RandomAccessCollection, Value: Hashable, RowContent: View>(
+        _ data: Data, selection: Binding<Set<Value>>,
+        @ViewBuilder rowContent: @escaping (Data.Element) -> RowContent
+    ) where Data.Element: Identifiable, Content == ForEach<Data, Data.Element.ID, RowContent> {
+        self.content = ForEach(data, content: rowContent)
+        self.selection = _ListSelection(selection)
+    }
+}
+extension List: _PrimitiveView {}
+extension List: _HostView {
+    var _kind: String { "list" }
+    /// `editing` (the environment's edit mode) and `refreshable` / `refreshing`
+    /// (`.refreshable`) are present only when true / when refreshable.
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        var props: [String: _JSON] = ["style": .string(environment._listStyle)]
+        if environment.editMode?.wrappedValue.isEditing == true { props["editing"] = .bool(true) }
+        _refresh(in: environment).addProps(to: &props)
+        // `.scrollDismissesKeyboard` (ScrollModifiers.swift).
+        if environment._scrollDismissesKeyboard { props["dismissesKeyboard"] = .bool(true) }
+        // `.scrollContentBackground(.hidden)` (ScrollViewReader.swift).
+        if environment._scrollContentBackground == .hidden { props["background"] = .string("hidden") }
+        // `.environment(\.defaultMinListRowHeight, 1)`: rows as short as their content.
+        if environment.defaultMinListRowHeight != 44 { props["minRowHeight"] = .number(Double(max(0, environment.defaultMinListRowHeight))) }
+        return .object(props)
+    }
+    var _content: [any View] { [content] }
+    var _handler: ((_JSON) -> Void)? { nil }
+
+    func _refresh(in environment: EnvironmentValues) -> _Refresh {
+        _Refresh(action: environment._refreshAction, refreshing: $refreshing)
+    }
+}
+extension List: _Refreshing {}
+
+/// `List` and `ScrollView`: hosts whose `refresh` handler the runtime takes
+/// from `_refresh(in:)` (the handler depends on the environment).
+protocol _Refreshing: _TraitBearing {
+    func _refresh(in environment: EnvironmentValues) -> _Refresh
+}
+extension List: _ListSelectionProviding {
+    var _selection: _ListSelection? { selection }
+}
+
+// MARK: - Section
+
+public struct Section<Content: View> {
+    let header: String?
+    let footer: String?
+    let content: Content
+    /// Modifiers applied to the section itself (`Section { … }.disabled(x)`)
+    /// style each of its rows, as in SwiftUI, instead of boxing the section
+    /// (a `styled` around a `section` is not a section to the list layout).
+    var rowStyles: [_Style] = []
+
+    public init(@ViewBuilder content: () -> Content) {
+        self.header = nil
+        self.footer = nil
+        self.content = content()
+    }
+
+    /// A header from a localized key.
+    public init(_ titleKey: LocalizedStringKey, @ViewBuilder content: () -> Content) {
+        self.header = titleKey.key
+        self.footer = nil
+        self.content = content()
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, @ViewBuilder content: () -> Content) {
+        self.header = String(title)
+        self.footer = nil
+        self.content = content()
+    }
+
+    /// Only `Text` headers and footers are supported; their content becomes the title.
+    public init(@ViewBuilder content: () -> Content, @ViewBuilder header: () -> Text) {
+        self.header = header().content
+        self.footer = nil
+        self.content = content()
+    }
+
+    public init(@ViewBuilder content: () -> Content, @ViewBuilder footer: () -> Text) {
+        self.header = nil
+        self.footer = footer().content
+        self.content = content()
+    }
+
+    public init(@ViewBuilder content: () -> Content, @ViewBuilder header: () -> Text,
+                @ViewBuilder footer: () -> Text) {
+        self.header = header().content
+        self.footer = footer().content
+        self.content = content()
+    }
+
+    /// A header or footer that is a `Text` (or an optional one) is a string
+    /// prop, as above; any other view is a `sectionheader` / `sectionfooter`
+    /// child (SectionSupplements.swift).
+    var headerView: (any View)?
+    var footerView: (any View)?
+}
+/// Lets pickers look through sections for their options, and modifiers
+/// style a section's rows.
+protocol _SectionView: _TraitBearing {
+    var _sectionContent: any View { get }
+    func _stylingRows(_ style: _Style) -> any View
+}
+
+extension Section: _SectionView {
+    var _sectionContent: any View { content }
+    func _stylingRows(_ style: _Style) -> any View {
+        var copy = self
+        copy.rowStyles.append(style)
+        return copy
+    }
+}
+
+extension Section: _PrimitiveView {}
+extension Section: _HostView {
+    var _kind: String { "section" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(["header": header.map(_JSON.string) ?? .null, "footer": footer.map(_JSON.string) ?? .null])
+    }
+    var _content: [any View] {
+        // Each style distributes over the rows (`_StyledGroup`); a second one
+        // wraps the already styled rows again.
+        var view: any View = content
+        for style in rowStyles { view = _styledGroup(view, style) }
+        // View headers and footers come first and last, outside the row styles.
+        var children: [any View] = [view]
+        if let headerView { children.insert(_SectionSupplement(kind: "sectionheader", content: headerView), at: 0) }
+        if let footerView { children.append(_SectionSupplement(kind: "sectionfooter", content: footerView)) }
+        return children
+    }
+}
+
+/// `_StyledGroup(content: view, style: style)` for an existential view.
+func _styledGroup(_ view: any View, _ style: _Style) -> any View {
+    func open<V: View>(_ content: V) -> any View { _StyledGroup(content: content, style: style) }
+    return open(view)
+}

package/Sources/SwiftUI/API/Menu.swift

@@ -0,0 +1,58 @@
+/// A button that shows its content as a menu. The renderer lays out only the
+/// label (the first child, wrapped in a `zstack` so it is always one element)
+/// and lists the remaining children (buttons, inline pickers, dividers,
+/// sections) in a popover when tapped.
+public struct Menu<Label: View, Content: View> {
+    let label: Label
+    let content: Content
+
+    public init(@ViewBuilder content: () -> Content, @ViewBuilder label: () -> Label) {
+        self.content = content()
+        self.label = label()
+    }
+}
+
+extension Menu where Label == Text {
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, @ViewBuilder content: () -> Content) {
+        self.label = Text(title)
+        self.content = content()
+    }
+}
+
+extension Menu where Label == SwiftUI.Label<Text, Image> {
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, systemImage: String, @ViewBuilder content: () -> Content) {
+        self.label = SwiftUI.Label(String(title), systemImage: systemImage)
+        self.content = content()
+    }
+}
+
+extension Menu: _PrimitiveView {}
+extension Menu: _HostView {
+    var _kind: String { "menu" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object([:]) }
+    var _content: [any View] { [ZStack { label }, content] }
+}
+
+public protocol MenuStyle {}
+public struct DefaultMenuStyle: MenuStyle { public init() {} }
+public struct ButtonMenuStyle: MenuStyle { public init() {} }
+extension MenuStyle where Self == DefaultMenuStyle {
+    public static var automatic: DefaultMenuStyle { DefaultMenuStyle() }
+}
+/// A menu whose label is a borderless button (iOS 14's style, deprecated); drawn as the default.
+public struct BorderlessButtonMenuStyle: MenuStyle { public init() {} }
+extension MenuStyle where Self == BorderlessButtonMenuStyle {
+    public static var borderlessButton: BorderlessButtonMenuStyle { BorderlessButtonMenuStyle() }
+}
+extension MenuStyle where Self == ButtonMenuStyle {
+    public static var button: ButtonMenuStyle { ButtonMenuStyle() }
+}
+
+public enum MenuIndicatorVisibility: Hashable, Sendable { case automatic, visible, hidden }
+
+nonisolated extension View {
+    public func menuStyle<S: MenuStyle>(_ style: S) -> some View { self }
+    public func menuIndicator(_ visibility: MenuIndicatorVisibility) -> some View { self }
+}