@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/API/Video.swift

@@ -0,0 +1,64 @@
+/// The `video` element (docs/ops-protocol.md, "Video and audio"): an HTML
+/// `<video>` the page plays. The shim's SwiftUI has no video view of its own;
+/// AVFoundation builds one on this (`AVPlayer`'s views: AVKit's
+/// `VideoPlayer`, an `AVPlayerLayer` in a UIKit view), with the props worked
+/// out from the player and a handler for the page's `video` events.
+///
+/// Public so the frameworks above SwiftUI can emit the element; apps never
+/// name it.
+public struct _VideoElement {
+    let props: _JSON
+    let handler: (_JSON) -> Void
+
+    /// `props` are the element's (see the protocol document); `handler`
+    /// receives each `video` event whole (`{"type": "video", "id", "event", …}`).
+    public init(props: _JSON, handler: @escaping (_JSON) -> Void) {
+        self.props = props
+        self.handler = handler
+    }
+}
+extension _VideoElement: _PrimitiveView {}
+extension _VideoElement: _HostView {
+    var _kind: String { "video" }
+    func _props(in environment: EnvironmentValues) -> _JSON { props }
+    var _handler: ((_JSON) -> Void)? { handler }
+}
+
+extension _Runtime {
+    /// The `response` fields for a headless `media` request (AVFoundation's
+    /// files and probes, QuickLook's previews): a `file` gets a stand-in URL,
+    /// a `probe` the `duration` / `width` / `height` of the `SB_RESPONSES`
+    /// entry whose `url` (exact) or `prefix` matches and that has a
+    /// `duration`, an `open` finds no tab to open (`opened: false`).
+    nonisolated static func _headlessMedia(params: _JSON, fixtures: [_JSON], serial: Int) -> [String: _JSON] {
+        guard case .object(let request) = params, case .string(let action)? = request["action"] else {
+            return ["error": .string("malformed request")]
+        }
+        switch action {
+        case "file":
+            return ["value": .object(["url": .string("blob:headless/\(serial)")])]
+        case "release":
+            return ["value": .object([:])]
+        case "open":
+            return ["value": .object(["opened": .bool(false)])]
+        case "probe":
+            guard case .string(let url)? = request["url"] else { return ["error": .string("malformed request")] }
+            let fixture = fixtures.first { item in
+                guard case .object(let fields) = item, fields["duration"] != nil else { return false }
+                if case .string(let exact)? = fields["url"], exact == url { return true }
+                if case .string(let prefix)? = fields["prefix"], url.hasPrefix(prefix) { return true }
+                return false
+            }
+            guard case .object(let fields)? = fixture else {
+                return ["error": .string("headless: no SB_RESPONSES entry with a duration for \(url)")]
+            }
+            return ["value": .object([
+                "duration": fields["duration"] ?? .null,
+                "width": fields["width"] ?? .number(0),
+                "height": fields["height"] ?? .number(0),
+            ])]
+        default:
+            return ["error": .string("headless: unknown media action \(action)")]
+        }
+    }
+}

package/Sources/SwiftUI/API/View.swift

@@ -0,0 +1,215 @@
+/// A type that represents part of your app's user interface.
+///
+/// Mirrors SwiftUI's declaration, including main-actor isolation, so that a
+/// type conforming to `View` in its primary declaration is main-actor
+/// isolated on every platform.
+@MainActor @preconcurrency
+public protocol View {
+    associatedtype Body: View
+    @ViewBuilder var body: Self.Body { get }
+}
+
+extension Never: View {
+    public typealias Body = Never
+    public var body: Never { fatalError("Never has no body") }
+}
+
+/// Views the runtime renders directly instead of evaluating `body`.
+public protocol _PrimitiveView: View where Body == Never {}
+
+extension _PrimitiveView {
+    public var body: Never {
+        fatalError("\(Self.self) is a primitive view and has no body")
+    }
+}
+
+/// A view whose only job is to contribute other views to its parent.
+/// Tuples, optionals, conditionals, `Group`, `AnyView` and `ForEach` are groups.
+protocol _GroupView: _TraitBearing {
+    var _children: [any View] { get }
+    /// Stable identities for `_children`, when the group is keyed (`ForEach`).
+    var _keys: [AnyHashable]? { get }
+    /// Whether the group is more than a wrapper of one view: it has other
+    /// than one child, or keys. A modifier applied to such a group applies
+    /// to each of its children (`_StyledGroup`).
+    var _spreads: Bool { get }
+}
+
+extension _GroupView {
+    var _keys: [AnyHashable]? { nil }
+    var _spreads: Bool { _keys != nil || _children.count != 1 }
+}
+
+/// A view that becomes an element in the render tree (see docs/ops-protocol.md).
+protocol _HostView: _TraitBearing {
+    var _kind: String { get }
+    func _props(in environment: EnvironmentValues) -> _JSON
+    var _content: [any View] { get }
+    /// Receives the event payload (`.null` for a tap).
+    var _handler: ((_JSON) -> Void)? { get }
+}
+
+extension _HostView {
+    var _content: [any View] { [] }
+    var _handler: ((_JSON) -> Void)? { nil }
+}
+
+// MARK: - ViewBuilder
+
+@resultBuilder
+public enum ViewBuilder {
+    public static func buildBlock() -> EmptyView { EmptyView() }
+
+    public static func buildBlock<Content: View>(_ content: Content) -> Content { content }
+
+    public static func buildBlock<each Content: View>(
+        _ content: repeat each Content
+    ) -> TupleView<(repeat each Content)> {
+        var children: [any View] = []
+        for child in repeat each content { children.append(child) }
+        return TupleView((repeat each content), children: children)
+    }
+
+    public static func buildExpression<Content: View>(_ content: Content) -> Content { content }
+
+    public static func buildOptional<Content: View>(_ content: Content?) -> Content? { content }
+
+    public static func buildEither<TrueContent: View, FalseContent: View>(
+        first: TrueContent
+    ) -> _ConditionalContent<TrueContent, FalseContent> {
+        _ConditionalContent(storage: .trueContent(first))
+    }
+
+    public static func buildEither<TrueContent: View, FalseContent: View>(
+        second: FalseContent
+    ) -> _ConditionalContent<TrueContent, FalseContent> {
+        _ConditionalContent(storage: .falseContent(second))
+    }
+
+    public static func buildLimitedAvailability<Content: View>(_ content: Content) -> AnyView {
+        AnyView(content)
+    }
+}
+
+// MARK: - Structural views
+
+public struct EmptyView: Sendable {
+    public init() {}
+}
+extension EmptyView: _PrimitiveView {}
+extension EmptyView: _GroupView {
+    var _children: [any View] { [] }
+}
+
+public struct TupleView<T> {
+    public var value: T
+    let children: [any View]
+
+    init(_ value: T, children: [any View]) {
+        self.value = value
+        self.children = children
+    }
+}
+extension TupleView: _PrimitiveView {}
+extension TupleView: _GroupView {
+    var _children: [any View] { children }
+}
+
+public struct _ConditionalContent<TrueContent: View, FalseContent: View> {
+    enum Storage {
+        case trueContent(TrueContent)
+        case falseContent(FalseContent)
+    }
+    let storage: Storage
+}
+extension _ConditionalContent: _PrimitiveView {}
+extension _ConditionalContent: _GroupView {
+    var _children: [any View] {
+        switch storage {
+        case .trueContent(let view): [view]
+        case .falseContent(let view): [view]
+        }
+    }
+}
+
+extension Optional: View where Wrapped: View {
+    public typealias Body = Never
+    public var body: Never { fatalError("Optional is a primitive view and has no body") }
+}
+// Unconditional: the marker only lets the trait lookups run (ViewTraits.swift).
+extension Optional: _TraitBearing {}
+extension Optional: _GroupView where Wrapped: View {
+    var _children: [any View] {
+        switch self {
+        case .some(let view): [view]
+        case .none: []
+        }
+    }
+}
+
+/// A type-erased view.
+public struct AnyView {
+    let storage: any View
+
+    public init<V: View>(_ view: V) { storage = view }
+    public init<V: View>(erasing view: V) { storage = view }
+}
+extension AnyView: _PrimitiveView {}
+extension AnyView: _GroupView {
+    var _children: [any View] { [storage] }
+}
+
+/// Collects views without affecting layout.
+public struct Group<Content: View> {
+    let content: Content
+    public init(@ViewBuilder content: () -> Content) { self.content = content() }
+}
+extension Group: _PrimitiveView {}
+extension Group: _GroupView {
+    var _children: [any View] { [content] }
+}
+
+/// A view that computes views on demand from a collection, keyed by identity.
+/// `Content` is unconstrained so that the same type can produce chart content
+/// (`ForEach` inside a `Chart`, see Charts/ChartContent.swift); the `View`
+/// conformance applies when `Content` is a view.
+public struct ForEach<Data: RandomAccessCollection, ID: Hashable, Content> {
+    public let data: Data
+    let id: (Data.Element) -> ID
+    let content: (Data.Element) -> Content
+
+    init(_data data: Data, id: @escaping (Data.Element) -> ID, content: @escaping (Data.Element) -> Content) {
+        self.data = data
+        self.id = id
+        self.content = content
+    }
+}
+
+extension ForEach where Content: View {
+    public init(_ data: Data, id: KeyPath<Data.Element, ID>,
+                @ViewBuilder content: @escaping (Data.Element) -> Content) {
+        self.init(_data: data, id: { $0[keyPath: id] }, content: content)
+    }
+}
+
+extension ForEach where Content: View, Data.Element: Identifiable, ID == Data.Element.ID {
+    public init(_ data: Data, @ViewBuilder content: @escaping (Data.Element) -> Content) {
+        self.init(_data: data, id: { $0.id }, content: content)
+    }
+}
+
+extension ForEach where Content: View, Data == Range<Int>, ID == Int {
+    public init(_ data: Range<Int>, @ViewBuilder content: @escaping (Int) -> Content) {
+        self.init(_data: data, id: { $0 }, content: content)
+    }
+}
+
+extension ForEach: View where Content: View {
+    public typealias Body = Never
+}
+extension ForEach: _PrimitiveView where Content: View {}
+extension ForEach: _TraitBearing {}
+extension ForEach: _GroupView where Content: View {
+    var _children: [any View] { data.map { content($0) } }
+    var _keys: [AnyHashable]? { data.map { AnyHashable(id($0)) } }
+}

package/Sources/SwiftUI/API/ViewModifier.swift

@@ -0,0 +1,43 @@
+/// A reusable modifier: `body(content:)` wraps the view it is applied to.
+/// `@State` and `@Environment` properties declared on a modifier are managed
+/// by the runtime like a view's (it reflects into the modifier of a
+/// `ModifiedContent`).
+@MainActor @preconcurrency
+public protocol ViewModifier {
+    associatedtype Body: View
+    typealias Content = _ViewModifier_Content<Self>
+    @ViewBuilder func body(content: Content) -> Body
+}
+
+/// The view a modifier's `body(content:)` receives: the modified view, erased.
+public struct _ViewModifier_Content<Modifier: ViewModifier> {
+    let view: AnyView
+}
+extension _ViewModifier_Content: _PrimitiveView {}
+extension _ViewModifier_Content: _GroupView {
+    var _children: [any View] { [view] }
+}
+
+/// A view with a `ViewModifier` applied.
+public struct ModifiedContent<Content: View, Modifier: ViewModifier>: View {
+    public var content: Content
+    public var modifier: Modifier
+
+    public init(content: Content, modifier: Modifier) {
+        self.content = content
+        self.modifier = modifier
+    }
+
+    public var body: some View {
+        modifier.body(content: _ViewModifier_Content(view: AnyView(content)))
+    }
+}
+
+nonisolated extension View {
+    @MainActor
+    public func modifier<M: ViewModifier>(_ modifier: M) -> ModifiedContent<Self, M> {
+        ModifiedContent(content: self, modifier: modifier)
+    }
+}
+
+extension ModifiedContent: _HoldsModifier {}

package/Sources/SwiftUI/API/VisualEffect.swift

@@ -0,0 +1,155 @@
+/// `.visualEffect { content, proxy in … }` (docs/ops-protocol.md, "Phase 12").
+/// The closure's effects (offset, scale, rotation, opacity, blur, …) apply as
+/// the matching view modifiers. The proxy is empty: the browser does not
+/// report a view's frame on every scroll step, so an effect that reads
+/// `proxy.frame(in: .global)` sees a zero rectangle and the view renders
+/// without that part of the effect. Compile-level support, honestly limited.
+
+public protocol VisualEffect {}
+
+/// The chained effects, as style changes on the content.
+protocol _VisualEffectChaining {
+    var _effects: [(inout _Style) -> Void] { get }
+}
+
+public struct EmptyVisualEffect: VisualEffect, _VisualEffectChaining {
+    var _effects: [(inout _Style) -> Void] { [] }
+    public init() {}
+}
+
+public struct _VisualEffectChain: VisualEffect, _VisualEffectChaining {
+    var _effects: [(inout _Style) -> Void]
+}
+
+extension VisualEffect {
+    func _adding(_ effect: @escaping (inout _Style) -> Void) -> _VisualEffectChain {
+        _VisualEffectChain(_effects: ((self as? _VisualEffectChaining)?._effects ?? []) + [effect])
+    }
+
+    public func offset(x: CGFloat = 0, y: CGFloat = 0) -> _VisualEffectChain {
+        _adding { $0.extras["offset"] = .object(["x": .number(x), "y": .number(y)]) }
+    }
+    public func offset(_ offset: CGSize) -> _VisualEffectChain { self.offset(x: offset.width, y: offset.height) }
+    public func scaleEffect(_ scale: CGFloat, anchor: UnitPoint = .center) -> _VisualEffectChain {
+        scaleEffect(x: scale, y: scale, anchor: anchor)
+    }
+    public func scaleEffect(_ scale: CGSize, anchor: UnitPoint = .center) -> _VisualEffectChain {
+        scaleEffect(x: scale.width, y: scale.height, anchor: anchor)
+    }
+    public func scaleEffect(x: CGFloat = 1, y: CGFloat = 1, anchor: UnitPoint = .center) -> _VisualEffectChain {
+        _adding {
+            $0.extras["scale"] = .object(["x": .number(x), "y": .number(y)])
+            $0.extras["scaleAnchor"] = anchor._json
+        }
+    }
+    public func rotationEffect(_ angle: Angle, anchor: UnitPoint = .center) -> _VisualEffectChain {
+        _adding {
+            $0.extras["rotation"] = .number(angle.degrees)
+            $0.extras["rotationAnchor"] = anchor._json
+        }
+    }
+    public func rotation3DEffect(_ angle: Angle, axis: (x: CGFloat, y: CGFloat, z: CGFloat),
+                                 anchor: UnitPoint = .center, anchorZ: CGFloat = 0,
+                                 perspective: CGFloat = 1) -> _VisualEffectChain {
+        _adding {
+            $0.extras["rotation3D"] = .object([
+                "angle": .number(angle.degrees),
+                "axis": .object(["x": .number(axis.x), "y": .number(axis.y), "z": .number(axis.z)]),
+                "anchor": anchor._json,
+                "perspective": .number(perspective),
+            ])
+        }
+    }
+    public func opacity(_ opacity: Double) -> _VisualEffectChain { _adding { $0.opacity = opacity } }
+    public func blur(radius: CGFloat, opaque: Bool = false) -> _VisualEffectChain { _adding { $0.extras["blur"] = .number(radius) } }
+    /// Accepted; the renderer has no filter for these yet.
+    public func brightness(_ amount: Double) -> _VisualEffectChain { _adding { _ in } }
+    public func contrast(_ amount: Double) -> _VisualEffectChain { _adding { _ in } }
+    public func saturation(_ amount: Double) -> _VisualEffectChain { _adding { _ in } }
+    public func grayscale(_ amount: Double) -> _VisualEffectChain { _adding { _ in } }
+    public func hueRotation(_ angle: Angle) -> _VisualEffectChain { _adding { _ in } }
+    public func colorEffect<S: ShapeStyle>(_ shader: S) -> _VisualEffectChain { _adding { _ in } }
+}
+
+nonisolated extension View {
+    public func visualEffect(_ effect: @escaping (EmptyVisualEffect, GeometryProxy) -> some VisualEffect) -> some View {
+        let result = effect(EmptyVisualEffect(), GeometryProxy(size: .zero))
+        let effects = (result as? _VisualEffectChaining)?._effects ?? []
+        return _styled { style in
+            for apply in effects { apply(&style) }
+        }
+    }
+}
+
+// MARK: - Scroll transitions
+
+/// Where a view is in its scroll view, for `.scrollTransition`: about to
+/// enter at the top leading edge, fully visible (`identity`), or leaving at
+/// the bottom trailing edge.
+public enum ScrollTransitionPhase: Hashable, Sendable {
+    case topLeading, identity, bottomTrailing
+
+    public var isIdentity: Bool { self == .identity }
+
+    /// -1 at the top leading edge, 0 when visible, 1 at the bottom trailing edge.
+    public var value: Double {
+        switch self {
+        case .topLeading: -1
+        case .identity: 0
+        case .bottomTrailing: 1
+        }
+    }
+}
+
+/// When a scroll transition applies its effect; accepted.
+public struct ScrollTransitionConfiguration: Sendable {
+    public static let identity = ScrollTransitionConfiguration()
+    public static func animated(_ animation: Animation = .default) -> ScrollTransitionConfiguration { .init() }
+    public static let animated = ScrollTransitionConfiguration()
+    public static func interactive(timingCurve: UnitCurve = .easeInOut) -> ScrollTransitionConfiguration { .init() }
+    public static let interactive = ScrollTransitionConfiguration()
+    public func threshold(_ threshold: ScrollTransitionConfiguration.Threshold) -> ScrollTransitionConfiguration { self }
+    public func animation(_ animation: Animation) -> ScrollTransitionConfiguration { self }
+
+    public struct Threshold: Sendable {
+        public static let visible = Threshold()
+        public static let hidden = Threshold()
+        public static var centered: Threshold { Threshold() }
+        public static func visible(_ amount: Double) -> Threshold { Threshold() }
+        public func interpolated(towards other: Threshold, amount: Double) -> Threshold { self }
+        public func inset(by distance: Double) -> Threshold { self }
+    }
+}
+
+nonisolated extension View {
+    /// The effect for a view as it scrolls in and out. The browser does not
+    /// report where a view is on every scroll step, so the view shows the
+    /// effect of the `identity` phase: as it is when fully visible.
+    public func scrollTransition(_ configuration: ScrollTransitionConfiguration = .interactive, axis: Axis? = nil,
+                                 transition: @escaping (EmptyVisualEffect, ScrollTransitionPhase) -> some VisualEffect) -> some View {
+        let result = transition(EmptyVisualEffect(), .identity)
+        let effects = (result as? _VisualEffectChaining)?._effects ?? []
+        return _styled { style in
+            for apply in effects { apply(&style) }
+        }
+    }
+
+    public func scrollTransition(topLeading: ScrollTransitionConfiguration, bottomTrailing: ScrollTransitionConfiguration, axis: Axis? = nil,
+                                 transition: @escaping (EmptyVisualEffect, ScrollTransitionPhase) -> some VisualEffect) -> some View {
+        scrollTransition(topLeading, axis: axis, transition: transition)
+    }
+}
+
+/// A timing curve over 0…1 (iOS 17), as scroll transitions take; the
+/// browser's transitions do not use it.
+public struct UnitCurve: Hashable, Sendable {
+    let name: String
+    public static let linear = UnitCurve(name: "linear")
+    public static let easeIn = UnitCurve(name: "easeIn")
+    public static let easeOut = UnitCurve(name: "easeOut")
+    public static let easeInOut = UnitCurve(name: "easeInOut")
+    public static let circularEaseIn = UnitCurve(name: "circularEaseIn")
+    public static let circularEaseOut = UnitCurve(name: "circularEaseOut")
+    public static let circularEaseInOut = UnitCurve(name: "circularEaseInOut")
+    public static func bezier(startControlPoint: UnitPoint, endControlPoint: UnitPoint) -> UnitCurve { UnitCurve(name: "bezier") }
+}

package/Sources/SwiftUI/API/Windows.swift

@@ -0,0 +1,25 @@
+// Scene windows: `@Environment(\.openWindow)`, `\.dismissWindow` and
+// `\.supportsMultipleWindows`. The page is the app's one window, so it
+// reports no support for more, opening a window does nothing, and dismissing
+// one does nothing either.
+
+/// Opens a window of a `WindowGroup`. Does nothing: the page is one window.
+public struct OpenWindowAction: Sendable {
+    @MainActor public func callAsFunction(id: String) {}
+    @MainActor public func callAsFunction<D: Decodable & Encodable & Hashable>(value: D) {}
+    @MainActor public func callAsFunction<D: Decodable & Encodable & Hashable>(id: String, value: D) {}
+}
+
+/// Dismisses a window. Does nothing: the page is one window.
+public struct DismissWindowAction: Sendable {
+    @MainActor public func callAsFunction() {}
+    @MainActor public func callAsFunction(id: String) {}
+    @MainActor public func callAsFunction<D: Decodable & Encodable & Hashable>(value: D) {}
+}
+
+extension EnvironmentValues {
+    public var openWindow: OpenWindowAction { OpenWindowAction() }
+    public var dismissWindow: DismissWindowAction { DismissWindowAction() }
+    /// False: the page is one window.
+    public var supportsMultipleWindows: Bool { false }
+}