[renovate-ce-paramount-engineering]

This PR contains the following updates:

Package	Change	Age	Confidence
@tanstack/virtual-core (source)	^3.17.8 → ^3.19.9

⚠️ Renovate does not enforce Minimum Release Age for bump, lockfileUpdate, or rollback updates, so these are raised without a Minimum Release Age check. You will need to manually validate the Minimum Release Age for these package(s).

---

Release Notes

TanStack/virtual (@​tanstack/virtual-core)

v3.19.9

Compare Source

Patch Changes

• #​1347 35ad56d - fix(virtual-core): stop a touch fling for a command issued during it on Android too

• #​1348 979c1b4 - Avoid ResizeObserver loop errors when a synchronous resize render mounts or unmounts rows. Measure new rows immediately, defer their observation until the next frame, and stop observing detached rows before delivery ends.

v3.19.8

Compare Source

Patch Changes

• #​1340 2343004 - fix(virtual-core): account for scrollMargin when deciding the viewport is at the end

v3.19.7

Compare Source

Patch Changes

• #​1335 887e971 - fix(virtual-core): cancel stale anchor work on explicit scroll

• #​1337 5d51f1d - fix(virtual-core): hold a clamped compensation retry while a touch owns the scroll

v3.19.6

Compare Source

Patch Changes

• #​1326 05bb4d3 - Measure the scroll viewport using client dimensions so borders and scrollbars do not obscure end-aligned items.

v3.19.5

Compare Source

Patch Changes

• #​1330 56b2a63 - fix(virtual-core): keep an instant scroll command clamped at a max the sizer committed outside a row resize

  Before an instant scroll command's write is reported, the browser can clamp it at a smaller scroll max that the sizer moves to without a row resize: an append or prepend, measure(), or a resize the sizer had not committed when the command was written. The virtualizer now also records the max at each commit, so such an event is read as its own clamped write and the command lands. A clamped write reported with isScrolling false is now written again too.

• #​1329 d2c7911 - fix(virtual-core): keep an instant scroll command when the browser clamps its write before rows grow back

  Rows measured right after an instant scrollToEnd() (or scrollToIndex) can first shrink the sizer below the written position and then grow it again in the same task. The browser clamps the write to the smaller max, and the scroll event reports that position. It was read as the user scrolling away, so the command was cancelled and the list stopped short of the end (a chat opened with estimateSize larger than its rows). The virtualizer now follows the scroll max through those measurements and reads such an event as its own clamped write, so the command retargets and lands at the end.

• #​1324 9c762fe - fix(virtual-core): scroll commands and corrections that stalled or were lost (#​1307)

  • On iOS 27 and later a scrollTop write no longer stops a fling but is overridden by it within a frame. A scrollToIndex, scrollToOffset or scrollToEnd issued during a fling now waits for the fling to end instead of being lost. The user taking over before then cancels it: a drag, a second flick, or a finger stopping the fling (iOS reports none of these with touch events while the fling runs). Corrections keep being held through the gesture as on every version.
  • scrollToOffset / scrollBy: a row above the viewport growing after the write's read-back moved the element off the fixed target, and the command kept reconciling until the 5s safety valve. The target now moves with the correction.
  • A prepend (anchorTo: 'end') before the read-back of a scroll command was anchored against the stale offset and written over the command. It is now left to reconcile, like a resize in that window.
  • A scroll event between the prepend's options change and the adapter's commit no longer loses the anchor (one blank frame when the element could not be written by commit time).
  • A command's write clamped by a sizer that shrank below it before the read-back no longer reads as a user scroll; the command reaches its fresh target.

• #​1332 6789f7a - fix(virtual-core): on iOS 27 and later, a scroll command issued during a fling takes effect at once

  A scrollToIndex, scrollToOffset or scrollToEnd issued during a fling waited for the fling to end, so a button outside the list (such as "jump to latest") did nothing until the list stopped. The command now stops the fling by hiding the scroll element's overflow for two frames, then restores the element's own inline value and writes. The user taking over before the write still cancels the command.

• #​1325 77cb05e - refactor(virtual-core): move the iOS touch gesture tracking into its own internal module. One fix along the way: changing the scroll element no longer carries over a pending iOS late-fling window, which could defer corrections on the new element for 150ms.

• #​1318 4a1a4fd - fix(virtual-core): on iOS, defer scroll corrections only for touch-driven scrolls (a finger down, or the momentum after it), so a programmatic landing like scrollToOffset compensates before paint instead of snapping later

• #​1319 3c61b6e - fix(virtual-core): hold a scroll correction the element cannot take instead of writing it (#​1287)

  A prepend's anchor delta or an above-viewport size change that lands while a scrollTop write is impossible (iOS during a touch gesture or its momentum tail, any WebKit while the element is rubber-banding past an edge) is now held: scrollOffset carries the corrected position, the rows and the total size are exposed shifted back by the held amount so every adapter keeps the reader's row where it is, and one write moves the element once a write is possible. Before, the write was discarded during the bounce on desktop Safari (the bounce stalled with the new rows and a blank top on screen), and on iOS the new rows showed through the bounce and snapped back at the flush.

• #​1324 9c762fe - refactor(virtual-core): simplify the scroll-correction state (no behaviour change)

  • A scroll event is classified once (spurious re-emit, our own write's read-back, a clamped read-back or echo, or external) before the handler acts on it, a scroll command waiting for the iOS 27 momentum tail is a phase of its own, and the iOS touch gesture tracks a single moved flag.
  • scrollAdjustments is deprecated: a correction is folded into scrollOffset at once, so it is always 0. Read scrollOffset alone; the getter stays.
  • One edge case changes: corrections made while enabled: false used to accumulate, and a correction made after re-enabling but before the next update was added on top of them. They are no longer carried over.

v3.19.4

Compare Source

Patch Changes

• #​1320 269e8ed - fix(virtual-core): with useAnimationFrameWithResizeObserver, request frames from the scroll element's window instead of the global one, and cancel frames still queued on cleanup, so a list rendered into another window does not stall while the opener is minimized or occluded

v3.19.3

Compare Source

Patch Changes

• #​1316 f211d3a - refactor(virtual-core): simplify the scroll-correction state: a scroll write is tracked until its read-back as one record, the iOS touch gesture as one record, the pending prepend anchor as a tagged record, and every scroll command starts through one entry point (no behaviour change, with two exceptions: a second touchend/touchcancel inside the post-touch grace window now restarts the window instead of leaving the first timer to end it early, and after the scroll element is swapped or the virtualizer disabled, a write to the old element is no longer matched to the new element's first scroll report). scrollAdjustments becomes a read-only getter with the same value (assigning to it is no longer supported).

v3.19.2

Compare Source

Patch Changes

• #​1314 3800fb3 - fix(virtual-core): treat iOS touchcancel like touchend so interrupted gestures cannot leave touch state stuck and keep scroll anchoring suppressed

• #​1311 cb510cb - refactor(virtual-core): track an in-flight scroll command's lifecycle as one phase instead of several flags (no behaviour change)

v3.19.1

Compare Source

Patch Changes

• #​1310 7aa34f6 - fix(virtual-core): let a user scroll end a non-smooth scrollToIndex before reconcile has seen it land, so a later measurement no longer pulls the user back to the old target

• #​1309 e7a0a92 - fix(virtual-core): leave resizes measured before a scroll command's write is read back to reconcile, so an upward scrollToIndex no longer jumps back and stalls until the safety valve, and build scrollBy on a just-written offset

v3.19.0

Compare Source

Minor Changes

• #​1302 92c697f - fix(virtual-core): keep lanes aligned after changing lanes with measureElement (#​1036)
  • overscan now counts whole rows when lanes > 1, so every lane renders (and measures) the same number of extra items. This renders more items than before: lanes: 4, overscan: 2 now adds 8 items on each side instead of 2. Range gains an optional lanes field that defaultRangeExtractor reads; a custom rangeExtractor gets row overscan only if it delegates to defaultRangeExtractor.
  • A ResizeObserver callback now measures all of its entries before notifying, so a synchronous re-render can no longer unmount part of a row before it is measured.

Patch Changes

• #​1305 28a2174 - fix(virtual-core): don't replay iOS-deferred size corrections after an in-flight scrollToIndex lands

v3.18.0

Compare Source

Minor Changes

• #​1300 43675bc - feat(virtual-core): add cancelScroll() to stop an in-flight scrollToIndex / scrollToOffset / scrollBy / scrollToEnd from correcting toward its target, so a user gesture can take over the viewport (#​1285)

Patch Changes

• #​1276 9df47a3 - Fix scrollToIndex(last, { align: 'end' }) overshooting the last item by paddingEnd; it now respects scrollPaddingEnd like other end-aligned items. To scroll to the very bottom including paddingEnd, use scrollToEnd().

• #​1293 c644f10 - fix(virtual-core): don't cache a 0 size when measureElement receives a node that isn't attached to the document yet

• #​1294 2a631f4 - Keep scrollToIndex reconciliation active until pending ResizeObserver measurements can update its target, including when useAnimationFrameWithResizeObserver is enabled. Respect an external scroll away from a reached target during this settling period.

v3.17.11

Compare Source

Patch Changes

• #​1284 06d1b6b - Read the current scroll offset when the debounced scroll-end fallback fires so measurement adjustments made since the last browser scroll event are not overwritten by stale state.

• #​1248 2c0a0ea - Keep a travelling smooth scrollToIndex alive when content is prepended. With anchorTo: 'end', the prepend anchor sync wrote scrollTop instantly, which cancelled the browser's smooth animation and left the scroll stranded partway; Chromium drops a smooth request re-issued right after such a cancel, so it could not be resumed. The sync is now skipped while a smooth programmatic scroll is still in flight, and the animation continues to its recomputed target. A smooth scroll that has already landed still receives the anchor sync.

v3.17.10

Compare Source

Patch Changes

• #​1272 ab3278c - Keep an end-pinned virtualizer following appended items when older items are trimmed in the same update and the item count does not increase. Recognize ordered, overlapping windows while preserving reading anchors for users who have scrolled away from the end.

  Preserve item keys in the lazy measurement cache so a stable getItemKey callback reading mutable data cannot change the identity of previously measured rows.

v3.17.9

Compare Source

Patch Changes

• #​1260 4a0adf3 - Recover the bottom pin when the browser clamps an end-anchored scroll compensation write. resizeItem compensates a size change by writing scrollTop before the consumer has committed the new total size, so when the grown item does not itself extend the scroll range the browser clamps the write to the old maximum and the viewport is left short of the end with no scroll event to correct it. Two cases hit this: paddingEnd > 0 with a growing last item, where the overflowing item only extends scrollHeight to its own end and the clamp lands exactly paddingEnd short (#​1258); and a row above the last one growing while the last row keeps its size, under directDomUpdates (#​1266). A compensation write whose target exceeds the scroll maximum at write time is now recorded as clamped and re-issued once the sizer has grown — right after notify for consumers that size the container synchronously in onChange, and from _willUpdate for consumers that size it during a render. The clamped read-back keeps the retry pending; any other scroll event cancels it, so a user reading history is never yanked.

---

Configuration

📅 Schedule: (in timezone America/Los_Angeles)

• Branch creation
  • "before 6am on monday"
• Automerge
  • At any time (no schedule defined)

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

---

• If you want to rebase/retry this PR, check this box

---

This PR has been generated by Renovate CE.