@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/API/Modifiers.swift

@@ -0,0 +1,313 @@
+/// 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?
+    /// `.clipShape(.containerRelative)`: clipped to the container's corners.
+    var clipsToContainerShape = false
+    /// `.background(_:)`: painted in the container's shape (`.containerShape`).
+    var backgroundInContainerShape = false
+    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: _EnvironmentModifying {
+    /// A font with a text style or a size is the environment's `font` below
+    /// (a weight or design alone changes the font the page draws, not that).
+    func _apply(to environment: inout EnvironmentValues) {
+        if let font = style.font, font.textStyle != nil || font.size != nil { environment.font = font }
+    }
+}
+extension _StyledView: _HostView {
+    var _kind: String { "styled" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        var resolved = style
+        // `.background()` paints the background style in context, which
+        // `.backgroundStyle(_:)` sets (the system background by default).
+        if style.background is BackgroundStyle, let contextual = environment._backgroundStyle {
+            resolved.background = contextual
+        }
+        // The container's shape (`.containerShape`): a background is painted
+        // in it, and `.clipShape(.containerRelative)` clips to it.
+        let container = environment._containerShapeRadius
+        if style.clipsToContainerShape { resolved.cornerRadius = container ?? 0 }
+        if style.backgroundInContainerShape, let container, container > 0 {
+            resolved.extras["backgroundCornerRadius"] = .number(container)
+        }
+        return .object(["style": resolved._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] {
+        // A modifier on a `Section` styles its rows (the section stays a direct
+        // child of its list, which is how the layout recognizes it).
+        if let section = content as? any _SectionView { return [section._stylingRows(style)] }
+        if let group = content as? any _GroupView, group._spreads {
+            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._spreads {
+            return group._keys
+        }
+        return nil
+    }
+
+    // Asked of the content alone: a chain of modifiers asks each level once,
+    // where computing the content's children and keys at every level made
+    // the cost double with each modifier.
+    var _spreads: Bool {
+        guard let group = content as? any _GroupView, group._spreads else { return false }
+        // A styled section is one child; it keeps the section's keys.
+        if content is any _SectionView { return group._keys != nil }
+        return true
+    }
+}
+
+nonisolated 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
+            )
+        }
+    }
+
+    /// The padding a scene's content takes from its edges: 16 points on
+    /// iPhone, as `.padding()`.
+    public func scenePadding(_ edges: Edge.Set = .all) -> some View {
+        padding(edges, 16)
+    }
+
+    public func scenePadding(_ padding: ScenePadding, edges: Edge.Set = .all) -> some View {
+        self.padding(edges, 16)
+    }
+
+    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.
+    /// Painted in the container's shape (`.containerShape`), else the box, as in SwiftUI.
+    public func background<S: ShapeStyle>(_ style: S, ignoresSafeAreaEdges edges: Edge.Set = .all) -> some View {
+        _styled {
+            $0.background = style
+            $0.backgroundInContainerShape = true
+        }
+    }
+
+    /// The system background color behind the view.
+    public func background(ignoresSafeAreaEdges edges: Edge.Set = .all) -> some View {
+        _styled {
+            $0.background = BackgroundStyle()
+            $0.backgroundInContainerShape = true
+        }
+    }
+
+    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) }
+
+    /// Names the view for `ScrollViewProxy.scrollTo(_:anchor:)` inside a
+    /// `ScrollViewReader` (ScrollViewReader.swift); elsewhere it adds nothing
+    /// to the rendered tree. A changed id does not reset the view's state.
+    public func id<ID: Hashable>(_ id: ID) -> some View {
+        _IdentifiedView(content: self, id: AnyHashable(id))
+    }
+
+    /// A compositing hint; accepted for source compatibility and currently
+    /// without effect on the rendered tree.
+    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
+            $0.clipsToContainerShape = shape is ContainerRelativeShape
+        }
+    }
+}
+
+/// The kind of scene padding (`.minimum`); iPhone has one.
+public struct ScenePadding: Equatable, Sendable {
+    public static let minimum = ScenePadding()
+    public static let navigationBar = ScenePadding()
+}

package/Sources/SwiftUI/API/MoreModifiers.swift

@@ -0,0 +1,100 @@
+// Smaller modifiers Ice Cubes uses.
+//
+// Drawn: `.border(_:width:)` (a stroke inside the view's box, as an
+// overlay), `.edgesIgnoringSafeArea(_:)` (`.ignoresSafeArea(edges:)`),
+// `.safeAreaBar(edge:…)` (iOS 26; as `.safeAreaInset`, see
+// ScrollModifiers.swift) and `.scrollPosition(id:anchor:)` (setting the
+// binding scrolls to the view with that `.id`, as `ScrollViewProxy.scrollTo`;
+// scrolling by hand does not update the binding).
+//
+// Accepted without effect: `.buttonBorderShape(_:)` (bordered buttons stay
+// capsules), `.truncationMode(_:)` (text truncates at its tail),
+// `.lineSpacing(_:)` (lines keep the font's line height),
+// `.controlGroupStyle(_:)`, `.listRowHoverEffectDisabled(_:)`,
+// `.searchScopes(_:scopes:)` (no scope bar is drawn under the search field)
+// and, on toolbar items, `.sharedBackgroundVisibility(_:)` and
+// `.matchedTransitionSource(id:in:)`.
+
+public struct ButtonBorderShape: Equatable, Sendable {
+    let name: String
+    public static let automatic = ButtonBorderShape(name: "automatic")
+    public static let capsule = ButtonBorderShape(name: "capsule")
+    public static let circle = ButtonBorderShape(name: "circle")
+    public static let roundedRectangle = ButtonBorderShape(name: "roundedRectangle")
+    public static func roundedRectangle(radius: CGFloat) -> ButtonBorderShape { .roundedRectangle }
+}
+
+public protocol ControlGroupStyle {}
+public struct AutomaticControlGroupStyle: ControlGroupStyle { public init() {} }
+public struct MenuControlGroupStyle: ControlGroupStyle { public init() {} }
+public struct CompactMenuControlGroupStyle: ControlGroupStyle { public init() {} }
+public struct NavigationControlGroupStyle: ControlGroupStyle { public init() {} }
+public struct PaletteControlGroupStyle: ControlGroupStyle { public init() {} }
+extension ControlGroupStyle where Self == AutomaticControlGroupStyle {
+    public static var automatic: AutomaticControlGroupStyle { AutomaticControlGroupStyle() }
+}
+extension ControlGroupStyle where Self == MenuControlGroupStyle {
+    public static var menu: MenuControlGroupStyle { MenuControlGroupStyle() }
+}
+extension ControlGroupStyle where Self == CompactMenuControlGroupStyle {
+    public static var compactMenu: CompactMenuControlGroupStyle { CompactMenuControlGroupStyle() }
+}
+extension ControlGroupStyle where Self == NavigationControlGroupStyle {
+    public static var navigation: NavigationControlGroupStyle { NavigationControlGroupStyle() }
+}
+extension ControlGroupStyle where Self == PaletteControlGroupStyle {
+    public static var palette: PaletteControlGroupStyle { PaletteControlGroupStyle() }
+}
+
+/// When a search's scope bar shows; accepted.
+public struct SearchScopeActivation: Sendable {
+    let name: String
+    public static let automatic = SearchScopeActivation(name: "automatic")
+    public static let onTextEntry = SearchScopeActivation(name: "onTextEntry")
+    public static let onSearchPresentation = SearchScopeActivation(name: "onSearchPresentation")
+}
+
+nonisolated extension View {
+    public func border<S: ShapeStyle>(_ content: S, width: CGFloat = 1) -> some View {
+        overlay { Rectangle().strokeBorder(content, lineWidth: width) }
+    }
+
+    public func edgesIgnoringSafeArea(_ edges: Edge.Set) -> some View {
+        ignoresSafeArea(.all, edges: edges)
+    }
+
+    public func safeAreaBar<V: View>(edge: VerticalEdge, alignment: HorizontalAlignment = .center,
+                                     spacing: CGFloat? = nil, @ViewBuilder content: () -> V) -> some View {
+        safeAreaInset(edge: edge, alignment: alignment, spacing: spacing, content: content)
+    }
+
+    public func buttonBorderShape(_ shape: ButtonBorderShape) -> some View { self }
+    public func truncationMode(_ mode: Text.TruncationMode) -> some View { self }
+    public func lineSpacing(_ lineSpacing: CGFloat) -> some View { self }
+    public func controlGroupStyle<S: ControlGroupStyle>(_ style: S) -> some View { self }
+    public func listRowHoverEffectDisabled(_ disabled: Bool = true) -> some View { self }
+
+    public func searchScopes<V: Hashable, S: View>(_ scope: Binding<V>, @ViewBuilder scopes: () -> S) -> some View { self }
+    public func searchScopes<V: Hashable, S: View>(_ scope: Binding<V>, activation: SearchScopeActivation,
+                                                   @ViewBuilder _ scopes: () -> S) -> some View { self }
+}
+
+extension View {
+    /// Scrolls to the view whose `.id` the binding holds whenever the binding
+    /// changes (see the top of this file).
+    public func scrollPosition<ID: Hashable>(id: Binding<ID?>, anchor: UnitPoint? = nil) -> some View {
+        ScrollViewReader { proxy in
+            self.onChange(of: id.wrappedValue) { _, target in
+                if let target { proxy.scrollTo(target, anchor: anchor) }
+            }
+        }
+    }
+}
+
+extension ToolbarContent {
+    /// Accepted: toolbar items share the bar's background.
+    public nonisolated func sharedBackgroundVisibility(_ visibility: Visibility) -> Self { self }
+
+    /// Accepted (no zoom transitions on the page).
+    public nonisolated func matchedTransitionSource<ID: Hashable>(id: ID, in namespace: Namespace.ID) -> Self { self }
+}

package/Sources/SwiftUI/API/Namespace.swift

@@ -0,0 +1,44 @@
+// `@Namespace` and `.matchedGeometryEffect`. A namespace is an identifier
+// that lasts as long as its view is mounted (its storage is a `State`), so
+// code that passes it around or keys things by it (ButtonKit's triggers, Ice
+// Cubes' media viewer) works. The page does not animate a view from one
+// place to another, so `.matchedGeometryEffect` leaves the view as it is:
+// the change happens without the shared-element animation.
+
+/// An identifier for a group of matched views, stable while the view is mounted.
+@propertyWrapper
+public struct Namespace: DynamicProperty {
+    public struct ID: Hashable, Sendable {
+        let value: Int
+    }
+
+    nonisolated(unsafe) static var lastID = 0
+    let state: State<ID>
+
+    public init() {
+        Namespace.lastID += 1
+        state = State(wrappedValue: ID(value: Namespace.lastID))
+    }
+
+    public var wrappedValue: ID { state.wrappedValue }
+}
+
+extension Namespace: _StateProperty {
+    var _box: any _AnyStateBox { state.box }
+}
+
+/// Which of a view's geometry `.matchedGeometryEffect` would match.
+public struct MatchedGeometryProperties: OptionSet, Hashable, Sendable {
+    public let rawValue: UInt32
+    public init(rawValue: UInt32) { self.rawValue = rawValue }
+    public static let position = MatchedGeometryProperties(rawValue: 1)
+    public static let size = MatchedGeometryProperties(rawValue: 2)
+    public static let frame: MatchedGeometryProperties = [.position, .size]
+}
+
+nonisolated extension View {
+    /// The view unchanged: the page has no shared-element animation.
+    public func matchedGeometryEffect<ID: Hashable>(id: ID, in namespace: Namespace.ID,
+                                                    properties: MatchedGeometryProperties = .frame,
+                                                    anchor: UnitPoint = .center, isSource: Bool = true) -> some View { self }
+}