@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/Runtime/Ops.swift

@@ -0,0 +1,152 @@
+/// One instruction for a renderer. See docs/ops-protocol.md.
+public enum _Op: Equatable, Sendable {
+    case create(id: Int, kind: String, props: _JSON)
+    case update(id: Int, props: _JSON)
+    case insert(parent: Int, id: Int, index: Int)
+    case remove(id: Int)
+    /// End of a render pass, optionally animated (`withAnimation`).
+    case commit(animation: _JSON? = nil)
+    /// Headless mode only: echoes a replayed event (an object with at least
+    /// `type`) before its ops.
+    case event(_JSON)
+    /// 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 {
+        case .create(let id, let kind, let props):
+            return .object(["op": .string("create"), "id": .number(Double(id)), "kind": .string(kind), "props": props])
+        case .update(let id, let props):
+            return .object(["op": .string("update"), "id": .number(Double(id)), "props": props])
+        case .insert(let parent, let id, let index):
+            return .object(["op": .string("insert"), "parent": .number(Double(parent)),
+                     "id": .number(Double(id)), "index": .number(Double(index))])
+        case .remove(let id):
+            return .object(["op": .string("remove"), "id": .number(Double(id))])
+        case .commit(let animation):
+            if let animation { return .object(["op": .string("commit"), "animation": animation]) }
+            return .object(["op": .string("commit")])
+        case .event(let event):
+            if case .object(var fields) = event {
+                fields["op"] = .string("event")
+                return .object(fields)
+            }
+            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")])
+        }
+    }
+}
+
+/// Where ops go. The browser build buffers them for JavaScript; headless mode
+/// prints them; tests record them.
+@MainActor
+public protocol _RenderHost: AnyObject {
+    func apply(_ ops: [_Op])
+}
+
+/// Prints one op per line (JSON Lines).
+@MainActor
+final class _HeadlessHost: _RenderHost {
+    func apply(_ ops: [_Op]) {
+        for op in ops { print(op.json.serialized) }
+    }
+}
+
+/// 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)
+    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)
+        stale = true
+    }
+
+    func clear() {
+        pending.removeAll()
+        stale = true
+    }
+
+    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 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)
+    }
+}
+
+/// Holds the serialized state snapshot for the `sb_state_*` exports.
+@MainActor
+final class _StateBuffer {
+    static let shared = _StateBuffer()
+    private var buffer: UnsafeMutableBufferPointer<UInt8> = .allocate(capacity: 0)
+
+    func refresh(with json: _JSON) {
+        let bytes = Array(json.serialized.utf8)
+        buffer.deallocate()
+        buffer = .allocate(capacity: bytes.count)
+        _ = buffer.initialize(from: bytes)
+    }
+
+    var pointer: Int32 { Int32(Int(bitPattern: buffer.baseAddress)) }
+    var length: Int32 { Int32(buffer.count) }
+}

package/Sources/SwiftUI/Runtime/Reconciler.swift

@@ -0,0 +1,219 @@
+/// A node of the element tree produced from the mounted view tree each pass.
+struct _Element {
+    var kind: String
+    var props: _JSON
+    var children: [_Element]
+    var handler: ((_JSON) -> Void)?
+    /// Identity for keyed children (`ForEach`); unkeyed elements match by position.
+    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.
+    var token: Int = _Element.nextToken()
+
+    nonisolated(unsafe) private static var tokenCounter = 0
+    static func nextToken() -> Int {
+        tokenCounter += 1
+        return tokenCounter
+    }
+}
+
+/// Row metadata the runtime attaches while producing elements and consumes
+/// when it emits a `list`: a `.tag` (or a `ForEach` id, the implicit tag), a
+/// `NavigationLink(value:)`'s value and handler, and the `onDelete` of the
+/// row's `ForEach`.
+struct _RowMark {
+    var tag: AnyHashable?
+    var linkValue: AnyHashable?
+    var linkHandler: ((_JSON) -> Void)?
+    var delete: (() -> Void)?
+    var deleteDisabled = false
+
+    var isEmpty: Bool { tag == nil && linkValue == nil && delete == nil && !deleteDisabled }
+
+    /// Fills what `self` lacks from an inner element's mark.
+    func merged(with inner: _RowMark) -> _RowMark {
+        var result = self
+        if result.tag == nil { result.tag = inner.tag }
+        if result.linkValue == nil {
+            result.linkValue = inner.linkValue
+            result.linkHandler = inner.linkHandler
+        }
+        if result.delete == nil { result.delete = inner.delete }
+        result.deleteDisabled = result.deleteDisabled || inner.deleteDisabled
+        return result
+    }
+}
+
+/// Diffs successive element trees and emits ops. Ids are assigned by position
+/// (or key) and kind: an element that keeps both keeps its id across passes.
+@MainActor
+final class _Reconciler {
+    struct Rendered {
+        var id: Int
+        var kind: String
+        var props: _JSON
+        var children: [Rendered]
+        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] = []
+    private var nextId = 1
+    private(set) var handlers: [Int: (_JSON) -> Void] = [:]
+
+    func update(with elements: [_Element], animation: _JSON? = nil) -> [_Op] {
+        var ops: [_Op] = []
+        roots = diff(parent: 0, old: roots, new: elements, ops: &ops)
+        ops.append(.commit(animation: animation))
+        return ops
+    }
+
+    private func diff(parent: Int, old: [Rendered], new: [_Element], ops: inout [_Op]) -> [Rendered] {
+        let keyed = new.contains { $0.key != nil } || old.contains { $0.key != nil }
+        return keyed
+            ? diffKeyed(parent: parent, old: old, new: new, ops: &ops)
+            : diffPositional(parent: parent, old: old, new: new, ops: &ops)
+    }
+
+    private func diffPositional(parent: Int, old: [Rendered], new: [_Element], ops: inout [_Op]) -> [Rendered] {
+        var result: [Rendered] = []
+        result.reserveCapacity(new.count)
+
+        for (index, element) in new.enumerated() {
+            if index < old.count, old[index].kind == element.kind {
+                result.append(reuse(old[index], for: element, ops: &ops))
+            } else {
+                if index < old.count { destroy(old[index], ops: &ops) }
+                result.append(create(element, parent: parent, index: index, ops: &ops))
+            }
+        }
+
+        for stale in old.dropFirst(new.count) {
+            destroy(stale, ops: &ops)
+        }
+        return result
+    }
+
+    /// Keyed children: match by key, move what survives, create the rest.
+    /// Unkeyed children in a keyed list are matched by their position.
+    private func diffKeyed(parent: Int, old: [Rendered], new: [_Element], ops: inout [_Op]) -> [Rendered] {
+        func identity(_ key: AnyHashable?, _ index: Int) -> AnyHashable {
+            key ?? AnyHashable(_PositionKey(index: index))
+        }
+
+        var oldByIdentity: [AnyHashable: Rendered] = [:]
+        for (index, rendered) in old.enumerated() {
+            oldByIdentity[identity(rendered.key, index)] = rendered
+        }
+        let newIdentities = new.enumerated().map { identity($1.key, $0) }
+        let kept = Set(newIdentities.enumerated().compactMap { index, id in
+            oldByIdentity[id].map { $0.kind == new[index].kind ? id : nil } ?? nil
+        })
+
+        // 1. Remove everything that does not survive, so the parent's children
+        //    are exactly the kept old elements in their old order.
+        var pending: [AnyHashable] = []
+        for (index, rendered) in old.enumerated() {
+            let id = identity(rendered.key, index)
+            if kept.contains(id) { pending.append(id) } else { destroy(rendered, ops: &ops) }
+        }
+
+        // 2. Walk the new order; anything not already at the front is moved there.
+        var result: [Rendered] = []
+        result.reserveCapacity(new.count)
+        for (index, element) in new.enumerated() {
+            let id = newIdentities[index]
+            if kept.contains(id), let previous = oldByIdentity[id] {
+                if pending.first == id {
+                    pending.removeFirst()
+                } else {
+                    pending.removeAll { $0 == id }
+                    ops.append(.insert(parent: parent, id: previous.id, index: index))
+                }
+                var rendered = reuse(previous, for: element, ops: &ops)
+                rendered.key = element.key
+                result.append(rendered)
+            } else {
+                var rendered = create(element, parent: parent, index: index, ops: &ops)
+                rendered.key = element.key
+                result.append(rendered)
+            }
+        }
+        return result
+    }
+
+    private func reuse(_ previous: Rendered, for element: _Element, ops: inout [_Op]) -> Rendered {
+        // The same element value as last pass (a clean subtree's cached
+        // output): nothing below it changed, and its handlers are registered.
+        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
+        }
+        setHandler(element.handler, for: rendered.id)
+        rendered.children = diff(parent: rendered.id, old: rendered.children, new: element.children, ops: &ops)
+        return rendered
+    }
+
+    private func create(_ element: _Element, parent: Int, index: Int, ops: inout [_Op]) -> Rendered {
+        let id = nextId
+        nextId += 1
+        ops.append(.create(id: id, kind: element.kind, props: element.props))
+        ops.append(.insert(parent: parent, id: id, index: index))
+        setHandler(element.handler, for: id)
+        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, accessibility: element.accessibility)
+    }
+
+    private func destroy(_ rendered: Rendered, ops: inout [_Op]) {
+        ops.append(.remove(id: rendered.id))
+        forget(rendered)
+    }
+
+    private func forget(_ rendered: Rendered) {
+        handlers[rendered.id] = nil
+        for child in rendered.children { forget(child) }
+    }
+
+    private func setHandler(_ handler: ((_JSON) -> Void)?, for id: Int) {
+        if let handler {
+            handlers[id] = handler
+        } else {
+            handlers[id] = nil
+        }
+    }
+}
+
+private struct _PositionKey: Hashable {
+    let index: Int
+}
+
+/// Key given to the elements a keyed mounted node produces.
+struct _ElementKey: Hashable {
+    let base: AnyHashable
+    let index: Int
+}
+
+/// `_ElementKey` qualified by the keyed group's position among its siblings,
+/// so two `ForEach`es in one container never share a key.
+struct _GroupKey: Hashable {
+    let position: Int
+    let key: AnyHashable
+}