@swiftbrowser/swift 0.1.0 → 0.3.0

package/Sources/SwiftUI/API/Gauge.swift

@@ -35,6 +35,12 @@ public struct AccessoryCircularCapacityGaugeStyle: GaugeStyle, _NamedGaugeStyle,
     var _name: String { "accessoryCircularCapacity" }
 }
 
+/// A determinate `ProgressView`'s gauge: the label above the bar in the
+/// body font, the current value label under it (the page lays it out).
+struct _ProgressGaugeStyle: GaugeStyle, _NamedGaugeStyle, Sendable {
+    var _name: String { "progress" }
+}
+
 extension GaugeStyle where Self == DefaultGaugeStyle {
     public static var automatic: DefaultGaugeStyle { DefaultGaugeStyle() }
 }
@@ -70,7 +76,7 @@ extension EnvironmentValues {
     }
 }
 
-extension View {
+nonisolated extension View {
     public func gaugeStyle<S: GaugeStyle>(_ style: S) -> some View {
         environment(\.gaugeStyle, (style as? any _NamedGaugeStyle)?._name ?? "automatic")
     }
@@ -163,10 +169,11 @@ extension Gauge: _HostView {
 
 // MARK: - ProgressView
 
-/// Progress toward a total. A determinate progress view draws as a
-/// `linearCapacity` gauge with its label; an indeterminate one (no value)
-/// has no spinner in the protocol and shows its label, or an hourglass
-/// symbol when it has none.
+/// Progress toward a total. A determinate progress view draws as a gauge
+/// (style `progress`: its label above the bar, its current value label under
+/// it); an indeterminate one (no value) is
+/// the spinner symbol (`progress.indicator`, which the page animates) with its
+/// label under it, as iOS draws them.
 public struct ProgressView<Label: View, CurrentValueLabel: View>: View {
     /// Progress in 0…1, nil when indeterminate.
     let fraction: Double?
@@ -178,16 +185,24 @@ public struct ProgressView<Label: View, CurrentValueLabel: View>: View {
             Gauge(value: fraction, in: 0...1) {
                 if let label { label }
             } currentValueLabel: {
-                if let currentValueLabel { currentValueLabel }
+                if let currentValueLabel { currentValueLabel.foregroundStyle(.secondary) }
             }
-            .gaugeStyle(.linearCapacity)
+            .gaugeStyle(_ProgressGaugeStyle())
         } else if let label {
-            label.foregroundStyle(.secondary)
+            VStack(spacing: 8) {
+                activityIndicator
+                label.foregroundStyle(.secondary)
+            }
         } else {
-            Image(systemName: "hourglass").foregroundStyle(.secondary)
+            activityIndicator
         }
     }
 
+    /// iOS's activity indicator is 20pt across whatever the font around it.
+    private var activityIndicator: some View {
+        Image(systemName: "progress.indicator").font(.system(size: 20)).foregroundStyle(.secondary)
+    }
+
     static func fraction<V: BinaryFloatingPoint>(_ value: V?, total: V) -> Double? {
         guard let value, total > 0 else { return nil }
         return max(0, min(1, Double(value) / Double(total)))
@@ -209,6 +224,7 @@ extension ProgressView where Label == EmptyView, CurrentValueLabel == EmptyView
 }
 
 extension ProgressView where Label == Text, CurrentValueLabel == EmptyView {
+    @_disfavoredOverload
     public init<S: StringProtocol>(_ title: S) {
         fraction = nil
         label = Text(title)
@@ -272,7 +288,7 @@ extension ProgressViewStyle where Self == CircularProgressViewStyle {
     public static var circular: CircularProgressViewStyle { CircularProgressViewStyle() }
 }
 
-extension View {
+nonisolated extension View {
     public func progressViewStyle<S: ProgressViewStyle>(_ style: S) -> some View { self }
 }
 

package/Sources/SwiftUI/API/GeometryEffects.swift

@@ -0,0 +1,232 @@
+/// `Animatable`, `GeometryEffect`, `ProjectionTransform` and `AnimatableModifier`.
+///
+/// SwiftUI animates a type's `animatableData` by interpolating it frame by
+/// frame and evaluating the view (or effect) at each step. The browser
+/// animates the styles a pass sends (Phase 3), not Swift values, so here a
+/// modifier or effect is evaluated at its final `animatableData` only: the
+/// page animates the change between the transform the old value gave and the
+/// one the new value gives. An effect whose start and end look the same (a
+/// shake that returns to rest after each whole unit) does not move.
+///
+/// A `GeometryEffect`'s `effectValue(size:)` is asked with a zero size: the
+/// Swift side does not know the view's laid-out size (as for `.visualEffect`'s
+/// proxy). Its transform is drawn as an offset, a rotation and a scale about
+/// the view's top-leading corner, the origin SwiftUI's projection uses; a
+/// shear and the perspective row are not drawn.
+
+// MARK: - Vector arithmetic
+
+/// A value SwiftUI can interpolate: it adds, subtracts and scales.
+public protocol VectorArithmetic: AdditiveArithmetic {
+    mutating func scale(by rhs: Double)
+    var magnitudeSquared: Double { get }
+}
+
+extension VectorArithmetic {
+    /// The value scaled by `rhs`.
+    public func scaled(by rhs: Double) -> Self {
+        var copy = self
+        copy.scale(by: rhs)
+        return copy
+    }
+
+    /// The value `amount` of the way from `self` to `other`.
+    public func interpolated(towards other: Self, amount: Double) -> Self {
+        self + (other - self).scaled(by: amount)
+    }
+}
+
+extension Double: VectorArithmetic {
+    public mutating func scale(by rhs: Double) { self *= rhs }
+    public var magnitudeSquared: Double { self * self }
+}
+
+extension Float: VectorArithmetic {
+    public mutating func scale(by rhs: Double) { self *= Float(rhs) }
+    public var magnitudeSquared: Double { Double(self * self) }
+}
+
+/// No animatable data: the default of an `Animatable` type.
+public struct EmptyAnimatableData: VectorArithmetic, Hashable, Sendable {
+    public init() {}
+    public static var zero: EmptyAnimatableData { EmptyAnimatableData() }
+    public static func + (lhs: Self, rhs: Self) -> Self { lhs }
+    public static func - (lhs: Self, rhs: Self) -> Self { lhs }
+    public mutating func scale(by rhs: Double) {}
+    public var magnitudeSquared: Double { 0 }
+}
+
+/// Two animatable values interpolated together.
+public struct AnimatablePair<First: VectorArithmetic, Second: VectorArithmetic>: VectorArithmetic {
+    public var first: First
+    public var second: Second
+
+    public init(_ first: First, _ second: Second) {
+        self.first = first
+        self.second = second
+    }
+
+    public static var zero: Self { Self(.zero, .zero) }
+    public static func + (lhs: Self, rhs: Self) -> Self { Self(lhs.first + rhs.first, lhs.second + rhs.second) }
+    public static func - (lhs: Self, rhs: Self) -> Self { Self(lhs.first - rhs.first, lhs.second - rhs.second) }
+    public mutating func scale(by rhs: Double) {
+        first.scale(by: rhs)
+        second.scale(by: rhs)
+    }
+    public var magnitudeSquared: Double { first.magnitudeSquared + second.magnitudeSquared }
+}
+
+extension AnimatablePair: Equatable {}
+extension AnimatablePair: Sendable where First: Sendable, Second: Sendable {}
+
+// MARK: - Animatable
+
+/// A type whose `animatableData` SwiftUI interpolates. In the browser a
+/// modifier or effect is evaluated at the final value (see the file comment);
+/// a custom `Shape` sends its path along the way (Shape.swift).
+public protocol Animatable {
+    associatedtype AnimatableData: VectorArithmetic = EmptyAnimatableData
+    var animatableData: AnimatableData { get set }
+}
+
+extension Animatable where AnimatableData == EmptyAnimatableData {
+    public var animatableData: EmptyAnimatableData {
+        get { EmptyAnimatableData() }
+        set {}
+    }
+}
+
+extension CGPoint: Animatable {
+    public var animatableData: AnimatablePair<CGFloat, CGFloat> {
+        get { AnimatablePair(x, y) }
+        set { (x, y) = (newValue.first, newValue.second) }
+    }
+}
+
+extension CGSize: Animatable {
+    public var animatableData: AnimatablePair<CGFloat, CGFloat> {
+        get { AnimatablePair(width, height) }
+        set { (width, height) = (newValue.first, newValue.second) }
+    }
+}
+
+extension CGRect: Animatable {
+    public var animatableData: AnimatablePair<CGPoint.AnimatableData, CGSize.AnimatableData> {
+        get { AnimatablePair(origin.animatableData, size.animatableData) }
+        set { (origin.animatableData, size.animatableData) = (newValue.first, newValue.second) }
+    }
+}
+
+/// A modifier whose `animatableData` is interpolated (deprecated in SwiftUI
+/// for `Animatable` & `ViewModifier`). Its body runs with the final value.
+public protocol AnimatableModifier: Animatable, ViewModifier {}
+
+// MARK: - Projection transforms
+
+/// A 3×3 projective transform, applied to row vectors as in Core Animation:
+/// (x, y, 1) × m.
+public struct ProjectionTransform: Equatable, Sendable {
+    public var m11: CGFloat = 1, m12: CGFloat = 0, m13: CGFloat = 0
+    public var m21: CGFloat = 0, m22: CGFloat = 1, m23: CGFloat = 0
+    public var m31: CGFloat = 0, m32: CGFloat = 0, m33: CGFloat = 1
+
+    /// The identity.
+    public init() {}
+
+    public var isIdentity: Bool { self == ProjectionTransform() }
+    /// Whether the perspective column is (0, 0, 1).
+    public var isAffine: Bool { m13 == 0 && m23 == 0 && m33 == 1 }
+
+    /// The transform of `self` followed by `rhs`.
+    public func concatenating(_ rhs: ProjectionTransform) -> ProjectionTransform {
+        var r = ProjectionTransform()
+        r.m11 = m11 * rhs.m11 + m12 * rhs.m21 + m13 * rhs.m31
+        r.m12 = m11 * rhs.m12 + m12 * rhs.m22 + m13 * rhs.m32
+        r.m13 = m11 * rhs.m13 + m12 * rhs.m23 + m13 * rhs.m33
+        r.m21 = m21 * rhs.m11 + m22 * rhs.m21 + m23 * rhs.m31
+        r.m22 = m21 * rhs.m12 + m22 * rhs.m22 + m23 * rhs.m32
+        r.m23 = m21 * rhs.m13 + m22 * rhs.m23 + m23 * rhs.m33
+        r.m31 = m31 * rhs.m11 + m32 * rhs.m21 + m33 * rhs.m31
+        r.m32 = m31 * rhs.m12 + m32 * rhs.m22 + m33 * rhs.m32
+        r.m33 = m31 * rhs.m13 + m32 * rhs.m23 + m33 * rhs.m33
+        return r
+    }
+
+    /// The offset, rotation (radians) and scale whose composition about the
+    /// origin, scale first, gives the affine part; nil for a shear.
+    var _decomposed: (tx: CGFloat, ty: CGFloat, angle: CGFloat, sx: CGFloat, sy: CGFloat)? {
+        let sx = (m11 * m11 + m12 * m12).squareRoot()
+        guard sx > 0 else { return nil }
+        let angle = _atan2(m12, m11)
+        let sy = (m11 * m22 - m12 * m21) / sx
+        // Without a shear the second row is the first turned a quarter, scaled by sy / sx.
+        let expected21 = -m12 / sx * sy, expected22 = m11 / sx * sy
+        guard abs(m21 - expected21) < 1e-9, abs(m22 - expected22) < 1e-9 else { return nil }
+        return (m31, m32, angle, sx, sy)
+    }
+}
+
+/// atan2 without Foundation (the shim does not import it).
+func _atan2(_ y: CGFloat, _ x: CGFloat) -> CGFloat {
+    if x == 0 { return y > 0 ? .pi / 2 : (y < 0 ? -.pi / 2 : 0) }
+    var angle = _atan(y / x)
+    if x < 0 { angle += y >= 0 ? .pi : -.pi }
+    return angle
+}
+
+/// atan by argument reduction (|z| ≤ tan(π/12)) and its series.
+func _atan(_ z: CGFloat) -> CGFloat {
+    if z < 0 { return -_atan(-z) }
+    if z > 1 { return .pi / 2 - _atan(1 / z) }
+    let tan15 = 0.2679491924311227
+    if z > tan15 {
+        // atan(z) = π/6 + atan((z√3 − 1) / (z + √3))
+        let root3 = 1.7320508075688772
+        return .pi / 6 + _atan((z * root3 - 1) / (z + root3))
+    }
+    var term = z, sum = z
+    let z2 = z * z
+    for n in 1..<12 {
+        term *= -z2
+        sum += term / CGFloat(2 * n + 1)
+    }
+    return sum
+}
+
+nonisolated extension View {
+    /// Draws the view through `transform` (its affine part: offset, rotation
+    /// and scale about the top-leading corner; a shear draws untransformed).
+    public func projectionEffect(_ transform: ProjectionTransform) -> some View {
+        _styled { style in
+            guard !transform.isIdentity, let parts = transform._decomposed else { return }
+            // Differences below a billionth of a point (sin(4π)) are rounding, not movement.
+            let negligible = 1e-9
+            if abs(parts.tx) > negligible || abs(parts.ty) > negligible {
+                style.extras["offset"] = .object(["x": .number(parts.tx), "y": .number(parts.ty)])
+            }
+            if abs(parts.angle) > negligible {
+                style.extras["rotation"] = .number(parts.angle * 180 / .pi)
+                style.extras["rotationAnchor"] = UnitPoint.topLeading._json
+            }
+            if abs(parts.sx - 1) > negligible || abs(parts.sy - 1) > negligible {
+                style.extras["scale"] = .object(["x": .number(parts.sx), "y": .number(parts.sy)])
+                style.extras["scaleAnchor"] = UnitPoint.topLeading._json
+            }
+        }
+    }
+}
+
+// MARK: - Geometry effects
+
+/// A modifier that moves its view with a projection transform. Its body
+/// draws `effectValue(size:)` (asked with a zero size, at the final
+/// `animatableData`; see the file comment).
+public protocol GeometryEffect: Animatable, ViewModifier {
+    func effectValue(size: CGSize) -> ProjectionTransform
+}
+
+extension GeometryEffect {
+    public func body(content: Content) -> some View {
+        content.projectionEffect(effectValue(size: .zero))
+    }
+}

package/Sources/SwiftUI/API/GeometryReader.swift

@@ -81,6 +81,13 @@ public struct GeometryProxy {
     public func frame(in coordinateSpace: CoordinateSpace) -> CGRect {
         CGRect(origin: .zero, size: size)
     }
+
+    /// The bounds of the space named `coordinateSpace` around this view (iOS
+    /// 17), as the view sees them. The browser reports a view's own size
+    /// only, so there are none (nil, as outside such a space).
+    public func bounds(of coordinateSpace: CoordinateSpace) -> CGRect? {
+        coordinateSpace == .local ? CGRect(origin: .zero, size: size) : nil
+    }
 }
 
 public enum CoordinateSpace: Hashable {
@@ -89,17 +96,21 @@ public enum CoordinateSpace: Hashable {
 
     public var isGlobal: Bool { self == .global }
     public var isLocal: Bool { self == .local }
+
+    /// The nearest scroll view's space (iOS 17).
+    public static var scrollView: CoordinateSpace { .named("_SwiftBrowser.scrollView") }
+    public static func scrollView(axis: Axis) -> CoordinateSpace { scrollView }
 }
 /// `AnyHashable` is not `Sendable`; names are value types in practice.
 extension CoordinateSpace: @unchecked Sendable {}
 
-extension View {
+nonisolated extension View {
     /// Names a coordinate space; accepted for source compatibility (geometry
     /// is always reported in the view's own box).
     public func coordinateSpace<T: Hashable>(name: T) -> some View { self }
 }
 
-protocol _GeometryReading {
+protocol _GeometryReading: _TraitBearing {
     func _content(for size: CGSize) -> any View
 }
 

package/Sources/SwiftUI/API/GestureState.swift

@@ -0,0 +1,65 @@
+// `@GestureState` and `Gesture.updating(_:body:)`: state that a gesture
+// sets while it runs and that returns to its initial value when it ends. It
+// is stored like `@State` (so it survives re-renders and a change re-renders
+// the view); `updating` sets it from the gesture's changed events and resets
+// it on the ended event. The transaction the body may set is ignored, and a
+// cancelled gesture resets like an ended one.
+
+@propertyWrapper
+public struct GestureState<Value>: DynamicProperty {
+    let state: State<Value>
+    let initial: Value
+
+    public init(wrappedValue: Value) {
+        state = State(wrappedValue: wrappedValue)
+        initial = wrappedValue
+    }
+
+    public init(initialValue: Value) {
+        self.init(wrappedValue: initialValue)
+    }
+
+    public init(wrappedValue: Value, resetTransaction: Transaction) {
+        self.init(wrappedValue: wrappedValue)
+    }
+
+    public init(wrappedValue: Value, reset: @escaping (Value, inout Transaction) -> Void) {
+        self.init(wrappedValue: wrappedValue)
+    }
+
+    public var wrappedValue: Value { state.wrappedValue }
+
+    public var projectedValue: GestureState<Value> { self }
+
+    /// Sets the stored value (`updating`'s body result).
+    func _set(_ value: Value) { state.wrappedValue = value }
+
+    func _reset() { state.wrappedValue = initial }
+}
+
+extension GestureState where Value: ExpressibleByNilLiteral {
+    public init(resetTransaction: Transaction = Transaction()) {
+        self.init(wrappedValue: nil)
+    }
+}
+
+extension GestureState: _StateProperty {
+    var _box: any _AnyStateBox { state.box }
+}
+
+extension Gesture {
+    /// Runs `body` with each changed value to update `state`, which returns
+    /// to its initial value when the gesture ends.
+    @MainActor
+    public func updating<State>(_ state: GestureState<State>,
+                                body: @escaping (Value, inout State, inout Transaction) -> Void) -> _ModifiedGesture<Self> {
+        let changed: @MainActor (Value) -> Void = { value in
+            var current = state.wrappedValue
+            var transaction = Transaction()
+            body(value, &current, &transaction)
+            state._set(current)
+        }
+        let ended: @MainActor (Value) -> Void = { _ in state._reset() }
+        return _ModifiedGesture(_config: Self._adding(to: _config, changed: changed, ended: ended))
+    }
+}

package/Sources/SwiftUI/API/Gestures.swift

@@ -304,7 +304,7 @@ extension _GestureView: _GroupView {
     }
 }
 
-extension View {
+nonisolated extension View {
     public func gesture<G: Gesture>(_ gesture: G, including mask: GestureMask = .all) -> some View {
         _GestureView(content: self, config: gesture._config)
     }

package/Sources/SwiftUI/API/Glass.swift

@@ -0,0 +1,127 @@
+// iOS 26 Liquid Glass. The page has no refracting glass, so a glass effect
+// is approximated by what it looks like at rest: a translucent material
+// (`regularMaterial`, `ultraThinMaterial` for `.clear`) filling the given
+// shape behind the view, under the glass's tint when it has one. The
+// `interactive` response to touches (the glass swelling under a finger),
+// the merging of nearby glass shapes in a `GlassEffectContainer` and the
+// morphing between `glassEffectID`s are not drawn: containers lay their
+// content out as given and ids are accepted. The glass button styles draw
+// as the bordered ones (`.glass` as `.bordered`, `.glassProminent` as
+// `.borderedProminent`).
+
+/// The material of a glass effect.
+public struct Glass: Equatable, Sendable {
+    enum Variant: Equatable, Sendable {
+        case regular, clear, identity
+    }
+
+    let variant: Variant
+    let tintColor: Color?
+    let isInteractive: Bool
+
+    /// Glass over ordinary content.
+    public static let regular = Glass(variant: .regular, tintColor: nil, isInteractive: false)
+    /// More transparent glass, for media-rich backgrounds.
+    public static let clear = Glass(variant: .clear, tintColor: nil, isInteractive: false)
+    /// No glass at all: the view draws as if the effect were not applied.
+    public static let identity = Glass(variant: .identity, tintColor: nil, isInteractive: false)
+
+    /// Tinted glass: the color is laid over the material.
+    public func tint(_ color: Color?) -> Glass {
+        Glass(variant: variant, tintColor: color, isInteractive: isInteractive)
+    }
+
+    /// Accepted; the page's glass does not react to touches.
+    public func interactive(_ isEnabled: Bool = true) -> Glass {
+        Glass(variant: variant, tintColor: tintColor, isInteractive: isEnabled)
+    }
+
+    var material: Material { variant == .clear ? .ultraThinMaterial : .regularMaterial }
+}
+
+/// The glass behind a view: the material, then the tint, in the shape.
+struct _GlassEffectView<Content: View, S: Shape> {
+    let content: Content
+    let glass: Glass
+    let shape: S
+}
+extension _GlassEffectView: View {
+    var body: some View {
+        if glass.variant == .identity {
+            content
+        } else if let tint = glass.tintColor {
+            content.background(tint, in: shape).background(glass.material, in: shape)
+        } else {
+            content.background(glass.material, in: shape)
+        }
+    }
+}
+
+nonisolated extension View {
+    /// Draws Liquid Glass behind the view in `shape` (a capsule by default);
+    /// see the top of this file for the approximation.
+    public func glassEffect<S: Shape>(_ glass: Glass = .regular, in shape: S = Capsule()) -> some View {
+        _GlassEffectView(content: self, glass: glass, shape: shape)
+    }
+
+    public func glassEffect(_ glass: Glass = .regular, isEnabled: Bool) -> some View {
+        _GlassEffectView(content: self, glass: isEnabled ? glass : .identity, shape: Capsule())
+    }
+
+    /// Accepted: glass shapes keep their own outlines (no morphing between ids).
+    public func glassEffectID<ID: Hashable & Sendable>(_ id: ID?, in namespace: Namespace.ID) -> some View { self }
+
+    /// Accepted: glass shapes keep their own outlines (no union is drawn).
+    public func glassEffectUnion<ID: Hashable & Sendable>(id: ID?, namespace: Namespace.ID) -> some View { self }
+
+    /// Accepted: glass appears and disappears with the view's own transition.
+    public func glassEffectTransition(_ transition: GlassEffectTransition) -> some View { self }
+}
+
+/// How glass appears and disappears; accepted (see `glassEffectTransition`).
+public struct GlassEffectTransition: Equatable, Sendable {
+    let name: String
+    public static let matchedGeometry = GlassEffectTransition(name: "matchedGeometry")
+    public static func matchedGeometry(properties: MatchedGeometryProperties = .frame,
+                                       anchor: UnitPoint = .center) -> GlassEffectTransition { .matchedGeometry }
+    public static let materialize = GlassEffectTransition(name: "materialize")
+    public static let identity = GlassEffectTransition(name: "identity")
+}
+
+/// Groups glass shapes so they can merge on iOS; here it lays its content
+/// out as given (a group: the content's views are its parent's children).
+public struct GlassEffectContainer<Content: View> {
+    let content: Content
+
+    public init(spacing: CGFloat? = nil, @ViewBuilder content: () -> Content) {
+        self.content = content()
+    }
+}
+extension GlassEffectContainer: _PrimitiveView {}
+extension GlassEffectContainer: _GroupView {
+    var _children: [any View] { [content] }
+}
+
+// MARK: - Glass button styles
+
+/// `.buttonStyle(.glass)`: drawn as `.bordered` (a gray capsule).
+public struct GlassButtonStyle: PrimitiveButtonStyle {
+    public init() {}
+    public init(_ glass: Glass) {}
+    public var _name: String { "bordered" }
+}
+
+/// `.buttonStyle(.glassProminent)`: drawn as `.borderedProminent` (a tinted capsule).
+public struct GlassProminentButtonStyle: PrimitiveButtonStyle {
+    public init() {}
+    public var _name: String { "borderedProminent" }
+}
+
+extension PrimitiveButtonStyle where Self == GlassButtonStyle {
+    public static var glass: GlassButtonStyle { GlassButtonStyle() }
+    public static func glass(_ glass: Glass) -> GlassButtonStyle { GlassButtonStyle(glass) }
+}
+
+extension PrimitiveButtonStyle where Self == GlassProminentButtonStyle {
+    public static var glassProminent: GlassProminentButtonStyle { GlassProminentButtonStyle() }
+}

package/Sources/SwiftUI/API/Grid.swift

@@ -64,7 +64,7 @@ extension _GridCellHintView: _HostView {
     var _content: [any View] { [content] }
 }
 
-extension View {
+nonisolated extension View {
     /// Makes the cell span `count` columns of its `GridRow`.
     public func gridCellColumns(_ count: Int) -> some View {
         _GridCellHintView(content: self, style: ["gridCellColumns": .number(Double(count))])