@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/SwiftUI/API/Preferences.swift

@@ -0,0 +1,262 @@
+// Preferences: values views pass up to their ancestors, the way environment
+// values pass down. A view sets one with `.preference(key:value:)`; the
+// reconciler combines a subtree's values with the key's `reduce` (children in
+// order) after the subtree's bodies ran, and `.onPreferenceChange`,
+// `.overlayPreferenceValue` and `.backgroundPreferenceValue` read the result.
+// A subtree that is skipped keeps the values it produced last time.
+//
+// Anchors: the Swift side has no layout, so an anchor resolves against the
+// size the renderer reports for the anchored view (its element carries
+// `reportsSize`, like a `GeometryReader`'s), in the view's own coordinates:
+// `.bounds` is `CGRect(origin: .zero, size: measured)`. Until the first
+// report it is zero, and the preference updates when the size arrives.
+
+/// A named value produced by a view, combined over a subtree with `reduce`.
+public protocol PreferenceKey {
+    associatedtype Value
+    static var defaultValue: Value { get }
+    static func reduce(value: inout Value, nextValue: () -> Value)
+}
+
+extension PreferenceKey where Value: ExpressibleByNilLiteral {
+    public static var defaultValue: Value { nil }
+}
+
+/// The preference values a subtree produced, by key type.
+struct _PreferenceValues {
+    struct Entry {
+        var value: Any
+        /// The key's `reduce`, for combining with a later sibling's value.
+        let reduce: (Any, Any) -> Any
+    }
+
+    var entries: [ObjectIdentifier: Entry] = [:]
+
+    var isEmpty: Bool { entries.isEmpty }
+
+    subscript<K: PreferenceKey>(key: K.Type) -> K.Value? {
+        entries[ObjectIdentifier(key)]?.value as? K.Value
+    }
+
+    /// The key's combined value, or its default when nothing in the subtree set it.
+    func value<K: PreferenceKey>(of key: K.Type) -> K.Value { self[key] ?? K.defaultValue }
+
+    mutating func set<K: PreferenceKey>(_ key: K.Type, to value: K.Value) {
+        entries[ObjectIdentifier(key)] = Entry(value: value) { first, next in
+            var combined = first as! K.Value
+            K.reduce(value: &combined) { next as! K.Value }
+            return combined
+        }
+    }
+
+    mutating func remove<K: PreferenceKey>(_ key: K.Type) {
+        entries[ObjectIdentifier(key)] = nil
+    }
+
+    /// Adds a later sibling's values: a key both set is reduced, in order.
+    mutating func merge(_ later: _PreferenceValues) {
+        for (key, entry) in later.entries {
+            if var existing = entries[key] {
+                existing.value = existing.reduce(existing.value, entry.value)
+                entries[key] = existing
+            } else {
+                entries[key] = entry
+            }
+        }
+    }
+}
+
+/// A view that changes its subtree's preference values (after its children's are combined).
+protocol _PreferenceWriting: _TraitBearing {
+    func _write(_ values: inout _PreferenceValues, measured: CGSize)
+}
+
+/// A view that reads its subtree's combined values.
+protocol _PreferenceReading: _TraitBearing {
+    /// Called after the subtree reconciled; `last` is what the previous call returned.
+    @MainActor func _read(_ values: _PreferenceValues, last: Any?) -> (keep: Any?, action: (@MainActor () -> Void)?)
+}
+
+/// A view whose element reports its laid-out size (`reportsSize`).
+protocol _SizeReporting: _TraitBearing {}
+
+/// `overlayPreferenceValue` / `backgroundPreferenceValue`: the decoration is
+/// made from the base's combined value, after the base reconciled.
+protocol _PreferenceValueDecorating: _TraitBearing {
+    var _base: any View { get }
+    func _decoration(from values: _PreferenceValues) -> any View
+}
+
+// MARK: - Setting
+
+struct _PreferenceView<Content: View, Key: PreferenceKey> {
+    let content: Content
+    let value: Key.Value
+}
+extension _PreferenceView: _PrimitiveView, _GroupView {
+    var _children: [any View] { [content] }
+}
+extension _PreferenceView: _PreferenceWriting {
+    func _write(_ values: inout _PreferenceValues, measured: CGSize) { values.set(Key.self, to: value) }
+}
+
+struct _TransformPreferenceView<Content: View, Key: PreferenceKey> {
+    let content: Content
+    let transform: (inout Key.Value) -> Void
+}
+extension _TransformPreferenceView: _PrimitiveView, _GroupView {
+    var _children: [any View] { [content] }
+}
+extension _TransformPreferenceView: _PreferenceWriting {
+    func _write(_ values: inout _PreferenceValues, measured: CGSize) {
+        var value = values.value(of: Key.self)
+        transform(&value)
+        values.set(Key.self, to: value)
+    }
+}
+
+nonisolated extension View {
+    /// Sets the key's value for this view; it replaces what the content set for the key.
+    public func preference<K: PreferenceKey>(key: K.Type = K.self, value: K.Value) -> some View {
+        _PreferenceView<Self, K>(content: self, value: value)
+    }
+
+    /// Changes the key's value the content produced (its default when it set none).
+    public func transformPreference<K: PreferenceKey>(_ key: K.Type = K.self, _ callback: @escaping (inout K.Value) -> Void) -> some View {
+        _TransformPreferenceView<Self, K>(content: self, transform: callback)
+    }
+}
+
+// MARK: - Reading
+
+struct _PreferenceChangeView<Content: View, Key: PreferenceKey> where Key.Value: Equatable {
+    let content: Content
+    let action: (Key.Value) -> Void
+}
+extension _PreferenceChangeView: _PrimitiveView, _GroupView {
+    var _children: [any View] { [content] }
+}
+extension _PreferenceChangeView: _PreferenceReading {
+    @MainActor func _read(_ values: _PreferenceValues, last: Any?) -> (keep: Any?, action: (@MainActor () -> Void)?) {
+        let value = values.value(of: Key.self)
+        if let last = last as? Key.Value, last == value { return (last, nil) }
+        let action = self.action
+        return (value, { action(value) })
+    }
+}
+
+struct _PreferenceDecorationView<Content: View, Key: PreferenceKey, Decoration: View> {
+    let content: Content
+    let decoration: (Key.Value) -> Decoration
+    let role: String
+    let alignment: Alignment
+}
+extension _PreferenceDecorationView: _PrimitiveView {}
+extension _PreferenceDecorationView: _HostView {
+    var _kind: String { "decorated" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(["role": .string(role), "alignment": .string(alignment._name)])
+    }
+    var _content: [any View] { [content] }
+}
+extension _PreferenceDecorationView: _PreferenceValueDecorating {
+    var _base: any View { content }
+    func _decoration(from values: _PreferenceValues) -> any View { decoration(values.value(of: Key.self)) }
+}
+
+nonisolated extension View {
+    /// Runs `action` after a render in which the key's combined value in this
+    /// subtree changed (and after the first, with its initial value).
+    public func onPreferenceChange<K: PreferenceKey>(_ key: K.Type = K.self, perform action: @escaping (K.Value) -> Void) -> some View where K.Value: Equatable {
+        _PreferenceChangeView<Self, K>(content: self, action: action)
+    }
+
+    /// An overlay made from the key's combined value in this view.
+    public func overlayPreferenceValue<K: PreferenceKey, V: View>(_ key: K.Type, alignment: Alignment = .center, @ViewBuilder _ transform: @escaping (K.Value) -> V) -> some View {
+        _PreferenceDecorationView<Self, K, V>(content: self, decoration: transform, role: "overlay", alignment: alignment)
+    }
+
+    /// A background made from the key's combined value in this view.
+    public func backgroundPreferenceValue<K: PreferenceKey, V: View>(_ key: K.Type, alignment: Alignment = .center, @ViewBuilder _ transform: @escaping (K.Value) -> V) -> some View {
+        _PreferenceDecorationView<Self, K, V>(content: self, decoration: transform, role: "background", alignment: alignment)
+    }
+}
+
+// MARK: - Anchors
+
+/// A geometric value of a view, resolved with a `GeometryProxy` subscript.
+public struct Anchor<Value> {
+    let value: Value
+
+    /// How to make an anchor from a view's bounds.
+    public struct Source {
+        let resolve: (CGRect) -> Value
+    }
+}
+extension Anchor: Equatable where Value: Equatable {}
+extension Anchor: Hashable where Value: Hashable {}
+extension Anchor: Sendable where Value: Sendable {}
+
+extension Anchor.Source where Value == CGRect {
+    public static var bounds: Anchor<CGRect>.Source { .init { $0 } }
+    public static func rect(_ r: CGRect) -> Anchor<CGRect>.Source { .init { _ in r } }
+}
+
+extension Anchor.Source where Value == CGPoint {
+    public static func point(_ p: CGPoint) -> Anchor<CGPoint>.Source { .init { _ in p } }
+    public static func unitPoint(_ p: UnitPoint) -> Anchor<CGPoint>.Source {
+        .init { CGPoint(x: $0.minX + p.x * $0.width, y: $0.minY + p.y * $0.height) }
+    }
+    public static var topLeading: Anchor<CGPoint>.Source { unitPoint(.topLeading) }
+    public static var top: Anchor<CGPoint>.Source { unitPoint(.top) }
+    public static var topTrailing: Anchor<CGPoint>.Source { unitPoint(.topTrailing) }
+    public static var leading: Anchor<CGPoint>.Source { unitPoint(.leading) }
+    public static var center: Anchor<CGPoint>.Source { unitPoint(.center) }
+    public static var trailing: Anchor<CGPoint>.Source { unitPoint(.trailing) }
+    public static var bottomLeading: Anchor<CGPoint>.Source { unitPoint(.bottomLeading) }
+    public static var bottom: Anchor<CGPoint>.Source { unitPoint(.bottom) }
+    public static var bottomTrailing: Anchor<CGPoint>.Source { unitPoint(.bottomTrailing) }
+}
+
+extension GeometryProxy {
+    /// The anchor's value, in the anchored view's own coordinates (see the file comment).
+    public subscript<T>(anchor: Anchor<T>) -> T { anchor.value }
+}
+
+struct _AnchorPreferenceView<Content: View, A, Key: PreferenceKey> {
+    let content: Content
+    let source: Anchor<A>.Source
+    /// Sets the value (`anchorPreference`) or changes it (`transformAnchorPreference`).
+    let write: (inout _PreferenceValues, Anchor<A>) -> Void
+}
+extension _AnchorPreferenceView: _PrimitiveView, _SizeReporting {}
+extension _AnchorPreferenceView: _HostView {
+    var _kind: String { "zstack" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(["alignment": .string(Alignment.center._name), "reportsSize": .bool(true)])
+    }
+    var _content: [any View] { [content] }
+}
+extension _AnchorPreferenceView: _PreferenceWriting {
+    func _write(_ values: inout _PreferenceValues, measured: CGSize) {
+        write(&values, Anchor(value: source.resolve(CGRect(origin: .zero, size: measured))))
+    }
+}
+
+nonisolated extension View {
+    /// Sets the key's value from an anchor of this view's bounds.
+    public func anchorPreference<A, K: PreferenceKey>(key: K.Type = K.self, value: Anchor<A>.Source, transform: @escaping (Anchor<A>) -> K.Value) -> some View {
+        _AnchorPreferenceView<Self, A, K>(content: self, source: value) { values, anchor in
+            values.set(K.self, to: transform(anchor))
+        }
+    }
+
+    /// Changes the key's value with an anchor of this view's bounds.
+    public func transformAnchorPreference<A, K: PreferenceKey>(key: K.Type = K.self, value: Anchor<A>.Source, transform: @escaping (inout K.Value, Anchor<A>) -> Void) -> some View {
+        _AnchorPreferenceView<Self, A, K>(content: self, source: value) { values, anchor in
+            var current = values.value(of: K.self)
+            transform(&current, anchor)
+            values.set(K.self, to: current)
+        }
+    }
+}

package/Sources/SwiftUI/API/Presentation.swift

@@ -3,11 +3,23 @@ public struct PresentationDetent: Hashable, Sendable {
     let name: String
     public static let medium = PresentationDetent(name: "medium")
     public static let large = PresentationDetent(name: "large")
+    /// A sheet this many points tall (`"height:<points>"`, capped at the large height).
+    public static func height(_ height: CGFloat) -> PresentationDetent { PresentationDetent(name: "height:\(Double(height))") }
+    /// A sheet this fraction of the screen tall (`"fraction:<f>"`, capped at the large height).
+    public static func fraction(_ fraction: CGFloat) -> PresentationDetent { PresentationDetent(name: "fraction:\(Double(fraction))") }
+
+    /// Orders detents smallest first (a height counts against an 852pt screen).
+    var _order: Double {
+        if name == "medium" { return 0.5 }
+        if name.hasPrefix("height:") { return (Double(name.dropFirst(7)) ?? 852) / 852 }
+        if name.hasPrefix("fraction:") { return Double(name.dropFirst(9)) ?? 1 }
+        return 1
+    }
 }
 
 /// Views that present a sheet. The runtime mounts the sheet content as a
 /// second child and emits it as a root-level `sheet` element while presented.
-protocol _SheetPresenting {
+protocol _SheetPresenting: _TraitBearing {
     var _isPresented: Binding<Bool> { get }
     var _onDismiss: (@MainActor () -> Void)? { get }
     var _base: any View { get }
@@ -36,7 +48,7 @@ extension _SheetView: _SheetPresenting {
     var _fullScreen: Bool { fullScreen }
 }
 
-protocol _DetentsModifying {
+protocol _DetentsModifying: _TraitBearing {
     var _detents: [String] { get }
 }
 
@@ -91,8 +103,9 @@ extension View {
     }
 
     public func presentationDetents(_ detents: Set<PresentationDetent>) -> some View {
-        let order = ["medium", "large"]
-        return _DetentsView(content: self, detents: order.filter { name in detents.contains { $0.name == name } })
+        // Smallest first: the page presents the sheet at the first.
+        let sorted = detents.sorted { ($0._order, $0.name) < ($1._order, $1.name) }
+        return _DetentsView(content: self, detents: sorted.map(\.name))
     }
 }
 

package/Sources/SwiftUI/API/PresentationExtras.swift

@@ -0,0 +1,60 @@
+// Sheet and transition modifiers accepted for source compatibility. The
+// page's sheet keeps its system background, corner radius and drag (to
+// dismiss, and between detents); a navigation push or sheet keeps its own
+// slide instead of iOS 18's zoom from a source view.
+//
+// `.presentationBackground`, `.presentationCornerRadius`,
+// `.presentationBackgroundInteraction`, `.presentationSizing`,
+// `.presentationDragIndicator`, `.interactiveDismissDisabled` (the sheet can
+// still be dragged down), `.navigationTransition` and
+// `.matchedTransitionSource` add nothing to the tree.
+
+public struct PresentationBackgroundInteraction: Sendable {
+    let name: String
+    public static let automatic = PresentationBackgroundInteraction(name: "automatic")
+    public static let enabled = PresentationBackgroundInteraction(name: "enabled")
+    public static func enabled(upThrough detent: PresentationDetent) -> PresentationBackgroundInteraction { .enabled }
+    public static let disabled = PresentationBackgroundInteraction(name: "disabled")
+}
+
+public struct PresentationSizing: Sendable {
+    let name: String
+    public static let automatic = PresentationSizing(name: "automatic")
+    public static let page = PresentationSizing(name: "page")
+    public static let form = PresentationSizing(name: "form")
+    public static let fitted = PresentationSizing(name: "fitted")
+}
+
+/// A navigation transition (iOS 18); the page keeps the standard one.
+public struct NavigationTransition: Sendable {
+    let name: String
+    public static let automatic = NavigationTransition(name: "automatic")
+    public static func zoom<ID: Hashable>(sourceID: ID, in namespace: Namespace.ID) -> NavigationTransition {
+        NavigationTransition(name: "zoom")
+    }
+}
+
+/// What `matchedTransitionSource(id:in:configuration:)` configures; unused.
+public struct EmptyMatchedTransitionSourceConfiguration: Sendable {
+    public func background(_ style: Color) -> EmptyMatchedTransitionSourceConfiguration { self }
+    public func clipShape(_ shape: RoundedRectangle) -> EmptyMatchedTransitionSourceConfiguration { self }
+    public func shadow(color: Color = .black, radius: CGFloat, x: CGFloat = 0, y: CGFloat = 0)
+        -> EmptyMatchedTransitionSourceConfiguration { self }
+}
+
+nonisolated extension View {
+    public func presentationBackground<S: ShapeStyle>(_ style: S) -> some View { self }
+    public func presentationBackground<V: View>(alignment: Alignment = .center, @ViewBuilder content: () -> V) -> some View { self }
+    public func presentationCornerRadius(_ cornerRadius: CGFloat?) -> some View { self }
+    public func presentationBackgroundInteraction(_ interaction: PresentationBackgroundInteraction) -> some View { self }
+    public func presentationSizing(_ sizing: PresentationSizing) -> some View { self }
+    public func presentationDragIndicator(_ visibility: Visibility) -> some View { self }
+    public func interactiveDismissDisabled(_ isDisabled: Bool = true) -> some View { self }
+
+    public func navigationTransition(_ style: NavigationTransition) -> some View { self }
+    public func matchedTransitionSource<ID: Hashable>(id: ID, in namespace: Namespace.ID) -> some View { self }
+    public func matchedTransitionSource<ID: Hashable>(
+        id: ID, in namespace: Namespace.ID,
+        configuration: (EmptyMatchedTransitionSourceConfiguration) -> EmptyMatchedTransitionSourceConfiguration
+    ) -> some View { self }
+}