@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/SwiftUI/Runtime/LazyRows.swift

@@ -0,0 +1,99 @@
+// Lazy rows. SwiftUI builds the rows of a `List` (or `Form`), and of a `LazyVStack` or
+// `LazyHStack`, as they scroll into view: a timeline of a thousand posts
+// mounts the few on screen. Building every row up front made long lists
+// expensive in the browser, in time (each row's body, its elements, the
+// page's layout of them) and in memory, which a phone's browser runs out of.
+//
+// Here a keyed group (`ForEach`, or a modifier spread over one) whose rows
+// are a lazy container's rows mounts its first rows only, followed by a
+// `lazyspacer` element standing for the rest. When the page sees the spacer
+// come near its scroll view's visible area it sends a `lazy` event, and the
+// group mounts the next rows (docs/ops-protocol.md, "Lazy rows"). Rows that
+// were built stay built, as on iOS a row's state survives scrolling away.
+//
+// The rows of a lazy container are its content seen through groups,
+// sections and views with a body of their own: `List { Section {
+// ForEach(...) } }` and `List { TimelineRows() }` are lazy, while a
+// `ForEach` inside a row's own `VStack` is part of that row and is built
+// with it.
+
+/// `List`, `Form`, `LazyVStack` and `LazyHStack`: their rows are built lazily.
+protocol _LazyRowsContainer: _TraitBearing {
+    var _lazyAxis: Axis { get }
+}
+
+enum _LazyRows {
+    /// Rows a group mounts before its spacer, and the rows each `lazy` event adds.
+    static let batch = 12
+}
+
+/// The key of a group's spacer among its rows' keys. Each batch's spacer is a
+/// new element (keyed by the rows before it), so the page watches it afresh:
+/// one still in view after a batch was built asks for the next.
+struct _LazySpacerKey: Hashable {
+    let built: Int
+}
+
+/// The rows of a lazy group that are not built yet (`lazyspacer` element).
+struct _LazyRowsSpacer {
+    let axis: Axis
+    let remaining: Int
+    let extend: @MainActor () -> Void
+}
+extension _LazyRowsSpacer: _PrimitiveView {}
+
+extension _LazyRowsSpacer: _HostView {
+    var _kind: String { "lazyspacer" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object([
+            "axis": .string(axis == .horizontal ? "horizontal" : "vertical"),
+            "remaining": .number(Double(remaining)),
+        ])
+    }
+    var _handler: ((_JSON) -> Void)? {
+        let extend = extend
+        return { _ in MainActor.assumeIsolated { extend() } }
+    }
+}
+
+extension List: _LazyRowsContainer {
+    var _lazyAxis: Axis { .vertical }
+}
+/// A `Form` is a grouped list, on iOS as here.
+extension Form: _LazyRowsContainer {
+    var _lazyAxis: Axis { .vertical }
+}
+extension LazyVStack: _LazyRowsContainer {
+    var _lazyAxis: Axis { .vertical }
+}
+extension LazyHStack: _LazyRowsContainer {
+    var _lazyAxis: Axis { .horizontal }
+}
+
+// MARK: - Lazy menus
+
+// A `Menu`'s items and a `.contextMenu`'s are built when the menu opens, as
+// on iOS, and dropped when it closes. Until then the `menu` / `contextmenu`
+// element has its label (or content) only and `"deferred": true`; the page
+// sends `{"type": "menu", "id": n, "open": true}` when the viewer opens it,
+// shows the popover once the items arrive, and sends `"open": false` when it
+// closes (docs/ops-protocol.md, "Lazy menus"). A timeline's rows each carry
+// a menu or two: built eagerly they were half of Ice Cubes' page. Headless
+// runs, whose event scripts tap menu items directly, build them eagerly.
+
+/// `Menu` and `.contextMenu`: hosts whose items are built only while open.
+protocol _LazyMenuHost: _TraitBearing {
+    /// The label (a `Menu`'s, in its `ZStack`) or the content (a context menu's).
+    var _menuBase: any View { get }
+    var _menuItems: any View { get }
+}
+
+extension Menu: _LazyMenuHost {
+    var _menuBase: any View { ZStack { label } }
+    var _menuItems: any View { content }
+}
+
+extension _ContextMenuView: _LazyMenuHost {
+    var _menuBase: any View { content }
+    var _menuItems: any View { items }
+}

package/Sources/SwiftUI/Runtime/Measurements.swift

@@ -0,0 +1,140 @@
+// Views measured by the page for code that asks for a view's size
+// synchronously: `UIHostingController.sizeThatFits(in:)` (UIKit), which
+// packages call to size SwiftUI views before laying them out themselves
+// (WrappingHStack measures each item this way to break its lines). Swift has
+// no text metrics, so the answer comes from the page, one render late:
+//
+// 1. The first ask for a view finds no measurement: the answer is nil (the
+//    hosting controller reports a zero size) and the view joins the pending
+//    list.
+// 2. The render that asked also renders the pending views, off screen: as
+//    the children of a `layout` element of their own at the root, transparent
+//    and not hit-testable. The page measures a `layout` element's children
+//    (minimum, ideal and maximum size) and sends them in a `layout` event,
+//    as it does for a custom `Layout` (CustomLayout.swift).
+// 3. The event fills the cache and asks for a render in which no body is
+//    skipped as unchanged, so the code that measured runs again and finds
+//    the sizes (the library keeps them in objects of its own, which only a
+//    body that re-runs makes again).
+//
+// A view is known by its reflected description (`String(reflecting:)`): its
+// type and stored values, as SwiftUI's own diffing sees them. Content a body
+// reads from elsewhere (an observable object) is not part of it, so such a
+// view keeps its first measurement. Views are measured in the root's
+// environment, as Apple's hosting controller measures them in its own,
+// without the environment of the view that asks. A view whose description
+// changes on every render (one that stores a new UUID each time) would be
+// measured forever: after a few rounds in a row that only found new views,
+// measurements are still taken but no longer re-render.
+
+/// A view's sizes as the page measured them: for a zero, unspecified and infinite proposal.
+struct _MeasuredSizes: Equatable {
+    var min: CGSize
+    var ideal: CGSize
+    var max: CGSize
+
+    /// The size for `proposal`, as `LayoutSubview.sizeThatFits` answers it.
+    func fitting(_ proposal: ProposedViewSize) -> CGSize {
+        CGSize(
+            width: LayoutSubview.fit(proposal.width, min: min.width, ideal: ideal.width, max: max.width),
+            height: LayoutSubview.fit(proposal.height, min: min.height, ideal: ideal.height, max: max.height)
+        )
+    }
+}
+
+/// The page's measurements of views, by description, and the views waiting for one.
+@MainActor
+public final class _ViewMeasurements {
+    public static let shared = _ViewMeasurements()
+
+    private var sizes: [String: _MeasuredSizes] = [:]
+    /// Waiting views, in the order the measuring element renders them.
+    private(set) var pending: [(key: String, view: AnyView)] = []
+    private var pendingKeys: Set<String> = []
+    /// Rounds in a row in which measurements arrived and the render that
+    /// followed asked for new views again.
+    private var rounds = 0
+    static let maxRounds = 4
+    /// The runtime that rendered last: the one to render again.
+    weak var runtime: _Runtime?
+
+    init() {}
+
+    /// The size `view` takes for `proposal`, from the page's measurement;
+    /// nil until the page has measured it, and the view is then queued.
+    public func size<V: View>(of view: V, fitting proposal: ProposedViewSize) -> CGSize? {
+        let key = String(reflecting: view)
+        if let measured = sizes[key] { return measured.fitting(proposal) }
+        if pendingKeys.insert(key).inserted {
+            pending.append((key, AnyView(view)))
+            runtime?._scheduleRender()
+        }
+        return nil
+    }
+
+    /// Records the sizes of the pending views the page measured (`keys`, in order).
+    func record(_ measured: [(key: String, sizes: _MeasuredSizes)]) {
+        var added = false
+        for (key, value) in measured where pendingKeys.contains(key) {
+            sizes[key] = value
+            pendingKeys.remove(key)
+            added = true
+        }
+        guard added else { return }
+        pending.removeAll { sizes[$0.key] != nil }
+        rounds += 1
+        if rounds <= Self.maxRounds { runtime?._renderEverything() }
+    }
+
+    /// Called after a render: a render that asked for nothing new ends the rounds.
+    func renderFinished() {
+        if pending.isEmpty { rounds = 0 }
+    }
+
+    /// Forgets everything (tests).
+    func reset() {
+        sizes = [:]
+        pending = []
+        pendingKeys = []
+        rounds = 0
+    }
+}
+
+/// The off-screen element that has the pending views measured: a `layout`
+/// element whose children are the views, transparent and not hit-testable.
+struct _MeasuringView: View {
+    let entries: [(key: String, view: AnyView)]
+
+    var body: some View {
+        _MeasuringLayout(entries: entries)
+            .opacity(0)
+            .allowsHitTesting(false)
+    }
+}
+
+struct _MeasuringLayout {
+    let entries: [(key: String, view: AnyView)]
+}
+extension _MeasuringLayout: _PrimitiveView {}
+extension _MeasuringLayout: _HostView {
+    var _kind: String { "layout" }
+
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        .object(["proposal": .null, "size": .null, "frames": .null])
+    }
+
+    var _content: [any View] { entries.map(\.view) }
+
+    var _handler: ((_JSON) -> Void)? {
+        let keys = entries.map(\.key)
+        return { event in
+            // An event for another set of children (a render added views
+            // since) is left for the event about the current ones.
+            guard let (_, subviews) = _parseLayoutEvent(event), subviews.count == keys.count else { return }
+            let measured = zip(keys, subviews).map { key, subview in
+                (key: key, sizes: _MeasuredSizes(min: subview.min, ideal: subview.ideal, max: subview.max))
+            }
+            MainActor.assumeIsolated { _ViewMeasurements.shared.record(measured) }
+        }
+    }
+}

package/Sources/SwiftUI/Runtime/Ops.swift

@@ -12,6 +12,17 @@ public enum _Op: Equatable, Sendable {
     /// The app's `UserDefaults`, whole, after a change; the host stores them
     /// and hands them back at the next launch (`SB_DEFAULTS`).
     case defaults(_JSON)
+    /// Phase 13: something only the host can do (`fetch`, an `image` probe);
+    /// the host answers with a `response` event carrying the same id.
+    case request(id: Int, kind: String, params: _JSON)
+    /// Phase 18: one saved batch of a SwiftData store (an object with `store`,
+    /// `put` and `delete`); the host writes it to IndexedDB and hands the
+    /// store back at the next launch (`SB_SWIFTDATA`).
+    case swiftData(_JSON)
+    /// A bitmap's source (an image file, or a generator's pixels) under its
+    /// content key, sent once before the first element that draws it; the
+    /// host keeps it for the run (docs/ops-protocol.md, "Bitmaps and Core Image").
+    case imageData(_JSON)
 
     public var json: _JSON {
         switch self {
@@ -35,6 +46,20 @@ public enum _Op: Equatable, Sendable {
             return .object(["op": .string("event")])
         case .defaults(let values):
             return .object(["op": .string("defaults"), "values": values])
+        case .request(let id, let kind, let params):
+            return .object(["op": .string("request"), "id": .number(Double(id)), "kind": .string(kind), "params": params])
+        case .swiftData(let change):
+            if case .object(var fields) = change {
+                fields["op"] = .string("swiftdata")
+                return .object(fields)
+            }
+            return .object(["op": .string("swiftdata")])
+        case .imageData(let source):
+            if case .object(var fields) = source {
+                fields["op"] = .string("imagedata")
+                return .object(fields)
+            }
+            return .object(["op": .string("imagedata")])
         }
     }
 }
@@ -54,34 +79,55 @@ final class _HeadlessHost: _RenderHost {
     }
 }
 
-/// Keeps pending ops serialized as a JSON array in a stable heap buffer that
-/// the browser reads out of linear memory via the `sb_ops_*` exports.
+/// Keeps pending ops serialized as a JSON array in a heap buffer that the
+/// browser reads out of linear memory via the `sb_ops_*` exports, and their
+/// `.bytes` values beside it (`sb_bytes_*`) once the page has asked for them
+/// (else as base64). The ops are serialized when the page reads them, once
+/// per batch, not on every `apply`.
 @MainActor
 final class _BufferedHost: _RenderHost {
     static let shared = _BufferedHost()
 
     private(set) var pending: [_Op] = []
     private var buffer: UnsafeMutableBufferPointer<UInt8> = .allocate(capacity: 2)
-
-    init() {
-        reserialize()
-    }
+    private let outbox = _BytesOutbox()
+    private var stale = true
+    /// The page reads `.bytes` beside the JSON: it called `sb_bytes_count`.
+    private var bytesBeside = false
 
     func apply(_ ops: [_Op]) {
         pending.append(contentsOf: ops)
-        reserialize()
+        stale = true
     }
 
     func clear() {
         pending.removeAll()
-        reserialize()
+        stale = true
     }
 
-    var pointer: Int32 { Int32(Int(bitPattern: buffer.baseAddress)) }
-    var length: Int32 { Int32(buffer.count) }
+    var pointer: Int32 { serialize(); return Int32(Int(bitPattern: buffer.baseAddress)) }
+    var length: Int32 { serialize(); return Int32(buffer.count) }
+
+    /// The buffer's text (tests: `pointer` is a wasm32 address).
+    var text: String { serialize(); return String(decoding: buffer, as: UTF8.self) }
+
+    /// The `.bytes` values of the pending ops, by the `n` of their `{"$bytes": n}`.
+    /// The first read opts the page in: from then on the ops name them as `{"$bytes": n}`.
+    var bytes: [UnsafeMutableBufferPointer<UInt8>] {
+        if !bytesBeside {
+            bytesBeside = true
+            stale = true
+        }
+        serialize()
+        return outbox.items
+    }
 
-    private func reserialize() {
-        let bytes = Array(_JSON.array(pending.map(\.json)).serialized.utf8)
+    private func serialize() {
+        guard stale else { return }
+        stale = false
+        outbox.removeAll()
+        let json = _JSON.array(pending.map(\.json))
+        let bytes = Array((bytesBeside ? json.serialized(outbox: outbox) : json.serialized).utf8)
         buffer.deallocate()
         buffer = .allocate(capacity: bytes.count)
         _ = buffer.initialize(from: bytes)

package/Sources/SwiftUI/Runtime/Reconciler.swift

@@ -8,6 +8,11 @@ struct _Element {
     var key: AnyHashable?
     /// What makes this element a selectable or deletable `List` row (Phase 8).
     var row: _RowMark?
+    /// `accessibilityLabel` / `accessibilityIdentifier`, for event scripts only.
+    var accessibility: _AccessibilityMark?
+    /// `.layoutValue(key:value:)` above this element, by key type: what a
+    /// custom layout's subview reads (CustomLayout.swift).
+    var layoutValues: [ObjectIdentifier: Any]?
     /// Identity of this element value: a fresh token per produced element,
     /// kept by copies. Two elements with one token are the same subtree (a
     /// clean node's cached output), which the reconciler skips whole.
@@ -59,6 +64,8 @@ final class _Reconciler {
         var key: AnyHashable?
         /// The token of the element this was rendered from.
         var token: Int
+        /// Not sent to the host; headless event scripts match it.
+        var accessibility: _AccessibilityMark?
     }
 
     private(set) var roots: [Rendered] = []
@@ -152,6 +159,7 @@ final class _Reconciler {
         if previous.token == element.token { return previous }
         var rendered = previous
         rendered.token = element.token
+        rendered.accessibility = element.accessibility
         if rendered.props != element.props {
             ops.append(.update(id: rendered.id, props: element.props))
             rendered.props = element.props
@@ -170,7 +178,8 @@ final class _Reconciler {
         let children = element.children.enumerated().map { childIndex, child in
             create(child, parent: id, index: childIndex, ops: &ops)
         }
-        return Rendered(id: id, kind: element.kind, props: element.props, children: children, key: element.key, token: element.token)
+        return Rendered(id: id, kind: element.kind, props: element.props, children: children, key: element.key,
+                        token: element.token, accessibility: element.accessibility)
     }
 
     private func destroy(_ rendered: Rendered, ops: inout [_Op]) {