@swiftbrowser/swift 0.0.0-stage → 0.1.0

package/Sources/SwiftUI/API/ShapeStyle.swift

@@ -0,0 +1,311 @@
+/// Paints: colors, hierarchical label/fill levels, gradients and materials.
+/// A style serializes to the JSON the renderer resolves (see
+/// docs/ops-protocol.md, "Phase 6 additions"): a `Color`'s own forms, or
+/// `{"hierarchical": 1...4}`, `{"linearGradient": {...}}`,
+/// `{"radialGradient": {...}}`, `{"colorGradient": color}`, `{"material": name}`.
+public protocol ShapeStyle: Sendable {
+    var _json: _JSON { get }
+}
+
+extension Color: ShapeStyle {}
+
+// MARK: - Hierarchical (.primary ... .quaternary)
+
+public struct HierarchicalShapeStyle: ShapeStyle, Hashable {
+    let level: Int
+
+    public static let primary = HierarchicalShapeStyle(level: 1)
+    public static let secondary = HierarchicalShapeStyle(level: 2)
+    public static let tertiary = HierarchicalShapeStyle(level: 3)
+    public static let quaternary = HierarchicalShapeStyle(level: 4)
+
+    public var _json: _JSON { .object(["hierarchical": .number(Double(level))]) }
+
+    public func opacity(_ opacity: Double) -> AnyShapeStyle {
+        AnyShapeStyle(_json: .object(["hierarchical": .number(Double(level)), "opacity": .number(opacity)]))
+    }
+}
+
+extension ShapeStyle where Self == HierarchicalShapeStyle {
+    public static var primary: HierarchicalShapeStyle { .primary }
+    public static var secondary: HierarchicalShapeStyle { .secondary }
+    public static var tertiary: HierarchicalShapeStyle { .tertiary }
+    public static var quaternary: HierarchicalShapeStyle { .quaternary }
+}
+
+/// The view's background color (`.background` as a style).
+public struct BackgroundStyle: ShapeStyle, Hashable {
+    public init() {}
+    public var _json: _JSON { .object(["name": .string("systemBackground")]) }
+}
+
+extension ShapeStyle where Self == BackgroundStyle {
+    public static var background: BackgroundStyle { BackgroundStyle() }
+}
+
+/// The current foreground color (`.foreground` as a style; `currentColor`).
+public struct ForegroundStyle: ShapeStyle, Hashable {
+    public init() {}
+    public var _json: _JSON { .object(["name": .string("primary")]) }
+}
+
+extension ShapeStyle where Self == ForegroundStyle {
+    public static var foreground: ForegroundStyle { ForegroundStyle() }
+}
+
+// The named colors, reachable as styles (`.fill(.indigo)`, `.background(.red)`).
+extension ShapeStyle where Self == Color {
+    public static var red: Color { .red }
+    public static var orange: Color { .orange }
+    public static var yellow: Color { .yellow }
+    public static var green: Color { .green }
+    public static var mint: Color { .mint }
+    public static var teal: Color { .teal }
+    public static var cyan: Color { .cyan }
+    public static var blue: Color { .blue }
+    public static var indigo: Color { .indigo }
+    public static var purple: Color { .purple }
+    public static var pink: Color { .pink }
+    public static var brown: Color { .brown }
+    public static var gray: Color { .gray }
+    public static var black: Color { .black }
+    public static var white: Color { .white }
+    public static var clear: Color { .clear }
+    public static var accentColor: Color { .accentColor }
+}
+
+// MARK: - Gradients
+
+public struct Gradient: Equatable, Sendable {
+    public struct Stop: Equatable, Sendable {
+        public var color: Color
+        public var location: CGFloat
+
+        public init(color: Color, location: CGFloat) {
+            self.color = color
+            self.location = location
+        }
+    }
+
+    public var stops: [Stop]
+
+    public init(stops: [Stop]) { self.stops = stops }
+
+    /// Evenly spaced stops.
+    public init(colors: [Color]) {
+        let count = max(colors.count - 1, 1)
+        stops = colors.enumerated().map { index, color in
+            Stop(color: color, location: colors.count == 1 ? 0 : CGFloat(index) / CGFloat(count))
+        }
+    }
+
+    var _json: _JSON {
+        .array(stops.map { .object(["color": $0.color._json, "location": .number($0.location)]) })
+    }
+}
+
+/// `Color.gradient`: a subtle vertical gradient derived from one color.
+public struct AnyGradient: ShapeStyle, Equatable {
+    let color: Color
+
+    public var _json: _JSON { .object(["colorGradient": color._json]) }
+}
+
+extension Color {
+    public var gradient: AnyGradient { AnyGradient(color: self) }
+}
+
+public struct LinearGradient: ShapeStyle, Equatable {
+    public var gradient: Gradient
+    public var startPoint: UnitPoint
+    public var endPoint: UnitPoint
+
+    public init(gradient: Gradient, startPoint: UnitPoint, endPoint: UnitPoint) {
+        self.gradient = gradient
+        self.startPoint = startPoint
+        self.endPoint = endPoint
+    }
+
+    public init(colors: [Color], startPoint: UnitPoint, endPoint: UnitPoint) {
+        self.init(gradient: Gradient(colors: colors), startPoint: startPoint, endPoint: endPoint)
+    }
+
+    public init(stops: [Gradient.Stop], startPoint: UnitPoint, endPoint: UnitPoint) {
+        self.init(gradient: Gradient(stops: stops), startPoint: startPoint, endPoint: endPoint)
+    }
+
+    public var _json: _JSON {
+        .object(["linearGradient": .object([
+            "stops": gradient._json,
+            "start": startPoint._json,
+            "end": endPoint._json,
+        ])])
+    }
+}
+
+public struct RadialGradient: ShapeStyle, Equatable {
+    public var gradient: Gradient
+    public var center: UnitPoint
+    public var startRadius: CGFloat
+    public var endRadius: CGFloat
+
+    public init(gradient: Gradient, center: UnitPoint, startRadius: CGFloat, endRadius: CGFloat) {
+        self.gradient = gradient
+        self.center = center
+        self.startRadius = startRadius
+        self.endRadius = endRadius
+    }
+
+    public init(colors: [Color], center: UnitPoint, startRadius: CGFloat, endRadius: CGFloat) {
+        self.init(gradient: Gradient(colors: colors), center: center, startRadius: startRadius, endRadius: endRadius)
+    }
+
+    public init(stops: [Gradient.Stop], center: UnitPoint, startRadius: CGFloat, endRadius: CGFloat) {
+        self.init(gradient: Gradient(stops: stops), center: center, startRadius: startRadius, endRadius: endRadius)
+    }
+
+    public var _json: _JSON {
+        .object(["radialGradient": .object([
+            "stops": gradient._json,
+            "center": center._json,
+            "startRadius": .number(startRadius),
+            "endRadius": .number(endRadius),
+        ])])
+    }
+}
+
+extension ShapeStyle where Self == LinearGradient {
+    public static func linearGradient(_ gradient: Gradient, startPoint: UnitPoint, endPoint: UnitPoint) -> LinearGradient {
+        LinearGradient(gradient: gradient, startPoint: startPoint, endPoint: endPoint)
+    }
+
+    public static func linearGradient(colors: [Color], startPoint: UnitPoint, endPoint: UnitPoint) -> LinearGradient {
+        LinearGradient(colors: colors, startPoint: startPoint, endPoint: endPoint)
+    }
+
+    public static func linearGradient(stops: [Gradient.Stop], startPoint: UnitPoint, endPoint: UnitPoint) -> LinearGradient {
+        LinearGradient(stops: stops, startPoint: startPoint, endPoint: endPoint)
+    }
+}
+
+extension ShapeStyle where Self == RadialGradient {
+    public static func radialGradient(_ gradient: Gradient, center: UnitPoint, startRadius: CGFloat,
+                                      endRadius: CGFloat) -> RadialGradient {
+        RadialGradient(gradient: gradient, center: center, startRadius: startRadius, endRadius: endRadius)
+    }
+
+    public static func radialGradient(colors: [Color], center: UnitPoint, startRadius: CGFloat,
+                                      endRadius: CGFloat) -> RadialGradient {
+        RadialGradient(colors: colors, center: center, startRadius: startRadius, endRadius: endRadius)
+    }
+}
+
+extension UnitPoint {
+    var _json: _JSON { .object(["x": .number(x), "y": .number(y)]) }
+}
+
+// Gradients as views: a rectangle filled with the gradient (a `shape` element).
+private func _gradientViewProps(_ style: some ShapeStyle) -> _JSON {
+    .object([
+        "shape": .string("rectangle"),
+        "cornerRadius": .number(0),
+        "fill": style._json,
+        "stroke": .null,
+    ])
+}
+
+extension LinearGradient: _PrimitiveView {}
+extension LinearGradient: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON { _gradientViewProps(self) }
+}
+
+extension RadialGradient: _PrimitiveView {}
+extension RadialGradient: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON { _gradientViewProps(self) }
+}
+
+extension AnyGradient: _PrimitiveView {}
+extension AnyGradient: _HostView {
+    var _kind: String { "shape" }
+    func _props(in environment: EnvironmentValues) -> _JSON { _gradientViewProps(self) }
+}
+
+// MARK: - Shadows
+
+/// A shadow a style can carry (`.shadow(.drop(...))`). The renderer has no
+/// per-style shadows, so a shadowed style paints as its base style.
+public struct ShadowStyle: Equatable, Sendable {
+    public enum Kind: Equatable, Sendable { case drop, inner }
+
+    public let kind: Kind
+    public let color: Color
+    public let radius: CGFloat
+    public let x: CGFloat
+    public let y: CGFloat
+
+    public static func drop(color: Color = Color(white: 0, opacity: 0.33), radius: CGFloat,
+                            x: CGFloat = 0, y: CGFloat = 0) -> ShadowStyle {
+        ShadowStyle(kind: .drop, color: color, radius: radius, x: x, y: y)
+    }
+
+    public static func inner(color: Color = Color(white: 0, opacity: 0.55), radius: CGFloat,
+                             x: CGFloat = 0, y: CGFloat = 0) -> ShadowStyle {
+        ShadowStyle(kind: .inner, color: color, radius: radius, x: x, y: y)
+    }
+}
+
+extension ShapeStyle {
+    /// Approximation: the shadow is dropped and the style paints as before.
+    public func shadow(_ style: ShadowStyle) -> AnyShapeStyle {
+        AnyShapeStyle(_json: _json)
+    }
+}
+
+// MARK: - Materials
+
+public struct Material: ShapeStyle, Hashable {
+    let name: String
+
+    public static let ultraThinMaterial = Material(name: "ultraThin")
+    public static let thinMaterial = Material(name: "thin")
+    public static let regularMaterial = Material(name: "regular")
+    public static let thickMaterial = Material(name: "thick")
+    public static let ultraThickMaterial = Material(name: "ultraThick")
+    public static let bar = Material(name: "regular")
+
+    public var _json: _JSON { .object(["material": .string(name)]) }
+}
+
+extension ShapeStyle where Self == Material {
+    public static var ultraThinMaterial: Material { .ultraThinMaterial }
+    public static var thinMaterial: Material { .thinMaterial }
+    public static var regularMaterial: Material { .regularMaterial }
+    public static var thickMaterial: Material { .thickMaterial }
+    public static var ultraThickMaterial: Material { .ultraThickMaterial }
+    public static var bar: Material { .bar }
+}
+
+// MARK: - Type erasure
+
+public struct AnyShapeStyle: ShapeStyle {
+    public let _json: _JSON
+
+    public init<S: ShapeStyle>(_ style: S) { _json = style._json }
+
+    init(_json: _JSON) { self._json = _json }
+}
+
+/// Opacity on any style: wraps the style's JSON with an `opacity` multiplier.
+extension ShapeStyle {
+    public func opacity(_ opacity: Double) -> AnyShapeStyle {
+        if let color = self as? Color { return AnyShapeStyle(color.opacity(opacity)) }
+        if case .object(var fields) = _json {
+            let existing: Double = if case .number(let n)? = fields["opacity"] { n } else { 1 }
+            fields["opacity"] = .number(existing * opacity)
+            return AnyShapeStyle(_json: .object(fields))
+        }
+        return AnyShapeStyle(_json: _json)
+    }
+}

package/Sources/SwiftUI/API/State.swift

@@ -0,0 +1,127 @@
+/// Marker protocol matching SwiftUI's, so user code that constrains on it compiles.
+public protocol DynamicProperty {
+    mutating func update()
+}
+
+extension DynamicProperty {
+    public mutating func update() {}
+}
+
+/// Type-erased access to a `State` box, used by the runtime to carry storage
+/// across re-renders and to observe mutations.
+protocol _AnyStateBox: AnyObject {
+    var _anyValue: Any { get set }
+    var _onChange: (() -> Void)? { get set }
+    /// Shares the persistent storage of a box from a previous render, so that
+    /// closures captured earlier keep writing to the live value.
+    func _adopt(_ previous: any _AnyStateBox)
+}
+
+/// Views expose their `State` properties to the runtime through this protocol.
+protocol _StateProperty {
+    var _box: any _AnyStateBox { get }
+}
+
+/// The persistent value behind a `State`; survives the view struct being
+/// recreated because every box for the same mounted view shares it.
+final class _StateStorage<Value> {
+    var value: Value {
+        didSet { onChange?() }
+    }
+    var onChange: (() -> Void)?
+
+    init(_ value: Value) { self.value = value }
+}
+
+final class _StateBox<Value>: _AnyStateBox {
+    var storage: _StateStorage<Value>
+
+    var value: Value {
+        get { storage.value }
+        set { storage.value = newValue }
+    }
+
+    var _onChange: (() -> Void)? {
+        get { storage.onChange }
+        set { storage.onChange = newValue }
+    }
+
+    init(_ value: Value) { storage = _StateStorage(value) }
+
+    var _anyValue: Any {
+        get { storage.value }
+        set { storage.value = newValue as! Value }
+    }
+
+    func _adopt(_ previous: any _AnyStateBox) {
+        guard let previous = previous as? _StateBox<Value> else { return }
+        storage = previous.storage
+    }
+}
+
+/// A property wrapper that reads and writes a value managed by the runtime.
+///
+/// A view struct is recreated every time its parent's body runs; the runtime
+/// finds `State` properties by reflection and moves the previous values into
+/// the new struct, so the value persists for as long as the view stays mounted.
+@propertyWrapper
+public struct State<Value>: DynamicProperty {
+    let box: _StateBox<Value>
+
+    public init(wrappedValue: Value) {
+        box = _StateBox(wrappedValue)
+    }
+
+    public init(initialValue: Value) {
+        self.init(wrappedValue: initialValue)
+    }
+
+    public var wrappedValue: Value {
+        get { box.value }
+        nonmutating set { box.value = newValue }
+    }
+
+    public var projectedValue: Binding<Value> {
+        let box = self.box
+        return Binding(get: { box.value }, set: { box.value = $0 })
+    }
+}
+
+extension State where Value: ExpressibleByNilLiteral {
+    public init() { self.init(wrappedValue: nil) }
+}
+
+extension State: _StateProperty {
+    var _box: any _AnyStateBox { box }
+}
+
+/// A two-way connection to a value owned elsewhere.
+@propertyWrapper
+@dynamicMemberLookup
+public struct Binding<Value>: DynamicProperty {
+    let getter: () -> Value
+    let setter: (Value) -> Void
+
+    public init(get: @escaping () -> Value, set: @escaping (Value) -> Void) {
+        getter = get
+        setter = set
+    }
+
+    public static func constant(_ value: Value) -> Binding<Value> {
+        Binding(get: { value }, set: { _ in })
+    }
+
+    public var wrappedValue: Value {
+        get { getter() }
+        nonmutating set { setter(newValue) }
+    }
+
+    public var projectedValue: Binding<Value> { self }
+
+    public subscript<Subject>(dynamicMember keyPath: WritableKeyPath<Value, Subject>) -> Binding<Subject> {
+        Binding<Subject>(
+            get: { self.wrappedValue[keyPath: keyPath] },
+            set: { self.wrappedValue[keyPath: keyPath] = $0 }
+        )
+    }
+}

package/Sources/SwiftUI/API/StrokeStyle.swift

@@ -0,0 +1,30 @@
+/// The line cap of a stroke (CoreGraphics' `CGLineCap`).
+public enum CGLineCap: Int32, Hashable, Sendable {
+    case butt, round, square
+}
+
+/// The line join of a stroke (CoreGraphics' `CGLineJoin`).
+public enum CGLineJoin: Int32, Hashable, Sendable {
+    case miter, round, bevel
+}
+
+/// How a line is stroked. Charts read `lineWidth`; the other fields are kept
+/// for source compatibility.
+public struct StrokeStyle: Equatable, Sendable {
+    public var lineWidth: CGFloat
+    public var lineCap: CGLineCap
+    public var lineJoin: CGLineJoin
+    public var miterLimit: CGFloat
+    public var dash: [CGFloat]
+    public var dashPhase: CGFloat
+
+    public init(lineWidth: CGFloat = 1, lineCap: CGLineCap = .butt, lineJoin: CGLineJoin = .miter,
+                miterLimit: CGFloat = 10, dash: [CGFloat] = [], dashPhase: CGFloat = 0) {
+        self.lineWidth = lineWidth
+        self.lineCap = lineCap
+        self.lineJoin = lineJoin
+        self.miterLimit = miterLimit
+        self.dash = dash
+        self.dashPhase = dashPhase
+    }
+}

package/Sources/SwiftUI/API/Tabs.swift

@@ -0,0 +1,119 @@
+/// A view that switches between child views with a tab bar.
+public struct TabView<SelectionValue: Hashable, Content: View> {
+    let content: Content
+    let selection: Binding<SelectionValue>?
+    @State var selectedIndex = 0
+
+    public init(selection: Binding<SelectionValue>?, @ViewBuilder content: () -> Content) {
+        self.selection = selection
+        self.content = content()
+    }
+}
+
+extension TabView where SelectionValue == Int {
+    public init(@ViewBuilder content: () -> Content) {
+        self.selection = nil
+        self.content = content()
+    }
+}
+
+protocol _TabViewHost {
+    var _tabContent: any View { get }
+    /// Index of the selected tab given the tabs' tags, and a setter.
+    func _selectedIndex(tags: [AnyHashable?]) -> Int
+    func _select(index: Int, tags: [AnyHashable?])
+}
+
+extension TabView: _PrimitiveView {}
+extension TabView: _HostView {
+    var _kind: String { "tabview" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object([:]) }
+    // Children and props are produced by the runtime.
+}
+extension TabView: _TabViewHost {
+    var _tabContent: any View { content }
+
+    func _selectedIndex(tags: [AnyHashable?]) -> Int {
+        if let selection {
+            let current = AnyHashable(selection.wrappedValue)
+            return tags.firstIndex { $0 == current } ?? 0
+        }
+        return min(selectedIndex, max(0, tags.count - 1))
+    }
+
+    func _select(index: Int, tags: [AnyHashable?]) {
+        if let selection {
+            if index < tags.count, let tag = tags[index], let value = tag.base as? SelectionValue {
+                selection.wrappedValue = value
+            }
+        } else {
+            selectedIndex = index
+        }
+    }
+}
+
+/// One tab, produced by the runtime from the TabView's content.
+struct _TabScreenView {
+    let content: any View
+    let title: String
+    let systemImage: String?
+    /// Only the selected tab's `navigationTitle` and `.toolbar` reach the
+    /// enclosing screen (a tab's own `NavigationStack` is flattened into it).
+    var isSelected = true
+}
+extension _TabScreenView: _PrimitiveView {}
+extension _TabScreenView: _HostView {
+    var _kind: String { "tab" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(["title": .string(title), "systemImage": systemImage.map(_JSON.string) ?? .null])
+    }
+    var _content: [any View] { [content] }
+}
+
+// MARK: - .tabItem and .tag
+
+protocol _TabItemProviding {
+    var _tabLabel: any View { get }
+    var _tabContent: any View { get }
+}
+
+struct _TabItemView<Content: View, Label: View> {
+    let content: Content
+    let label: Label
+}
+extension _TabItemView: _PrimitiveView {}
+extension _TabItemView: _GroupView {
+    var _children: [any View] { [content] }
+}
+extension _TabItemView: _TabItemProviding {
+    var _tabLabel: any View { label }
+    var _tabContent: any View { content }
+}
+
+protocol _TagProviding {
+    var _tag: AnyHashable { get }
+    var _tagged: any View { get }
+}
+
+struct _TagView<Content: View, Tag: Hashable> {
+    let content: Content
+    let tag: Tag
+}
+extension _TagView: _PrimitiveView {}
+extension _TagView: _GroupView {
+    var _children: [any View] { [content] }
+}
+extension _TagView: _TagProviding {
+    var _tag: AnyHashable { AnyHashable(tag) }
+    var _tagged: any View { content }
+}
+
+extension View {
+    public func tabItem<Label: View>(@ViewBuilder _ label: () -> Label) -> some View {
+        _TabItemView(content: self, label: label())
+    }
+
+    public func tag<Tag: Hashable>(_ tag: Tag) -> some View {
+        _TagView(content: self, tag: tag)
+    }
+}

package/Sources/SwiftUI/API/Tasks.swift

@@ -0,0 +1,35 @@
+/// Views that start an asynchronous task when they appear.
+protocol _TaskStarting {
+    /// Identity of the task; when it changes the task restarts.
+    var _taskID: AnyHashable? { get }
+    var _taskAction: @Sendable () async -> Void { get }
+}
+
+struct _TaskView<Content: View> {
+    let content: Content
+    let id: AnyHashable?
+    let action: @Sendable () async -> Void
+}
+extension _TaskView: _PrimitiveView {}
+extension _TaskView: _GroupView {
+    var _children: [any View] { [content] }
+}
+extension _TaskView: _TaskStarting {
+    var _taskID: AnyHashable? { id }
+    var _taskAction: @Sendable () async -> Void { action }
+}
+
+extension View {
+    /// Runs `action` in a task when the view appears, cancelling it when the
+    /// view disappears.
+    public func task(priority: TaskPriority = .userInitiated,
+                     @_inheritActorContext _ action: @escaping @Sendable () async -> Void) -> some View {
+        _TaskView(content: self, id: nil, action: action)
+    }
+
+    /// Like `task(_:)`, restarting the task whenever `id` changes.
+    public func task<T: Hashable>(id: T, priority: TaskPriority = .userInitiated,
+                                  @_inheritActorContext _ action: @escaping @Sendable () async -> Void) -> some View {
+        _TaskView(content: self, id: AnyHashable(id), action: action)
+    }
+}