@swiftbrowser/swift 0.1.0 → 0.3.0

package/Sources/SwiftUI/API/Menu.swift

@@ -13,6 +13,7 @@ public struct Menu<Label: View, Content: View> {
 }
 
 extension Menu where Label == Text {
+    @_disfavoredOverload
     public init<S: StringProtocol>(_ title: S, @ViewBuilder content: () -> Content) {
         self.label = Text(title)
         self.content = content()
@@ -20,6 +21,7 @@ extension Menu where Label == Text {
 }
 
 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()
@@ -39,13 +41,18 @@ 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 }
 
-extension View {
+nonisolated extension View {
     public func menuStyle<S: MenuStyle>(_ style: S) -> some View { self }
     public func menuIndicator(_ visibility: MenuIndicatorVisibility) -> some View { self }
 }

package/Sources/SwiftUI/API/Modifiers.swift

@@ -37,6 +37,10 @@ struct _Style: Equatable {
     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?
@@ -88,9 +92,31 @@ public struct _StyledView<Content: View> {
     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 { .object(["style": style._json]) }
+    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] }
 }
 
@@ -104,21 +130,40 @@ public struct _StyledGroup<Content: View> {
 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) }
+        // 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 {
+            let target = _spreadTarget(group)
+            var children = target._children
+            // A view of the group that is absent (`if locked { badge }` when not
+            // locked) gets no styled element: an empty one would take a stack's
+            // spacing. Keyed children keep their places.
+            if target._keys == nil { children.removeAll(where: _rendersNothing) }
+            return 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
+        if let group = content as? any _GroupView, group._spreads {
+            return _spreadTarget(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
+    }
 }
 
-extension View {
+nonisolated extension View {
     func _styled(_ configure: (inout _Style) -> Void) -> _StyledGroup<Self> {
         var style = _Style()
         configure(&style)
@@ -139,6 +184,16 @@ extension View {
         }
     }
 
+    /// 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)
     }
@@ -182,13 +237,20 @@ extension View {
     }
 
     /// 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 }
+        _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() }
+        _styled {
+            $0.background = BackgroundStyle()
+            $0.backgroundInContainerShape = true
+        }
     }
 
     public func opacity(_ opacity: Double) -> some View {
@@ -227,10 +289,15 @@ extension View {
 
     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 }
+    /// 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 {
@@ -238,6 +305,15 @@ extension View {
     }
 
     public func clipShape<S: Shape>(_ shape: S) -> some View {
-        _styled { $0.cornerRadius = shape._cornerRadius }
+        _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 }
+}

package/Sources/SwiftUI/API/Navigation.swift

@@ -23,7 +23,7 @@ public struct NavigationPath: Equatable {
     }
 }
 
-protocol _NavigationStackView {
+protocol _NavigationStackView: _TraitBearing {
     var _root: any View { get }
     var _pushedBox: _StateBox<[_PushedScreen]> { get }
     /// Value-based path, when the stack was created with one.
@@ -87,7 +87,7 @@ extension _PathScreenValue: _GroupView {
     var _children: [any View] { [] }
 }
 
-protocol _DestinationRegistering {
+protocol _DestinationRegistering: _TraitBearing {
     var _destinationType: ObjectIdentifier { get }
     var _destinationTypeName: String { get }
     func _destination(for value: Any) -> (any View)?
@@ -110,7 +110,7 @@ extension _DestinationView: _DestinationRegistering {
     }
 }
 
-extension View {
+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,
@@ -119,7 +119,7 @@ extension View {
     }
 }
 
-protocol _NavigationValueLinkView {
+protocol _NavigationValueLinkView: _TraitBearing {
     var _value: AnyHashable? { get }
 }
 
@@ -156,7 +156,7 @@ extension _NavScreenView: _HostView {
     var _content: [any View] { [content] }
 }
 
-protocol _NavigationLinkView {
+protocol _NavigationLinkView: _TraitBearing {
     var _destination: any View { get }
 }
 
@@ -180,12 +180,26 @@ public struct NavigationLink<Label: View, Destination: View> {
 }
 
 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
@@ -237,7 +251,7 @@ extension NavigationSplitViewStyle where Self == ProminentDetailNavigationSplitV
     public static var prominentDetail: ProminentDetailNavigationSplitViewStyle { ProminentDetailNavigationSplitViewStyle() }
 }
 
-extension View {
+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 }
@@ -247,7 +261,7 @@ extension View {
 /// 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 {
+protocol _NavigationSplitHost: _TraitBearing {
     var _sidebar: any View { get }
     var _detail: any View { get }
     /// Screens pushed from the compact detail (links inside it).
@@ -332,7 +346,7 @@ public enum NavigationBarItem {
     }
 }
 
-protocol _NavigationTitleModifying {
+protocol _NavigationTitleModifying: _TraitBearing {
     var _title: String? { get }
     var _displayMode: String? { get }
 }
@@ -351,7 +365,8 @@ extension _NavigationTitleView: _NavigationTitleModifying {
     var _displayMode: String? { displayMode }
 }
 
-extension View {
+nonisolated extension View {
+    @_disfavoredOverload
     public func navigationTitle<S: StringProtocol>(_ title: S) -> some View {
         _NavigationTitleView(content: self, title: String(title), displayMode: nil)
     }

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")
+                        }
+                    }
+                }
+        }
+    }
+}

package/Sources/SwiftUI/API/ObservableObject.swift

@@ -72,6 +72,20 @@ public final class ObservableObjectPublisher {
         subscribers[ObjectIdentifier(owner)] = (_WeakOwner(owner), onChange)
     }
 
+    /// Combine's subscriptions (Sources/Combine/ObjectWillChange.swift):
+    /// `onChange` runs on each `send()` while the returned token is alive
+    /// and not unsubscribed.
+    public func _subscribe(_ onChange: @escaping () -> Void) -> AnyObject {
+        let token = _WeakOwner(self)
+        _subscribe(owner: token, onChange)
+        return token
+    }
+
+    /// Ends a subscription `_subscribe(_:)` made.
+    public func _unsubscribe(_ token: AnyObject) {
+        subscribers[ObjectIdentifier(token)] = nil
+    }
+
     static func _publisher(for object: AnyObject) -> ObservableObjectPublisher {
         let id = ObjectIdentifier(object)
         if let existing = registry[id], existing._owner === object { return existing }
@@ -118,7 +132,7 @@ public struct Published<Value> {
 
 /// Views expose properties that observe an `ObservableObject` through this
 /// protocol; the runtime finds them by reflection and wires invalidation.
-protocol _ObservingProperty {
+protocol _ObservingProperty: _RuntimeProperty {
     /// Subscribes `onChange` to the observed object on behalf of `owner`
     /// (the mounted view), see `ObservableObjectPublisher._subscribe`.
     func _observe(owner: AnyObject, _ onChange: @escaping () -> Void)
@@ -271,7 +285,7 @@ extension EnvironmentObject: _ObservingProperty {
     }
 }
 
-extension View {
+nonisolated extension View {
     /// Supplies `object` to every `EnvironmentObject` of its type in the subtree.
     public func environmentObject<T: ObservableObject>(_ object: T) -> some View {
         _EnvironmentView(content: self) { $0._setObject(object) }