@swiftbrowser/swift 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,135 @@
+// CoreGraphics types, provided by the shim because browser builds have no
+// Foundation (see Geometry.swift).
+
+public struct CGPoint: Equatable, Hashable, Sendable {
+    public var x: CGFloat
+    public var y: CGFloat
+    public init(x: CGFloat, y: CGFloat) { self.x = x; self.y = y }
+    public init() { self.init(x: 0, y: 0) }
+    public static let zero = CGPoint()
+}
+
+/// A normalized point in a view's bounds; `(0, 0)` is top leading.
+public struct UnitPoint: Equatable, Hashable, Sendable {
+    public var x: CGFloat
+    public var y: CGFloat
+
+    public init(x: CGFloat, y: CGFloat) {
+        self.x = x
+        self.y = y
+    }
+
+    public init() { self.init(x: 0, y: 0) }
+
+    public static let zero = UnitPoint(x: 0, y: 0)
+    public static let center = UnitPoint(x: 0.5, y: 0.5)
+    public static let leading = UnitPoint(x: 0, y: 0.5)
+    public static let trailing = UnitPoint(x: 1, y: 0.5)
+    public static let top = UnitPoint(x: 0.5, y: 0)
+    public static let bottom = UnitPoint(x: 0.5, y: 1)
+    public static let topLeading = UnitPoint(x: 0, y: 0)
+    public static let topTrailing = UnitPoint(x: 1, y: 0)
+    public static let bottomLeading = UnitPoint(x: 0, y: 1)
+    public static let bottomTrailing = UnitPoint(x: 1, y: 1)
+}
+
+public struct CGSize: Equatable, Hashable, Sendable {
+    public var width: CGFloat
+    public var height: CGFloat
+    public init(width: CGFloat, height: CGFloat) { self.width = width; self.height = height }
+    public init() { self.init(width: 0, height: 0) }
+    public static let zero = CGSize()
+}
+
+public struct CGRect: Equatable, Hashable, Sendable {
+    public var origin: CGPoint
+    public var size: CGSize
+    public init(origin: CGPoint, size: CGSize) { self.origin = origin; self.size = size }
+    public init(x: CGFloat, y: CGFloat, width: CGFloat, height: CGFloat) {
+        self.init(origin: CGPoint(x: x, y: y), size: CGSize(width: width, height: height))
+    }
+    public init() { self.init(origin: .zero, size: .zero) }
+    public static let zero = CGRect()
+    public var minX: CGFloat { origin.x }
+    public var minY: CGFloat { origin.y }
+    public var midX: CGFloat { origin.x + size.width / 2 }
+    public var midY: CGFloat { origin.y + size.height / 2 }
+    public var maxX: CGFloat { origin.x + size.width }
+    public var maxY: CGFloat { origin.y + size.height }
+    public var width: CGFloat { size.width }
+    public var height: CGFloat { size.height }
+    public var isEmpty: Bool { size.width <= 0 || size.height <= 0 }
+
+    /// Shrinks the rectangle by `dx` on each horizontal side and `dy` on each vertical side.
+    public func insetBy(dx: CGFloat, dy: CGFloat) -> CGRect {
+        CGRect(x: origin.x + dx, y: origin.y + dy, width: size.width - 2 * dx, height: size.height - 2 * dy)
+    }
+
+    public func offsetBy(dx: CGFloat, dy: CGFloat) -> CGRect {
+        CGRect(origin: CGPoint(x: origin.x + dx, y: origin.y + dy), size: size)
+    }
+
+    public func contains(_ point: CGPoint) -> Bool {
+        point.x >= minX && point.x < maxX && point.y >= minY && point.y < maxY
+    }
+}
+
+/// The size the renderer laid a `GeometryReader` out at.
+public struct GeometryProxy {
+    public let size: CGSize
+
+    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 {
+    case global, local
+    case named(AnyHashable)
+
+    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 {}
+
+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: _TraitBearing {
+    func _content(for size: CGSize) -> any View
+}
+
+/// A container that reports its size to its content. The size arrives from
+/// the renderer after layout, so the content renders once at zero size and
+/// again with the real size.
+public struct GeometryReader<Content: View> {
+    let content: (GeometryProxy) -> Content
+
+    public init(@ViewBuilder content: @escaping (GeometryProxy) -> Content) {
+        self.content = content
+    }
+}
+extension GeometryReader: _PrimitiveView {}
+extension GeometryReader: _HostView {
+    var _kind: String { "geometry" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object([:]) }
+    // The runtime produces the content from the last reported size.
+}
+extension GeometryReader: _GeometryReading {
+    func _content(for size: CGSize) -> any View { content(GeometryProxy(size: size)) }
+}

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