@swiftbrowser/swift 0.0.0-stage → 0.1.0

package/Sources/SwiftUI/API/Layout.swift

@@ -0,0 +1,165 @@
+public enum TextAlignment: Hashable, Sendable {
+    case leading, center, trailing
+
+    var name: String {
+        switch self {
+        case .leading: "leading"
+        case .center: "center"
+        case .trailing: "trailing"
+        }
+    }
+}
+
+extension View {
+    /// Sets the priority by which a parent stack hands out space.
+    public func layoutPriority(_ value: Double) -> some View {
+        _styled { $0.layoutPriority = value }
+    }
+
+    /// Limits the number of lines text in this view can occupy.
+    public func lineLimit(_ number: Int?) -> some View {
+        _styled { $0.lineLimit = number ?? -1 }
+    }
+
+    /// `reservesSpace` is accepted and ignored: the text takes the lines it needs, up to `limit`.
+    public func lineLimit(_ limit: Int, reservesSpace: Bool) -> some View {
+        _styled { $0.lineLimit = limit }
+    }
+
+    public func multilineTextAlignment(_ alignment: TextAlignment) -> some View {
+        _styled { $0.multilineTextAlignment = alignment }
+    }
+
+    /// Fixes the view at its ideal size on the given axes.
+    public func fixedSize(horizontal: Bool, vertical: Bool) -> some View {
+        _styled { $0.fixedSize = (horizontal, vertical) }
+    }
+
+    public func fixedSize() -> some View {
+        fixedSize(horizontal: true, vertical: true)
+    }
+}
+
+// MARK: - Color and shapes as views
+
+extension Color: _PrimitiveView {}
+extension Color: _HostView {
+    var _kind: String { "color" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object(["color": _json]) }
+}
+
+/// A shape drawn as a view, optionally filled or stroked. `inset` strokes
+/// (`strokeBorder`) lie inside the shape's bounds.
+public struct _ShapeView<S: Shape> {
+    let shape: S
+    let fill: (any ShapeStyle)?
+    let stroke: (style: any ShapeStyle, lineWidth: CGFloat, inset: Bool)?
+}
+extension _ShapeView: _PrimitiveView {}
+extension _ShapeView: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        var stroke: _JSON = .null
+        if let s = self.stroke {
+            var object: [String: _JSON] = ["color": s.style._json, "lineWidth": .number(s.lineWidth)]
+            if s.inset { object["inset"] = .bool(true) }
+            stroke = .object(object)
+        }
+        return .object([
+            "shape": .string(shape._name),
+            "cornerRadius": .number(shape._cornerRadius),
+            "fill": fill?._json ?? .null,
+            "stroke": stroke,
+        ])
+    }
+}
+
+/// Options for `fill`; accepted for source compatibility.
+public struct FillStyle: Equatable, Sendable {
+    public var isEOFilled: Bool
+    public var isAntialiased: Bool
+
+    public init(eoFill: Bool = false, antialiased: Bool = true) {
+        isEOFilled = eoFill
+        isAntialiased = antialiased
+    }
+}
+
+extension Shape {
+    public func fill<S: ShapeStyle>(_ style: S, style fillStyle: FillStyle = FillStyle()) -> some View {
+        _ShapeView(shape: self, fill: style, stroke: nil)
+    }
+
+    /// Filled with the foreground style.
+    public func fill(style: FillStyle = FillStyle()) -> some View {
+        _ShapeView(shape: self, fill: ForegroundStyle(), stroke: nil)
+    }
+
+    public func stroke<S: ShapeStyle>(_ style: S, lineWidth: CGFloat = 1) -> some View {
+        _ShapeView(shape: self, fill: nil, stroke: (style, lineWidth, false))
+    }
+
+    public func stroke(lineWidth: CGFloat = 1) -> some View {
+        _ShapeView(shape: self, fill: nil, stroke: (ForegroundStyle(), lineWidth, false))
+    }
+
+    /// A stroke drawn inside the shape's bounds.
+    public func strokeBorder<S: ShapeStyle>(_ style: S, lineWidth: CGFloat = 1, antialiased: Bool = true) -> some View {
+        _ShapeView(shape: self, fill: nil, stroke: (style, lineWidth, true))
+    }
+
+    public func strokeBorder(lineWidth: CGFloat = 1, antialiased: Bool = true) -> some View {
+        _ShapeView(shape: self, fill: nil, stroke: (ForegroundStyle(), lineWidth, true))
+    }
+}
+
+extension Rectangle: View {
+    public typealias Body = Never
+    public var body: Never { fatalError("Rectangle is a primitive view") }
+}
+extension RoundedRectangle: View {
+    public typealias Body = Never
+    public var body: Never { fatalError("RoundedRectangle is a primitive view") }
+}
+extension Circle: View {
+    public typealias Body = Never
+    public var body: Never { fatalError("Circle is a primitive view") }
+}
+extension Capsule: View {
+    public typealias Body = Never
+    public var body: Never { fatalError("Capsule is a primitive view") }
+}
+extension Ellipse: View {
+    public typealias Body = Never
+    public var body: Never { fatalError("Ellipse is a primitive view") }
+}
+
+extension Rectangle: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON { _shapeProps(self) }
+}
+extension RoundedRectangle: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON { _shapeProps(self) }
+}
+extension Circle: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON { _shapeProps(self) }
+}
+extension Capsule: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON { _shapeProps(self) }
+}
+extension Ellipse: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON { _shapeProps(self) }
+}
+
+private func _shapeProps(_ shape: some Shape) -> _JSON {
+    .object([
+        "shape": .string(shape._name),
+        "cornerRadius": .number(shape._cornerRadius),
+        "fill": .null,
+        "stroke": .null,
+    ])
+}

package/Sources/SwiftUI/API/Lists.swift

@@ -0,0 +1,276 @@
+// 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() }
+}
+
+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
+
+    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
+    }
+
+    /// `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
+    }
+}
+
+/// Lists that carry a selection binding; the runtime puts it in the rows' environment.
+protocol _ListSelectionProviding {
+    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)
+        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 {
+    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
+
+    public init(@ViewBuilder content: () -> Content) {
+        self.header = nil
+        self.footer = nil
+        self.content = content()
+    }
+
+    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()
+    }
+}
+/// Lets pickers look through sections for their options.
+protocol _SectionView {
+    var _sectionContent: any View { get }
+}
+
+extension Section: _SectionView {
+    var _sectionContent: any View { content }
+}
+
+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] { [content] }
+}

package/Sources/SwiftUI/API/Menu.swift

@@ -0,0 +1,51 @@
+/// 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 {
+    public init<S: StringProtocol>(_ title: S, @ViewBuilder content: () -> Content) {
+        self.label = Text(title)
+        self.content = content()
+    }
+}
+
+extension Menu where Label == SwiftUI.Label<Text, Image> {
+    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() }
+}
+extension MenuStyle where Self == ButtonMenuStyle {
+    public static var button: ButtonMenuStyle { ButtonMenuStyle() }
+}
+
+public enum MenuIndicatorVisibility: Hashable, Sendable { case automatic, visible, hidden }
+
+extension View {
+    public func menuStyle<S: MenuStyle>(_ style: S) -> some View { self }
+    public func menuIndicator(_ visibility: MenuIndicatorVisibility) -> some View { self }
+}