fix(zero-swift): keep rows on screen in place when rows added above push taller rows out of the page at the end (#102)

Amp-Thread-ID: https://ampcode.com/threads/T-0b362c1a-8212-40b1-91d0-00c96e61b977

Co-authored-by: Amp <amp@ampcode.com>

Author: tmm

.changeset/swift-virtual-end-space.md

@@ -0,0 +1,5 @@
+---
+'zero-swift': patch
+---
+
+`VirtualList` and `VirtualListView` no longer move the rows on screen when rows are added above them while the list rests at its end, past its first page. The added rows pushed the last rows out of the page. Their estimated height then took their place below the page, so when they were taller than estimated, the content got shorter under the scroll position and the view clamped it. Once the next page brought those rows back, everything on screen had shifted by the difference. The space below the page now keeps the height the rows were laid out at until the page reaches them again.

swift/Sources/ZeroVirtual/VirtualizerCore.swift

@@ -278,6 +278,13 @@ package final class VirtualizerCore<
   // which would stop a fling. Space short of the estimate is given back with
   // a scroll once the list rests.
   private var spaceAdjust = 0.0
+  // How far the space after the rows is off its estimate: rows that leave
+  // the window's end, as rows added above push them out of the page, keep
+  // the space they were laid out in until the window reaches them again.
+  // Their estimate in its place could be shorter, which shrinks the content
+  // under a list parked at its end: the view clamps the offset, and what's
+  // on screen jumps.
+  private var spaceAfterAdjust = 0.0
   // The list opened away from its start (a permalink, a restore) and hasn't
   // been there since: its indexes count from where it opened.
   private var openedAway: Bool
@@ -376,10 +383,39 @@ package final class VirtualizerCore<
       return
     }
     pendingReanchor = nil
-    let oldSpace = manual && host != nil ? snapshot.spaceBefore : nil
+    let oldSpace = manual && host != nil ? (snapshot.spaceBefore, snapshot.spaceAfter) : nil
     rows = new
     version += 1
-    if let oldSpace { carrySpace(from: old, oldSpace) }
+    if let oldSpace {
+      carrySpace(from: old, oldSpace.0)
+      carrySpaceAfter(from: old, oldSpace.1)
+    }
+  }
+
+  /// Keeps the space after the rows where it was through rows leaving the
+  /// window's end: the rows gone, as laid out, stand in it. Any other
+  /// change to the window's end goes back to the estimate.
+  private func carrySpaceAfter(from old: RowsSnapshot<Row, StartRow>, _ oldSpace: Double) {
+    let oldEnd = old.firstRowIndex + old.rowsLength
+    let newEnd = rows.firstRowIndex + rows.rowsLength
+    guard isListContextCurrent, !rows.atEnd, !old.rowsEmpty, !rows.rowsEmpty,
+      let oldLast = old.rowAt(oldEnd - 1).map(options.rowKey),
+      let newLast = rows.rowAt(newEnd - 1).map(options.rowKey)
+    else {
+      spaceAfterAdjust = 0
+      return
+    }
+    if oldLast == newLast { return }
+    guard
+      (0..<old.rowsLength).contains(where: {
+        old.rowAt(old.firstRowIndex + $0).map(options.rowKey) == newLast
+      }), let host, let from = frame(host, key: AnyHashable(newLast)),
+      let to = frame(host, key: AnyHashable(oldLast)), to.maxY > from.maxY
+    else {
+      spaceAfterAdjust = 0
+      return
+    }
+    spaceAfterAdjust = oldSpace + to.maxY - from.maxY - estimatedSpaceAfter
   }
 
   /// Keeps the space before the rows where it was through new rows: less
@@ -754,10 +790,16 @@ package final class VirtualizerCore<
     return max(paging.estimatedTotal, end)
   }
 
+  // The space after the rows, as their count estimates it.
+  private var estimatedSpaceAfter: Double {
+    if rows.atEnd { return 0 }
+    return Double(max(0, effectiveEstimatedTotal - rows.firstRowIndex - rows.rowsLength))
+      * rowEstimate
+  }
+
   private func buildSnapshot() -> VirtualSnapshot<Row, Key> {
     let total = effectiveEstimatedTotal
     let end = rows.firstRowIndex + rows.rowsLength
-    let after = rows.atEnd ? 0 : max(0, total - end)
     var items: [VirtualItem<Row, Key>] = []
     items.reserveCapacity(rows.rowsLength)
     for index in rows.firstRowIndex..<end {
@@ -769,7 +811,7 @@ package final class VirtualizerCore<
     // At the start, space left over from above stands before the first row
     // until the list rests.
     s.spaceBefore = max(0, estimatedSpaceBefore + spaceAdjust)
-    s.spaceAfter = Double(after) * rowEstimate
+    s.spaceAfter = rows.atEnd ? 0 : max(0, estimatedSpaceAfter + spaceAfterAdjust)
     s.complete = rows.complete
     s.rowsEmpty = rows.rowsEmpty
     s.permalinkNotFound = rows.permalinkNotFound

swift/Tests/ZeroVirtualTests/LayoutHostTests.swift

@@ -177,6 +177,33 @@ final class LayoutScrollView {
     #expect(view.rowTop(key) == top)
   }
 
+  @Test("rows added above, at the end of a list past its first page, don't move what's on screen")
+  func insertsAbovePushTallRowsOutOfThePage() {
+    // Parked at the end, rows added above push the last rows, on screen and
+    // taller than estimated, out of the page: the space after the rows
+    // keeps their height, not their estimate, or the content shrinks under
+    // the offset and the view clamps it.
+    let h = Harness(rowCount: 300) {
+      $0.anchoring = .manual
+      $0.minPageSize = 40
+    }
+    let view = LayoutScrollView(h)
+    for i in 290..<300 { view.heights["r\(i)"] = 60 }
+    view.settle()
+    // To the end, a page at a time.
+    for _ in 0..<20 {
+      view.userScroll(.infinity)
+      view.settle()
+    }
+    let key = h.core.firstVisibleItem()!.key
+    let top = view.rowTop(key)
+    h.data.insert(contentsOf: (0..<25).map { TestRow(id: "x\($0)") }, at: 280)
+    view.settle(holding: key)
+    h.scheduler.advance(by: 200)
+    view.settle(holding: key)
+    #expect(view.rowTop(key) == top)
+  }
+
   @Test("at the start, rows shorter than estimated above take their space with them, not at rest")
   func shrinkageAtTheStart() {
     let h = Harness(rowCount: 300) { $0.anchoring = .manual }