@swiftbrowser/swift 0.1.0 → 0.3.0

package/Sources/SwiftUI/API/StackLayouts.swift

@@ -0,0 +1,199 @@
+/// `VStackLayout`, `HStackLayout`, `ZStackLayout` and `AnyLayout` (iOS 16):
+/// the stacks as `Layout` values, so that a view can switch its layout
+/// (`let layout = isCompact ? AnyLayout(VStackLayout()) : AnyLayout(HStackLayout())`).
+///
+/// Used as a container (`VStackLayout(spacing: 0) { … }`), a stack layout is
+/// the stack itself: the same `vstack` / `hstack` / `zstack` element, laid out
+/// by the page. `AnyLayout` does the same for a stack it wraps, and is a
+/// custom `layout` element (Phase 6) for any other layout. Switching an
+/// `AnyLayout` between kinds rebuilds its content (approximation: SwiftUI
+/// keeps the children's state and animates them to their new places).
+///
+/// Their `Layout` methods compute the stacks in Swift too, for a custom
+/// layout that delegates to one: subviews get the proposal (a vertical
+/// stack's height and a horizontal stack's width shared evenly), are placed
+/// one after the other `spacing` apart (8 by default) and aligned across
+/// the axis.
+
+public struct VStackLayout: Layout {
+    public var alignment: HorizontalAlignment
+    public var spacing: CGFloat?
+
+    public init(alignment: HorizontalAlignment = .center, spacing: CGFloat? = nil) {
+        self.alignment = alignment
+        self.spacing = spacing
+    }
+
+    public static var layoutProperties: LayoutProperties {
+        var properties = LayoutProperties()
+        properties.stackOrientation = .vertical
+        return properties
+    }
+
+    public func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
+        let sizes = _stackSizes(subviews, proposal: proposal, vertical: true)
+        let gap = spacing ?? 8
+        return CGSize(width: sizes.map(\.width).max() ?? 0,
+                      height: sizes.map(\.height).reduce(0, +) + gap * CGFloat(max(0, sizes.count - 1)))
+    }
+
+    public func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
+        let sizes = _stackSizes(subviews, proposal: proposal, vertical: true)
+        var y = bounds.minY
+        for (subview, size) in zip(subviews, sizes) {
+            let x: CGFloat = switch alignment.name {
+            case "leading": bounds.minX
+            case "trailing": bounds.maxX - size.width
+            default: bounds.midX - size.width / 2
+            }
+            subview.place(at: CGPoint(x: x, y: y), anchor: .topLeading, proposal: ProposedViewSize(size))
+            y += size.height + (spacing ?? 8)
+        }
+    }
+
+    /// The stack itself: a `VStack` of the content.
+    public func callAsFunction<V: View>(@ViewBuilder _ content: () -> V) -> some View {
+        VStack(alignment: alignment, spacing: spacing, content: content)
+    }
+}
+
+public struct HStackLayout: Layout {
+    public var alignment: VerticalAlignment
+    public var spacing: CGFloat?
+
+    public init(alignment: VerticalAlignment = .center, spacing: CGFloat? = nil) {
+        self.alignment = alignment
+        self.spacing = spacing
+    }
+
+    public static var layoutProperties: LayoutProperties {
+        var properties = LayoutProperties()
+        properties.stackOrientation = .horizontal
+        return properties
+    }
+
+    public func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
+        let sizes = _stackSizes(subviews, proposal: proposal, vertical: false)
+        let gap = spacing ?? 8
+        return CGSize(width: sizes.map(\.width).reduce(0, +) + gap * CGFloat(max(0, sizes.count - 1)),
+                      height: sizes.map(\.height).max() ?? 0)
+    }
+
+    public func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
+        let sizes = _stackSizes(subviews, proposal: proposal, vertical: false)
+        var x = bounds.minX
+        for (subview, size) in zip(subviews, sizes) {
+            let y: CGFloat = switch alignment.name {
+            case "top": bounds.minY
+            case "bottom": bounds.maxY - size.height
+            default: bounds.midY - size.height / 2
+            }
+            subview.place(at: CGPoint(x: x, y: y), anchor: .topLeading, proposal: ProposedViewSize(size))
+            x += size.width + (spacing ?? 8)
+        }
+    }
+
+    /// The stack itself: an `HStack` of the content.
+    public func callAsFunction<V: View>(@ViewBuilder _ content: () -> V) -> some View {
+        HStack(alignment: alignment, spacing: spacing, content: content)
+    }
+}
+
+public struct ZStackLayout: Layout {
+    public var alignment: Alignment
+
+    public init(alignment: Alignment = .center) {
+        self.alignment = alignment
+    }
+
+    public func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) -> CGSize {
+        let sizes = subviews.map { $0.sizeThatFits(proposal) }
+        return CGSize(width: sizes.map(\.width).max() ?? 0, height: sizes.map(\.height).max() ?? 0)
+    }
+
+    public func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout ()) {
+        for subview in subviews {
+            let size = subview.sizeThatFits(proposal)
+            let x: CGFloat = switch alignment.horizontal.name {
+            case "leading": bounds.minX
+            case "trailing": bounds.maxX - size.width
+            default: bounds.midX - size.width / 2
+            }
+            let y: CGFloat = switch alignment.vertical.name {
+            case "top": bounds.minY
+            case "bottom": bounds.maxY - size.height
+            default: bounds.midY - size.height / 2
+            }
+            subview.place(at: CGPoint(x: x, y: y), anchor: .topLeading, proposal: ProposedViewSize(size))
+        }
+    }
+
+    /// The stack itself: a `ZStack` of the content.
+    public func callAsFunction<V: View>(@ViewBuilder _ content: () -> V) -> some View {
+        ZStack(alignment: alignment, content: content)
+    }
+}
+
+/// Each subview's size along a stack: the proposal's length along the axis
+/// shared evenly, the full proposal across it.
+func _stackSizes(_ subviews: LayoutSubviews, proposal: ProposedViewSize, vertical: Bool) -> [CGSize] {
+    let count = CGFloat(max(1, subviews.count))
+    let share: ProposedViewSize = vertical
+        ? ProposedViewSize(width: proposal.width, height: proposal.height.map { $0 / count })
+        : ProposedViewSize(width: proposal.width.map { $0 / count }, height: proposal.height)
+    return subviews.map { $0.sizeThatFits(share) }
+}
+
+/// A layout chosen at run time.
+public struct AnyLayout: Layout {
+    let base: any Layout
+
+    public init<L: Layout>(_ layout: L) {
+        if let any = layout as? AnyLayout { base = any.base } else { base = layout }
+    }
+
+    public typealias Cache = _AnyLayoutCache
+
+    public static var layoutProperties: LayoutProperties { LayoutProperties() }
+
+    public func makeCache(subviews: Subviews) -> Cache {
+        func make<L: Layout>(_ layout: L) -> Any { layout.makeCache(subviews: subviews) }
+        return _AnyLayoutCache(value: make(base))
+    }
+
+    public func updateCache(_ cache: inout Cache, subviews: Subviews) {
+        cache = makeCache(subviews: subviews)
+    }
+
+    public func sizeThatFits(proposal: ProposedViewSize, subviews: Subviews, cache: inout Cache) -> CGSize {
+        func size<L: Layout>(_ layout: L) -> CGSize {
+            var typed = cache.value as! L.Cache
+            defer { cache.value = typed }
+            return layout.sizeThatFits(proposal: proposal, subviews: subviews, cache: &typed)
+        }
+        return size(base)
+    }
+
+    public func placeSubviews(in bounds: CGRect, proposal: ProposedViewSize, subviews: Subviews, cache: inout Cache) {
+        func place<L: Layout>(_ layout: L) {
+            var typed = cache.value as! L.Cache
+            layout.placeSubviews(in: bounds, proposal: proposal, subviews: subviews, cache: &typed)
+            cache.value = typed
+        }
+        place(base)
+    }
+
+    /// The wrapped stack's own element for a stack layout, else a `layout` element.
+    public func callAsFunction<V: View>(@ViewBuilder _ content: () -> V) -> some View {
+        let content = content()
+        if let stack = base as? VStackLayout { return AnyView(stack { content }) }
+        if let stack = base as? HStackLayout { return AnyView(stack { content }) }
+        if let stack = base as? ZStackLayout { return AnyView(stack { content }) }
+        return AnyView(_LayoutView(layout: self, content: content))
+    }
+}
+
+/// `AnyLayout`'s cache: the wrapped layout's.
+public struct _AnyLayoutCache {
+    var value: Any
+}

package/Sources/SwiftUI/API/State.swift

@@ -18,7 +18,7 @@ protocol _AnyStateBox: AnyObject {
 }
 
 /// Views expose their `State` properties to the runtime through this protocol.
-protocol _StateProperty {
+protocol _StateProperty: _RuntimeProperty {
     var _box: any _AnyStateBox { get }
 }
 
@@ -101,10 +101,21 @@ extension State: _StateProperty {
 public struct Binding<Value>: DynamicProperty {
     let getter: () -> Value
     let setter: (Value) -> Void
+    /// What the binding points at, for a binding the runtime re-creates on
+    /// every pass (a node's edit mode); nil for every other binding, which
+    /// then never compares equal (see `_Sameness`).
+    let identity: _RuntimeKey?
 
     public init(get: @escaping () -> Value, set: @escaping (Value) -> Void) {
         getter = get
         setter = set
+        identity = nil
+    }
+
+    init(identity: _RuntimeKey, get: @escaping () -> Value, set: @escaping (Value) -> Void) {
+        getter = get
+        setter = set
+        self.identity = identity
     }
 
     public static func constant(_ value: Value) -> Binding<Value> {
@@ -118,6 +129,12 @@ public struct Binding<Value>: DynamicProperty {
 
     public var projectedValue: Binding<Value> { self }
 
+    /// The binding itself: what a `$name` closure parameter (`ForEach($items) { $item in … }`)
+    /// is made from. It must be declared in the type for the compiler to find it.
+    public init(projectedValue: Binding<Value>) {
+        self = projectedValue
+    }
+
     public subscript<Subject>(dynamicMember keyPath: WritableKeyPath<Value, Subject>) -> Binding<Subject> {
         Binding<Subject>(
             get: { self.wrappedValue[keyPath: keyPath] },

package/Sources/SwiftUI/API/StatusGaps.swift

@@ -0,0 +1,121 @@
+import Foundation
+
+// Smaller SwiftUI API that Ice Cubes' status rows and composer use.
+
+extension LocalizedStringKey.StringInterpolation {
+    /// `"Closes in \(date, style: .timer)"`: the date formatted as
+    /// `Text(date, style:)` formats it, when the text is made (TextDates.swift).
+    public mutating func appendInterpolation(_ date: Date, style: Text.DateStyle) {
+        _append(.string(Text._format(date, style: style, now: Date())), specifier: "%@")
+    }
+}
+
+extension AnyTransition {
+    /// Moves in from `edge` while fading in, and out toward the opposite edge
+    /// while fading out (iOS 16).
+    public static func push(from edge: Edge) -> AnyTransition {
+        let opposite: Edge = switch edge {
+        case .top: .bottom
+        case .bottom: .top
+        case .leading: .trailing
+        case .trailing: .leading
+        }
+        return .asymmetric(insertion: .move(edge: edge).combined(with: .opacity),
+                           removal: .move(edge: opposite).combined(with: .opacity))
+    }
+}
+
+/// Space between toolbar items (iOS 26), which separates Liquid Glass
+/// groups. The page lays a placement's items out in a row of its own, so the
+/// spacer adds nothing.
+nonisolated public struct ToolbarSpacer: ToolbarContent {
+    public init(_ sizing: SpacerSizing = .flexible, placement: ToolbarItemPlacement = .automatic) {}
+    nonisolated public var _toolbarItems: [any View] { [] }
+}
+
+/// How much room a `ToolbarSpacer` takes.
+public struct SpacerSizing: Hashable, Sendable {
+    let name: String
+    public static let flexible = SpacerSizing(name: "flexible")
+    public static let fixed = SpacerSizing(name: "fixed")
+}
+
+nonisolated extension View {
+    /// Accepted: the actions are for assistive technologies the page does not bridge.
+    public func accessibilityActions<Content: View>(@ViewBuilder _ content: () -> Content) -> some View { self }
+}
+
+/// The view's tint as a style (`.foregroundStyle(.tint)`): the nearest
+/// `.tint(_:)`, else the accent color, resolved by the page.
+public struct TintShapeStyle: ShapeStyle, Hashable {
+    public init() {}
+    public var _json: _JSON { .object(["name": .string("tint")]) }
+}
+
+extension ShapeStyle where Self == TintShapeStyle {
+    public static var tint: TintShapeStyle { TintShapeStyle() }
+}
+
+private struct _DefaultMinListRowHeightKey: EnvironmentKey {
+    static var defaultValue: CGFloat { 44 }
+}
+
+private struct _DefaultMinListHeaderHeightKey: EnvironmentKey {
+    static var defaultValue: CGFloat? { nil }
+}
+
+extension EnvironmentValues {
+    /// A list row's minimum height, 44 by default: the page sizes a `List`'s
+    /// rows to their content, at least this (the list's `minRowHeight` prop).
+    public var defaultMinListRowHeight: CGFloat {
+        get { self[_DefaultMinListRowHeightKey.self] }
+        set { self[_DefaultMinListRowHeightKey.self] = newValue }
+    }
+
+    /// A list section header's minimum height; recorded.
+    public var defaultMinListHeaderHeight: CGFloat? {
+        get { self[_DefaultMinListHeaderHeightKey.self] }
+        set { self[_DefaultMinListHeaderHeightKey.self] = newValue }
+    }
+}
+
+extension GeometryProxy {
+    /// Zero: the page does not report the safe area to Swift.
+    public var safeAreaInsets: EdgeInsets { EdgeInsets() }
+}
+
+nonisolated extension View {
+    /// The navigation title from a localized key (the key's text: no string tables are loaded).
+    public func navigationTitle(_ titleKey: LocalizedStringKey) -> some View {
+        navigationTitle(Text(titleKey))
+    }
+}
+
+extension Font {
+    /// The same font: digits keep their proportional widths on the page.
+    public func monospacedDigit() -> Font { self }
+}
+
+nonisolated extension View {
+    /// The sheet's detents with the one `selection` names first, so the page
+    /// presents the sheet at it (the page reports no resizing: the binding
+    /// changes only when the app sets it).
+    public func presentationDetents(_ detents: Set<PresentationDetent>, selection: Binding<PresentationDetent>) -> some View {
+        let sorted = detents.sorted { ($0._order, $0.name) < ($1._order, $1.name) }
+        let selected = selection.wrappedValue
+        let ordered = sorted.contains(selected) ? [selected] + sorted.filter { $0 != selected } : sorted
+        return _DetentsView(content: self, detents: ordered.map(\.name))
+    }
+}
+
+extension SearchFieldPlacement {
+    /// When the navigation bar's search field shows.
+    public enum NavigationBarDrawerDisplayMode: Hashable, Sendable {
+        case automatic, always
+    }
+
+    /// The search field in the navigation bar's drawer; the page always shows it there.
+    public static func navigationBarDrawer(displayMode: NavigationBarDrawerDisplayMode) -> SearchFieldPlacement {
+        .navigationBarDrawer
+    }
+}

package/Sources/SwiftUI/API/SymbolEffects.swift

@@ -0,0 +1,203 @@
+// SF Symbols' effects (the Symbols framework's types, which SwiftUI
+// re-exports on iOS, as here) and the modifiers that apply them:
+// `.symbolEffect(.pulse, isActive:)`, `.symbolEffect(.bounce, value:)`,
+// `.contentTransition(.symbolEffect(.replace))`. An effect keeps the options
+// it was built with. The page draws a symbol as a still glyph, with no
+// layers to animate, so the modifiers return the view unchanged: the symbol
+// shows, without the bounce, pulse or replacement animation.
+//
+// The Symbols module (Sources/Symbols) re-exports these types for files that
+// `import Symbols`.
+
+// MARK: - Effect kinds
+
+/// A symbol effect: its options, kept.
+public protocol SymbolEffect: Hashable, Sendable {}
+/// Plays once each time a value changes (`.symbolEffect(_:value:)`).
+public protocol DiscreteSymbolEffect: SymbolEffect {}
+/// Plays while active (`.symbolEffect(_:isActive:)`).
+public protocol IndefiniteSymbolEffect: SymbolEffect {}
+/// Shows or hides a symbol.
+public protocol TransitionSymbolEffect: SymbolEffect {}
+/// Replaces one symbol with another (`.contentTransition(.symbolEffect(…))`).
+public protocol ContentTransitionSymbolEffect: SymbolEffect {}
+
+/// How the effects below are built: a list of option names.
+public protocol _SymbolEffectOptions {
+    var _options: [String] { get }
+    init(_options: [String])
+}
+
+extension _SymbolEffectOptions {
+    func adding(_ option: String) -> Self { Self(_options: _options + [option]) }
+    public var byLayer: Self { adding("byLayer") }
+    public var wholeSymbol: Self { adding("wholeSymbol") }
+}
+
+public struct BounceSymbolEffect: DiscreteSymbolEffect, IndefiniteSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+    public var up: Self { adding("up") }
+    public var down: Self { adding("down") }
+}
+
+public struct PulseSymbolEffect: DiscreteSymbolEffect, IndefiniteSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+}
+
+public struct VariableColorSymbolEffect: DiscreteSymbolEffect, IndefiniteSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+    public var iterative: Self { adding("iterative") }
+    public var cumulative: Self { adding("cumulative") }
+    public var reversing: Self { adding("reversing") }
+    public var nonReversing: Self { adding("nonReversing") }
+    public var hideInactiveLayers: Self { adding("hideInactiveLayers") }
+    public var dimInactiveLayers: Self { adding("dimInactiveLayers") }
+}
+
+public struct ScaleSymbolEffect: IndefiniteSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+    public var up: Self { adding("up") }
+    public var down: Self { adding("down") }
+}
+
+public struct AppearSymbolEffect: TransitionSymbolEffect, IndefiniteSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+    public var up: Self { adding("up") }
+    public var down: Self { adding("down") }
+}
+
+public struct DisappearSymbolEffect: TransitionSymbolEffect, IndefiniteSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+    public var up: Self { adding("up") }
+    public var down: Self { adding("down") }
+}
+
+public struct ReplaceSymbolEffect: ContentTransitionSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+    public var downUp: Self { adding("downUp") }
+    public var upUp: Self { adding("upUp") }
+    public var offUp: Self { adding("offUp") }
+    public func magic(fallback: ReplaceSymbolEffect) -> Self { adding("magic") }
+}
+
+public struct AutomaticSymbolEffect: ContentTransitionSymbolEffect, TransitionSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+}
+
+public struct BreatheSymbolEffect: DiscreteSymbolEffect, IndefiniteSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+    public var plain: Self { adding("plain") }
+    public var pulse: Self { adding("pulse") }
+}
+
+public struct RotateSymbolEffect: DiscreteSymbolEffect, IndefiniteSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+    public var clockwise: Self { adding("clockwise") }
+    public var counterClockwise: Self { adding("counterClockwise") }
+}
+
+public struct WiggleSymbolEffect: DiscreteSymbolEffect, IndefiniteSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+    public var up: Self { adding("up") }
+    public var down: Self { adding("down") }
+    public var left: Self { adding("left") }
+    public var right: Self { adding("right") }
+    public var forward: Self { adding("forward") }
+    public var backward: Self { adding("backward") }
+    public var clockwise: Self { adding("clockwise") }
+    public var counterClockwise: Self { adding("counterClockwise") }
+    public static func custom(angle: Angle) -> Self { Self(_options: ["custom"]) }
+    public func custom(angle: Angle) -> Self { adding("custom") }
+}
+
+public struct DrawOnSymbolEffect: TransitionSymbolEffect, IndefiniteSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+    public var individually: Self { adding("individually") }
+}
+
+public struct DrawOffSymbolEffect: TransitionSymbolEffect, IndefiniteSymbolEffect, _SymbolEffectOptions {
+    public let _options: [String]
+    public init(_options: [String]) { self._options = _options }
+    public var individually: Self { adding("individually") }
+}
+
+extension SymbolEffect where Self == BounceSymbolEffect { public static var bounce: BounceSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == PulseSymbolEffect { public static var pulse: PulseSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == VariableColorSymbolEffect { public static var variableColor: VariableColorSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == ScaleSymbolEffect { public static var scale: ScaleSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == AppearSymbolEffect { public static var appear: AppearSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == DisappearSymbolEffect { public static var disappear: DisappearSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == ReplaceSymbolEffect { public static var replace: ReplaceSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == AutomaticSymbolEffect { public static var automatic: AutomaticSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == BreatheSymbolEffect { public static var breathe: BreatheSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == RotateSymbolEffect { public static var rotate: RotateSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == WiggleSymbolEffect { public static var wiggle: WiggleSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == DrawOnSymbolEffect { public static var drawOn: DrawOnSymbolEffect { .init(_options: []) } }
+extension SymbolEffect where Self == DrawOffSymbolEffect { public static var drawOff: DrawOffSymbolEffect { .init(_options: []) } }
+
+/// How an effect plays: repeats and speed, kept.
+public struct SymbolEffectOptions: Hashable, Sendable {
+    public var repeatCount: Int?
+    public var isRepeating: Bool?
+    public var speed: Double = 1
+
+    public struct RepeatBehavior: Hashable, Sendable {
+        let count: Int?
+        public static let continuous = RepeatBehavior(count: nil)
+        public static func periodic(_ count: Int? = nil, delay: Double? = nil) -> RepeatBehavior { RepeatBehavior(count: count) }
+    }
+
+    public static let `default` = SymbolEffectOptions()
+    public static var repeating: SymbolEffectOptions { SymbolEffectOptions(isRepeating: true) }
+    public static var nonRepeating: SymbolEffectOptions { SymbolEffectOptions(isRepeating: false) }
+    public static func `repeat`(_ count: Int) -> SymbolEffectOptions { SymbolEffectOptions(repeatCount: count) }
+    public static func `repeat`(_ behavior: RepeatBehavior) -> SymbolEffectOptions { SymbolEffectOptions(isRepeating: true) }
+    public static func speed(_ speed: Double) -> SymbolEffectOptions { SymbolEffectOptions(speed: speed) }
+
+    public var repeating: SymbolEffectOptions { var copy = self; copy.isRepeating = true; return copy }
+    public var nonRepeating: SymbolEffectOptions { var copy = self; copy.isRepeating = false; return copy }
+    public func `repeat`(_ count: Int) -> SymbolEffectOptions { var copy = self; copy.repeatCount = count; return copy }
+    public func `repeat`(_ behavior: RepeatBehavior) -> SymbolEffectOptions { var copy = self; copy.isRepeating = true; return copy }
+    public func speed(_ speed: Double) -> SymbolEffectOptions { var copy = self; copy.speed = speed; return copy }
+}
+
+// MARK: - Modifiers
+
+nonisolated extension View {
+    /// The view unchanged: the page does not animate symbols.
+    public func symbolEffect<T: IndefiniteSymbolEffect>(_ effect: T, options: SymbolEffectOptions = .default, isActive: Bool = true) -> some View { self }
+
+    /// The view unchanged: the page does not animate symbols.
+    public func symbolEffect<T: DiscreteSymbolEffect, U: Equatable>(_ effect: T, options: SymbolEffectOptions = .default, value: U) -> some View { self }
+
+    public func symbolEffectsRemoved(_ isEnabled: Bool = true) -> some View { self }
+}
+
+extension ContentTransition {
+    /// A symbol replacement; the page swaps the symbol without animating it.
+    public static var symbolEffect: ContentTransition { ContentTransition(name: "symbolEffect") }
+    public static func symbolEffect<T: ContentTransitionSymbolEffect>(_ effect: T, options: SymbolEffectOptions = .default) -> ContentTransition {
+        ContentTransition(name: "symbolEffect")
+    }
+    /// Digits that roll to `value`; the page shows the new text without rolling.
+    public static func numericText(value: Double) -> ContentTransition { ContentTransition(name: "numericText") }
+}
+
+extension Image {
+    /// The symbol; the page draws variable symbols fully filled, whatever the value.
+    public init(systemName: String, variableValue: Double?) {
+        self.init(systemName: systemName)
+    }
+}