@swiftbrowser/swift 0.0.0-stage → 0.1.0

package/Sources/SwiftUI/API/Animation.swift

@@ -0,0 +1,253 @@
+/// How a change is animated. Encoded for the renderer as documented in
+/// docs/ops-protocol.md (Phase 3).
+public struct Animation: Equatable, Sendable {
+    enum Kind: String, Sendable {
+        case `default`, linear, easeIn, easeOut, easeInOut, spring
+    }
+
+    var kind: Kind
+    var duration: Double
+    var bounce: Double
+    var delayBy: Double
+    /// `.repeatCount` / `.repeatForever`: `count` nil with `forever` false means once.
+    var repeatCount: Int?
+    var repeatForever = false
+    var autoreverses = true
+
+    init(kind: Kind, duration: Double = 0.35, bounce: Double = 0, delay: Double = 0) {
+        self.kind = kind
+        self.duration = duration
+        self.bounce = bounce
+        self.delayBy = delay
+    }
+
+    public static let `default` = Animation(kind: .default)
+    public static let linear = Animation(kind: .linear)
+    public static let easeIn = Animation(kind: .easeIn)
+    public static let easeOut = Animation(kind: .easeOut)
+    public static let easeInOut = Animation(kind: .easeInOut)
+    public static let spring = Animation(kind: .spring, duration: 0.5, bounce: 0)
+    public static let bouncy = Animation(kind: .spring, duration: 0.5, bounce: 0.3)
+    public static let smooth = Animation(kind: .spring, duration: 0.5, bounce: 0)
+    public static let snappy = Animation(kind: .spring, duration: 0.5, bounce: 0.15)
+
+    public static func linear(duration: Double) -> Animation { Animation(kind: .linear, duration: duration) }
+    public static func easeIn(duration: Double) -> Animation { Animation(kind: .easeIn, duration: duration) }
+    public static func easeOut(duration: Double) -> Animation { Animation(kind: .easeOut, duration: duration) }
+    public static func easeInOut(duration: Double) -> Animation { Animation(kind: .easeInOut, duration: duration) }
+    public static func spring(duration: Double = 0.5, bounce: Double = 0) -> Animation {
+        Animation(kind: .spring, duration: duration, bounce: bounce)
+    }
+    /// The pre-iOS 17 spring: `response` is the duration, the damping fraction
+    /// maps onto bounce (`1` is a smooth spring, lower values overshoot).
+    public static func spring(response: Double = 0.5, dampingFraction: Double = 0.825,
+                              blendDuration: Double = 0) -> Animation {
+        Animation(kind: .spring, duration: response, bounce: max(0, min(1, 1 - dampingFraction)))
+    }
+    public static func interactiveSpring(response: Double = 0.15, dampingFraction: Double = 0.86,
+                                         blendDuration: Double = 0.25) -> Animation {
+        spring(response: response, dampingFraction: dampingFraction, blendDuration: blendDuration)
+    }
+    public static func bouncy(duration: Double = 0.5, extraBounce: Double = 0) -> Animation {
+        Animation(kind: .spring, duration: duration, bounce: 0.3 + extraBounce)
+    }
+    public static func smooth(duration: Double = 0.5, extraBounce: Double = 0) -> Animation {
+        Animation(kind: .spring, duration: duration, bounce: extraBounce)
+    }
+    public static func snappy(duration: Double = 0.5, extraBounce: Double = 0) -> Animation {
+        Animation(kind: .spring, duration: duration, bounce: 0.15 + extraBounce)
+    }
+
+    public func delay(_ delay: Double) -> Animation {
+        var copy = self
+        copy.delayBy = delay
+        return copy
+    }
+
+    public func speed(_ speed: Double) -> Animation {
+        var copy = self
+        copy.duration = speed > 0 ? duration / speed : duration
+        return copy
+    }
+
+    /// Repeats the animation `repeatCount` times, reversing on alternate runs
+    /// when `autoreverses`.
+    public func repeatCount(_ repeatCount: Int, autoreverses: Bool = true) -> Animation {
+        var copy = self
+        copy.repeatCount = repeatCount
+        copy.repeatForever = false
+        copy.autoreverses = autoreverses
+        return copy
+    }
+
+    public func repeatForever(autoreverses: Bool = true) -> Animation {
+        var copy = self
+        copy.repeatCount = nil
+        copy.repeatForever = true
+        copy.autoreverses = autoreverses
+        return copy
+    }
+
+    var _json: _JSON {
+        var object: [String: _JSON] = ["type": .string(kind.rawValue), "duration": .number(duration)]
+        if bounce != 0 { object["bounce"] = .number(bounce) }
+        if delayBy != 0 { object["delay"] = .number(delayBy) }
+        if repeatForever || repeatCount != nil {
+            object["repeat"] = .object([
+                "count": repeatForever ? .string("forever") : .number(Double(repeatCount ?? 1)),
+                "autoreverses": .bool(autoreverses),
+            ])
+        }
+        return .object(object)
+    }
+}
+
+extension Binding {
+    /// A binding whose writes animate the view changes they cause.
+    public func animation(_ animation: Animation? = .default) -> Binding<Value> {
+        let setter = self.setter
+        return Binding(get: getter) { value in
+            // Bindings are written from the main actor (event handlers, bodies).
+            MainActor.assumeIsolated { _Runtime.shared.beginTransaction(animation) }
+            setter(value)
+        }
+    }
+}
+
+/// Runs `body` and animates the view changes it causes.
+@MainActor
+public func withAnimation<Result>(_ animation: Animation? = .default,
+                                  _ body: () throws -> Result) rethrows -> Result {
+    _Runtime.shared.beginTransaction(animation)
+    return try body()
+}
+
+// MARK: - Transitions
+
+/// How a view appears and disappears when inserted or removed with animation.
+public struct AnyTransition: Sendable {
+    struct Part: Sendable {
+        var kind: String
+        var edge: Edge?
+        var scale: Double?
+        var offset: CGSize?
+        /// `asymmetric`: the transitions for insertion and removal.
+        var insertion: [Part]?
+        var removal: [Part]?
+
+        var _json: _JSON {
+            var object: [String: _JSON] = ["kind": .string(kind)]
+            if let edge { object["edge"] = .string(edge.name) }
+            if let scale { object["scale"] = .number(scale) }
+            if let offset {
+                object["x"] = .number(offset.width)
+                object["y"] = .number(offset.height)
+            }
+            if let insertion { object["insertion"] = AnyTransition(parts: insertion)._json }
+            if let removal { object["removal"] = AnyTransition(parts: removal)._json }
+            return .object(object)
+        }
+    }
+
+    public static func asymmetric(insertion: AnyTransition, removal: AnyTransition) -> AnyTransition {
+        AnyTransition(parts: [Part(kind: "asymmetric", insertion: insertion.parts, removal: removal.parts)])
+    }
+
+    var parts: [Part]
+
+    public static let identity = AnyTransition(parts: [Part(kind: "identity")])
+    public static let opacity = AnyTransition(parts: [Part(kind: "opacity")])
+    public static let slide = AnyTransition(parts: [Part(kind: "slide")])
+    public static let scale = AnyTransition(parts: [Part(kind: "scale", scale: 0.5)])
+
+    public static func scale(scale: Double) -> AnyTransition {
+        AnyTransition(parts: [Part(kind: "scale", scale: scale)])
+    }
+
+    /// The anchor is accepted for source compatibility; scaling is about the center.
+    public static func scale(scale: Double, anchor: UnitPoint) -> AnyTransition {
+        AnyTransition(parts: [Part(kind: "scale", scale: scale)])
+    }
+
+    /// Slides in from / out to the given offset (points).
+    public static func offset(x: CGFloat = 0, y: CGFloat = 0) -> AnyTransition {
+        AnyTransition(parts: [Part(kind: "offset", offset: CGSize(width: x, height: y))])
+    }
+
+    public static func offset(_ offset: CGSize) -> AnyTransition {
+        AnyTransition(parts: [Part(kind: "offset", offset: offset)])
+    }
+
+    public static func move(edge: Edge) -> AnyTransition {
+        AnyTransition(parts: [Part(kind: "move", edge: edge)])
+    }
+
+    public func combined(with other: AnyTransition) -> AnyTransition {
+        AnyTransition(parts: parts + other.parts)
+    }
+
+    /// A transition between two states of a `ViewModifier`. The shim cannot
+    /// diff arbitrary modifiers, so it is accepted and rendered as `opacity`
+    /// (docs/ops-protocol.md, Phase 8).
+    public static func modifier<E: ViewModifier>(active: E, identity: E) -> AnyTransition {
+        .opacity
+    }
+
+    var _json: _JSON {
+        parts.count == 1 ? parts[0]._json : .array(parts.map(\._json))
+    }
+}
+
+extension Edge {
+    var name: String {
+        switch self {
+        case .top: "top"
+        case .leading: "leading"
+        case .bottom: "bottom"
+        case .trailing: "trailing"
+        }
+    }
+}
+
+// MARK: - Modifiers
+
+/// Views whose subtree animates when `value` changes.
+protocol _AnimatedView {
+    var _animation: Animation? { get }
+    /// Whether the tracked value differs from a previously stored one.
+    func _changed(since previous: Any?) -> Bool
+    var _value: Any { get }
+    var _content: [any View] { get }
+}
+
+struct _AnimationView<Content: View, Value: Equatable> {
+    let content: Content
+    let animation: Animation?
+    let value: Value
+}
+extension _AnimationView: _PrimitiveView {}
+extension _AnimationView: _HostView {
+    var _kind: String { "styled" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object(["style": .object([:])]) }
+    var _content: [any View] { [content] }
+}
+extension _AnimationView: _AnimatedView {
+    var _animation: Animation? { animation }
+    var _value: Any { value }
+    func _changed(since previous: Any?) -> Bool {
+        guard let previous = previous as? Value else { return true }
+        return previous != value
+    }
+}
+
+extension View {
+    /// Animates changes to this view whenever `value` changes.
+    public func animation<V: Equatable>(_ animation: Animation?, value: V) -> some View {
+        _AnimationView(content: self, animation: animation, value: value)
+    }
+
+    /// The transition to use when this view is inserted or removed with animation.
+    public func transition(_ transition: AnyTransition) -> some View {
+        _styled { $0.transition = transition }
+    }
+}

package/Sources/SwiftUI/API/App.swift

@@ -0,0 +1,57 @@
+/// A part of an app's user interface with a life cycle managed by the system.
+@MainActor @preconcurrency
+public protocol Scene {
+    associatedtype Body: Scene
+    @SceneBuilder var body: Self.Body { get }
+}
+
+extension Never: Scene {}
+
+/// Scenes the runtime can mount directly.
+protocol _RootScene {
+    var _rootView: any View { get }
+}
+
+@resultBuilder
+public enum SceneBuilder {
+    public static func buildBlock<Content: Scene>(_ content: Content) -> Content { content }
+}
+
+/// A scene that presents a view hierarchy in a window (on the web, the screen).
+public struct WindowGroup<Content: View> {
+    let content: Content
+
+    public init(@ViewBuilder content: () -> Content) {
+        self.content = content()
+    }
+
+    public init(_ title: String, @ViewBuilder content: () -> Content) {
+        self.content = content()
+    }
+}
+
+extension WindowGroup: Scene {
+    public typealias Body = Never
+    public var body: Never { fatalError("WindowGroup is a primitive scene") }
+}
+
+extension WindowGroup: _RootScene {
+    var _rootView: any View { content }
+}
+
+/// The structure and behavior of an app. Mark the conforming type `@main`.
+@MainActor @preconcurrency
+public protocol App {
+    associatedtype Body: Scene
+    @SceneBuilder var body: Self.Body { get }
+    init()
+}
+
+extension App {
+    /// Entry point used by `@main`. Mounts the app's root view and, in the
+    /// browser, returns while the module stays alive to receive events.
+    public static func main() {
+        _installHostExecutor()
+        _Runtime.shared.launch(Self())
+    }
+}

package/Sources/SwiftUI/API/Color.swift

@@ -0,0 +1,161 @@
+public struct Color: Hashable, Sendable {
+    enum Storage: Hashable, Sendable {
+        case rgba(red: Double, green: Double, blue: Double, opacity: Double)
+        case semantic(name: String, opacity: Double)
+        /// A `.colorset` from the asset catalog (light/dark resolved by the renderer).
+        case named(name: String, opacity: Double)
+    }
+
+    let storage: Storage
+
+    public init(red: Double, green: Double, blue: Double, opacity: Double = 1) {
+        storage = .rgba(red: red, green: green, blue: blue, opacity: opacity)
+    }
+
+    /// A color from the asset catalog, possibly namespaced (`"dough/plain-bg"`).
+    /// SwiftUI's `bundle:` parameter is not offered (see `Image.init(_:)`).
+    public init(_ name: String) {
+        storage = .named(name: name, opacity: 1)
+    }
+
+    public init(white: Double, opacity: Double = 1) {
+        storage = .rgba(red: white, green: white, blue: white, opacity: opacity)
+    }
+
+    init(semantic name: String) {
+        storage = .semantic(name: name, opacity: 1)
+    }
+
+    // iOS system palette, light appearance.
+    public static let red = Color(red: 1.0, green: 0.231, blue: 0.188)
+    public static let orange = Color(red: 1.0, green: 0.584, blue: 0.0)
+    public static let yellow = Color(red: 1.0, green: 0.8, blue: 0.0)
+    public static let green = Color(red: 0.204, green: 0.78, blue: 0.349)
+    public static let mint = Color(red: 0.0, green: 0.78, blue: 0.745)
+    public static let teal = Color(red: 0.188, green: 0.69, blue: 0.78)
+    public static let cyan = Color(red: 0.196, green: 0.678, blue: 0.902)
+    public static let blue = Color(red: 0.0, green: 0.478, blue: 1.0)
+    public static let indigo = Color(red: 0.345, green: 0.337, blue: 0.839)
+    public static let purple = Color(red: 0.686, green: 0.322, blue: 0.871)
+    public static let pink = Color(red: 1.0, green: 0.176, blue: 0.333)
+    public static let brown = Color(red: 0.635, green: 0.518, blue: 0.368)
+    public static let gray = Color(red: 0.557, green: 0.557, blue: 0.576)
+    public static let black = Color(red: 0, green: 0, blue: 0)
+    public static let white = Color(red: 1, green: 1, blue: 1)
+
+    // Semantic colors the renderer resolves per color scheme.
+    public static let clear = Color(semantic: "clear")
+    public static let primary = Color(semantic: "primary")
+    public static let secondary = Color(semantic: "secondary")
+    public static let accentColor = Color(semantic: "accent")
+
+    public func opacity(_ opacity: Double) -> Color {
+        switch storage {
+        case .rgba(let r, let g, let b, let a):
+            Color(red: r, green: g, blue: b, opacity: a * opacity)
+        case .semantic(let name, let a):
+            Color(storage: .semantic(name: name, opacity: a * opacity))
+        case .named(let name, let a):
+            Color(storage: .named(name: name, opacity: a * opacity))
+        }
+    }
+
+    init(storage: Storage) { self.storage = storage }
+
+    public var _json: _JSON {
+        switch storage {
+        case .rgba(let r, let g, let b, let a):
+            .object(["r": .number(r), "g": .number(g), "b": .number(b), "a": .number(a)])
+        case .semantic(let name, let a):
+            a == 1 ? .object(["name": .string(name)]) : .object(["name": .string(name), "a": .number(a)])
+        case .named(let name, let a):
+            .object(["named": .string(name), "opacity": .number(a)])
+        }
+    }
+}
+
+// MARK: - Shapes (clipping only, for now)
+
+public protocol Shape: Sendable {
+    var _name: String { get }
+    var _cornerRadius: CGFloat { get }
+}
+
+public struct Rectangle: Shape {
+    public init() {}
+    public var _name: String { "rectangle" }
+    public var _cornerRadius: CGFloat { 0 }
+}
+
+/// Accepted for source compatibility; corners render continuous either way.
+public enum RoundedCornerStyle: Hashable, Sendable {
+    case circular, continuous
+}
+
+public struct RoundedRectangle: Shape {
+    public var cornerRadius: CGFloat
+    public var style: RoundedCornerStyle
+    public init(cornerRadius: CGFloat, style: RoundedCornerStyle = .continuous) {
+        self.cornerRadius = cornerRadius
+        self.style = style
+    }
+    public init(cornerSize: CGSize, style: RoundedCornerStyle = .continuous) {
+        cornerRadius = min(cornerSize.width, cornerSize.height)
+        self.style = style
+    }
+    public var _name: String { "roundedRectangle" }
+    public var _cornerRadius: CGFloat { cornerRadius }
+}
+
+public struct Circle: Shape {
+    public init() {}
+    public var _name: String { "circle" }
+    public var _cornerRadius: CGFloat { 9999 }
+}
+
+public struct Capsule: Shape {
+    public init() {}
+    public var _name: String { "capsule" }
+    public var _cornerRadius: CGFloat { 9999 }
+}
+
+public struct Ellipse: Shape {
+    public init() {}
+    public var _name: String { "ellipse" }
+    public var _cornerRadius: CGFloat { 9999 }
+}
+
+/// The container's shape (`.containerShape`), rendered as a 12pt rounded
+/// rectangle, the corner radius the Food Truck cards use.
+public struct ContainerRelativeShape: Shape {
+    public init() {}
+    public var _name: String { "containerRelative" }
+    public var _cornerRadius: CGFloat { 12 }
+}
+
+// Shapes as static members (`.clipShape(.capsule)`, `.background(.red, in: .rect(cornerRadius: 8))`).
+extension Shape where Self == Capsule {
+    public static var capsule: Capsule { Capsule() }
+    /// The shape of a button's border; drawn as a capsule.
+    public static var buttonBorder: Capsule { Capsule() }
+}
+extension Shape where Self == Circle {
+    public static var circle: Circle { Circle() }
+}
+extension Shape where Self == Ellipse {
+    public static var ellipse: Ellipse { Ellipse() }
+}
+extension Shape where Self == Rectangle {
+    public static var rect: Rectangle { Rectangle() }
+}
+extension Shape where Self == RoundedRectangle {
+    public static func rect(cornerRadius: CGFloat, style: RoundedCornerStyle = .continuous) -> RoundedRectangle {
+        RoundedRectangle(cornerRadius: cornerRadius, style: style)
+    }
+    public static func rect(cornerSize: CGSize, style: RoundedCornerStyle = .continuous) -> RoundedRectangle {
+        RoundedRectangle(cornerSize: cornerSize, style: style)
+    }
+}
+extension Shape where Self == ContainerRelativeShape {
+    public static var containerRelative: ContainerRelativeShape { ContainerRelativeShape() }
+}