@swiftbrowser/swift 0.1.0 → 0.2.0

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