@swiftbrowser/swift 0.1.0 → 0.2.0

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