@swiftbrowser/swift 0.0.0-stage → 0.1.0

package/Sources/SwiftUI/Runtime/Reconciler.swift

@@ -0,0 +1,210 @@
+/// 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?
+    /// 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
+    }
+
+    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
+        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)
+    }
+
+    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
+}