653 lines
22 KiB
TypeScript
653 lines
22 KiB
TypeScript
import { PassThrough } from 'stream'
|
|
|
|
import { Box, renderSync, ScrollBox, type ScrollBoxHandle, Text } from '@hermes/ink'
|
|
import React, { useLayoutEffect, useRef } from 'react'
|
|
import { describe, expect, it, vi } from 'vitest'
|
|
|
|
import { MAX_HISTORY } from '../config/limits.js'
|
|
import { pruneVirtualHeightCache, useVirtualHistory, virtualHistorySnapshotKey } from '../hooks/useVirtualHistory.js'
|
|
|
|
interface Item {
|
|
height: number
|
|
heightAfterResize?: number
|
|
key: string
|
|
text?: string
|
|
}
|
|
|
|
interface Exposed {
|
|
scroll: ScrollBoxHandle | null
|
|
virtualHistory: ReturnType<typeof useVirtualHistory>
|
|
}
|
|
|
|
const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
|
|
|
|
const makeStreams = () => {
|
|
const stdout = new PassThrough()
|
|
const stdin = new PassThrough()
|
|
const stderr = new PassThrough()
|
|
|
|
Object.assign(stdout, { columns: 80, isTTY: false, rows: 20 })
|
|
Object.assign(stdin, { isTTY: false })
|
|
Object.assign(stderr, { isTTY: false })
|
|
stdout.on('data', () => {})
|
|
|
|
return { stderr, stdin, stdout }
|
|
}
|
|
|
|
const mountedSpan = (items: readonly Item[], virtualHistory: ReturnType<typeof useVirtualHistory>) => {
|
|
let height = 0
|
|
|
|
for (let index = virtualHistory.start; index < virtualHistory.end; index++) {
|
|
height += items[index]?.height ?? 0
|
|
}
|
|
|
|
return { bottom: virtualHistory.topSpacer + height, top: virtualHistory.topSpacer }
|
|
}
|
|
|
|
const viewportIsMounted = (
|
|
items: readonly Item[],
|
|
virtualHistory: ReturnType<typeof useVirtualHistory>,
|
|
scroll: ScrollBoxHandle
|
|
) => {
|
|
const span = mountedSpan(items, virtualHistory)
|
|
const top = scroll.getScrollTop()
|
|
const bottom = top + scroll.getViewportHeight()
|
|
|
|
return top >= span.top && bottom <= span.bottom
|
|
}
|
|
|
|
const itemHeightForColumns = (item: Item | undefined, columns: number) =>
|
|
columns >= 80 ? (item?.heightAfterResize ?? item?.height ?? 1) : (item?.height ?? 1)
|
|
|
|
function Harness({
|
|
columns = 80,
|
|
expose,
|
|
height = 10,
|
|
generation = 0,
|
|
initialHeights,
|
|
items,
|
|
maxMounted = 16
|
|
}: {
|
|
columns?: number
|
|
expose: React.MutableRefObject<Exposed | null>
|
|
height?: number
|
|
generation?: number
|
|
initialHeights?: ReadonlyMap<string, number>
|
|
items: readonly Item[]
|
|
maxMounted?: number
|
|
}) {
|
|
const scrollRef = useRef<ScrollBoxHandle | null>(null)
|
|
|
|
const virtualHistory = useVirtualHistory(scrollRef, items, columns, {
|
|
coldStartCount: 16,
|
|
estimateHeight: index => itemHeightForColumns(items[index], columns),
|
|
generation,
|
|
initialHeights,
|
|
maxMounted,
|
|
overscan: 2
|
|
})
|
|
|
|
useLayoutEffect(() => {
|
|
expose.current = { scroll: scrollRef.current, virtualHistory }
|
|
})
|
|
|
|
return React.createElement(
|
|
ScrollBox,
|
|
{ flexDirection: 'column', height, ref: scrollRef, stickyScroll: true },
|
|
React.createElement(
|
|
Box,
|
|
{ flexDirection: 'column', width: '100%' },
|
|
virtualHistory.topSpacer > 0 ? React.createElement(Box, { height: virtualHistory.topSpacer }) : null,
|
|
...items.slice(virtualHistory.start, virtualHistory.end).map(item =>
|
|
React.createElement(
|
|
Box,
|
|
{
|
|
height: itemHeightForColumns(item, columns),
|
|
key: item.key,
|
|
ref: virtualHistory.measureRef(item.key)
|
|
},
|
|
React.createElement(Text, null, item.text ?? item.key)
|
|
)
|
|
),
|
|
virtualHistory.bottomSpacer > 0 ? React.createElement(Box, { height: virtualHistory.bottomSpacer }) : null
|
|
)
|
|
)
|
|
}
|
|
|
|
describe('useVirtualHistory offset cache reuse', () => {
|
|
it('prunes stable-session external height caches to active history keys', () => {
|
|
const cache = new Map([
|
|
['outgoing', 9],
|
|
['active', 3]
|
|
])
|
|
|
|
pruneVirtualHeightCache(cache, [{ key: 'active' }])
|
|
|
|
expect([...cache]).toEqual([['active', 3]])
|
|
})
|
|
|
|
it('includes viewport height in the external-store snapshot key', () => {
|
|
const base = {
|
|
getPendingDelta: () => 0,
|
|
getScrollTop: () => 20,
|
|
isSticky: () => false
|
|
}
|
|
|
|
const short = virtualHistorySnapshotKey({
|
|
...base,
|
|
getViewportHeight: () => 5
|
|
} as ScrollBoxHandle)
|
|
|
|
const tall = virtualHistorySnapshotKey({
|
|
...base,
|
|
getViewportHeight: () => 25
|
|
} as ScrollBoxHandle)
|
|
|
|
expect(short).not.toBe(tall)
|
|
})
|
|
|
|
it('remounts enough tail rows after the scroll viewport grows', async () => {
|
|
const items = Array.from({ length: 100 }, (_, index) => ({ height: 1, key: `item-${index}` }))
|
|
const expose = { current: null as Exposed | null }
|
|
const streams = makeStreams()
|
|
|
|
const instance = renderSync(React.createElement(Harness, { expose, height: 4, items, maxMounted: 80 }), {
|
|
patchConsole: false,
|
|
stderr: streams.stderr as NodeJS.WriteStream,
|
|
stdin: streams.stdin as NodeJS.ReadStream,
|
|
stdout: streams.stdout as NodeJS.WriteStream
|
|
})
|
|
|
|
try {
|
|
await delay(20)
|
|
instance.rerender(React.createElement(Harness, { expose, height: 9, items, maxMounted: 80 }))
|
|
await delay(80)
|
|
|
|
expect(viewportIsMounted(items, expose.current!.virtualHistory, expose.current!.scroll!)).toBe(true)
|
|
} finally {
|
|
instance.unmount()
|
|
instance.cleanup()
|
|
}
|
|
})
|
|
|
|
it('recomputes tail coverage when wrapped rows shrink after a width resize', async () => {
|
|
const items = Array.from({ length: 100 }, (_, index) => ({
|
|
height: 4,
|
|
heightAfterResize: 1,
|
|
key: `item-${index}`
|
|
}))
|
|
|
|
const expose = { current: null as Exposed | null }
|
|
const streams = makeStreams()
|
|
|
|
const instance = renderSync(
|
|
React.createElement(Harness, { columns: 40, expose, height: 10, items, maxMounted: 80 }),
|
|
{
|
|
patchConsole: false,
|
|
stderr: streams.stderr as NodeJS.WriteStream,
|
|
stdin: streams.stdin as NodeJS.ReadStream,
|
|
stdout: streams.stdout as NodeJS.WriteStream
|
|
}
|
|
)
|
|
|
|
try {
|
|
await delay(20)
|
|
instance.rerender(React.createElement(Harness, { columns: 80, expose, height: 10, items, maxMounted: 80 }))
|
|
await delay(80)
|
|
|
|
const resizedItems = items.map(item => ({ height: item.heightAfterResize!, key: item.key }))
|
|
|
|
expect(viewportIsMounted(resizedItems, expose.current!.virtualHistory, expose.current!.scroll!)).toBe(true)
|
|
} finally {
|
|
instance.unmount()
|
|
instance.cleanup()
|
|
}
|
|
})
|
|
|
|
it('keeps sticky scroll at the bottom when one tall tail row resizes', async () => {
|
|
const items = [{ height: 90, heightAfterResize: 50, key: 'tail' }]
|
|
const expose = { current: null as Exposed | null }
|
|
const streams = makeStreams()
|
|
|
|
const instance = renderSync(
|
|
React.createElement(Harness, { columns: 70, expose, height: 18, items, maxMounted: 80 }),
|
|
{
|
|
patchConsole: false,
|
|
stderr: streams.stderr as NodeJS.WriteStream,
|
|
stdin: streams.stdin as NodeJS.ReadStream,
|
|
stdout: streams.stdout as NodeJS.WriteStream
|
|
}
|
|
)
|
|
|
|
try {
|
|
await delay(20)
|
|
instance.rerender(React.createElement(Harness, { columns: 120, expose, height: 36, items, maxMounted: 80 }))
|
|
await delay(80)
|
|
|
|
const scroll = expose.current!.scroll!
|
|
|
|
expect(scroll.getScrollTop()).toBe(scroll.getScrollHeight() - scroll.getViewportHeight())
|
|
} finally {
|
|
instance.unmount()
|
|
instance.cleanup()
|
|
}
|
|
})
|
|
|
|
it('recomputes offsets after a mounted row height changes', async () => {
|
|
const tall = [
|
|
{ height: 6, key: 'a' },
|
|
{ height: 6, key: 'b' },
|
|
{ height: 6, key: 'c' }
|
|
]
|
|
|
|
const short = tall.map(item => ({ ...item, height: 2 }))
|
|
const expose = { current: null as Exposed | null }
|
|
const streams = makeStreams()
|
|
|
|
const instance = renderSync(React.createElement(Harness, { expose, items: tall }), {
|
|
patchConsole: false,
|
|
stderr: streams.stderr as NodeJS.WriteStream,
|
|
stdin: streams.stdin as NodeJS.ReadStream,
|
|
stdout: streams.stdout as NodeJS.WriteStream
|
|
})
|
|
|
|
try {
|
|
await delay(20)
|
|
expect(expose.current!.virtualHistory.offsets[tall.length]).toBe(18)
|
|
|
|
instance.rerender(React.createElement(Harness, { expose, items: short }))
|
|
await delay(40)
|
|
|
|
expect(expose.current!.virtualHistory.offsets[short.length]).toBe(6)
|
|
expect(expose.current!.virtualHistory.bottomSpacer).toBe(0)
|
|
} finally {
|
|
instance.unmount()
|
|
instance.cleanup()
|
|
}
|
|
})
|
|
|
|
it('adjusts the committed viewport without consuming pending scroll intent', async () => {
|
|
const items = Array.from({ length: 20 }, (_, index) => ({ height: 2, key: `item-${index}` }))
|
|
const expose = { current: null as Exposed | null }
|
|
const streams = makeStreams()
|
|
|
|
const instance = renderSync(React.createElement(Harness, { expose, items }), {
|
|
patchConsole: false,
|
|
stderr: streams.stderr as NodeJS.WriteStream,
|
|
stdin: streams.stdin as NodeJS.ReadStream,
|
|
stdout: streams.stdout as NodeJS.WriteStream
|
|
})
|
|
|
|
try {
|
|
await delay(20)
|
|
const scroll = expose.current!.scroll!
|
|
|
|
scroll.scrollTo(3)
|
|
scroll.scrollBy(2)
|
|
scroll.adjustScrollTop(4)
|
|
|
|
expect(scroll.getScrollTop()).toBe(7)
|
|
expect(scroll.getPendingDelta()).toBe(2)
|
|
expect(scroll.isSticky()).toBe(false)
|
|
} finally {
|
|
instance.unmount()
|
|
instance.cleanup()
|
|
}
|
|
})
|
|
|
|
it('keeps the tail clamp open while a manual non-sticky tail grows', async () => {
|
|
const before = Array.from({ length: 20 }, (_, index) => ({ height: 2, key: `item-${index}` }))
|
|
const after = before.map((item, index) => (index === before.length - 1 ? { ...item, height: 8 } : item))
|
|
const expose = { current: null as Exposed | null }
|
|
const streams = makeStreams()
|
|
const initialHeights = new Map(before.map(item => [item.key, item.height]))
|
|
|
|
const instance = renderSync(React.createElement(Harness, { expose, initialHeights, items: before }), {
|
|
patchConsole: false,
|
|
stderr: streams.stderr as NodeJS.WriteStream,
|
|
stdin: streams.stdin as NodeJS.ReadStream,
|
|
stdout: streams.stdout as NodeJS.WriteStream
|
|
})
|
|
|
|
try {
|
|
await delay(20)
|
|
const scroll = expose.current!.scroll!
|
|
const setClampBounds = vi.spyOn(scroll, 'setClampBounds')
|
|
|
|
scroll.scrollTo(28)
|
|
await delay(20)
|
|
instance.rerender(React.createElement(Harness, { expose, initialHeights, items: after }))
|
|
await delay(60)
|
|
|
|
expect(scroll.isSticky()).toBe(false)
|
|
expect(setClampBounds.mock.calls.some(([, max]) => max === Number.POSITIVE_INFINITY)).toBe(true)
|
|
|
|
scroll.scrollTo(36)
|
|
await delay(20)
|
|
expect(scroll.getScrollTop()).toBe(36)
|
|
} finally {
|
|
instance.unmount()
|
|
instance.cleanup()
|
|
}
|
|
})
|
|
|
|
it('quarantines invalid measured heights before cache and compensation', async () => {
|
|
const items = Array.from({ length: 20 }, (_, index) => ({ height: 2, key: `item-${index}` }))
|
|
const expose = { current: null as Exposed | null }
|
|
const streams = makeStreams()
|
|
const initialHeights = new Map(items.map(item => [item.key, item.height]))
|
|
|
|
const instance = renderSync(React.createElement(Harness, { expose, initialHeights, items }), {
|
|
patchConsole: false,
|
|
stderr: streams.stderr as NodeJS.WriteStream,
|
|
stdin: streams.stdin as NodeJS.ReadStream,
|
|
stdout: streams.stdout as NodeJS.WriteStream
|
|
})
|
|
|
|
try {
|
|
await delay(20)
|
|
const scroll = expose.current!.scroll!
|
|
|
|
scroll.scrollTo(5)
|
|
await delay(20)
|
|
const adjustScrollTop = vi.spyOn(scroll, 'adjustScrollTop')
|
|
const ref = expose.current!.virtualHistory.measureRef('item-1')
|
|
|
|
for (const height of [Number.NaN, Number.POSITIVE_INFINITY, -1, 1_000_000_000]) {
|
|
ref({ yogaNode: { getComputedHeight: () => height } })
|
|
ref(null)
|
|
}
|
|
|
|
expect(adjustScrollTop).not.toHaveBeenCalled()
|
|
expect(expose.current!.virtualHistory.offsets[items.length]).toBe(40)
|
|
expect(Number.isFinite(scroll.getScrollTop())).toBe(true)
|
|
} finally {
|
|
instance.unmount()
|
|
instance.cleanup()
|
|
}
|
|
})
|
|
|
|
it('preserves the visual anchor when a measured row above the viewport changes height', async () => {
|
|
const before = Array.from({ length: 20 }, (_, index) => ({ height: 2, key: `item-${index}` }))
|
|
const after = before.map((item, index) => (index === 0 ? { ...item, height: 5 } : item))
|
|
const expose = { current: null as Exposed | null }
|
|
const streams = makeStreams()
|
|
const initialHeights = new Map(before.map(item => [item.key, item.height]))
|
|
|
|
const instance = renderSync(React.createElement(Harness, { expose, initialHeights, items: before }), {
|
|
patchConsole: false,
|
|
stderr: streams.stderr as NodeJS.WriteStream,
|
|
stdin: streams.stdin as NodeJS.ReadStream,
|
|
stdout: streams.stdout as NodeJS.WriteStream
|
|
})
|
|
|
|
try {
|
|
await delay(20)
|
|
expose.current!.scroll!.scrollTo(3)
|
|
await delay(20)
|
|
|
|
instance.rerender(React.createElement(Harness, { expose, initialHeights, items: after }))
|
|
await delay(40)
|
|
|
|
expect(expose.current!.scroll!.getScrollTop()).toBe(6)
|
|
} finally {
|
|
instance.unmount()
|
|
instance.cleanup()
|
|
}
|
|
})
|
|
|
|
it('keeps a compensated near-tail viewport manual', async () => {
|
|
const before = Array.from({ length: 20 }, (_, index) => ({ height: 2, key: `item-${index}` }))
|
|
const after = before.map((item, index) => (index === 13 ? { ...item, height: 5 } : item))
|
|
const expose = { current: null as Exposed | null }
|
|
const streams = makeStreams()
|
|
const initialHeights = new Map(before.map(item => [item.key, item.height]))
|
|
|
|
const instance = renderSync(React.createElement(Harness, { expose, initialHeights, items: before }), {
|
|
patchConsole: false,
|
|
stderr: streams.stderr as NodeJS.WriteStream,
|
|
stdin: streams.stdin as NodeJS.ReadStream,
|
|
stdout: streams.stdout as NodeJS.WriteStream
|
|
})
|
|
|
|
try {
|
|
await delay(20)
|
|
const scroll = expose.current!.scroll!
|
|
|
|
scroll.scrollTo(29)
|
|
await delay(20)
|
|
instance.rerender(React.createElement(Harness, { expose, initialHeights, items: after }))
|
|
|
|
expect(scroll.getScrollTop()).toBe(32)
|
|
expect(scroll.isSticky()).toBe(false)
|
|
} finally {
|
|
instance.unmount()
|
|
instance.cleanup()
|
|
}
|
|
})
|
|
|
|
it('ignores stale unmount measurement from the previous width layout', async () => {
|
|
const items = Array.from({ length: 20 }, (_, index) => ({
|
|
height: 4,
|
|
heightAfterResize: index === 0 ? 5 : 2,
|
|
key: `item-${index}`
|
|
}))
|
|
|
|
const expose = { current: null as Exposed | null }
|
|
const streams = makeStreams()
|
|
const initialHeights = new Map(items.map(item => [item.key, item.height]))
|
|
|
|
const instance = renderSync(React.createElement(Harness, { columns: 40, expose, initialHeights, items }), {
|
|
patchConsole: false,
|
|
stderr: streams.stderr as NodeJS.WriteStream,
|
|
stdin: streams.stdin as NodeJS.ReadStream,
|
|
stdout: streams.stdout as NodeJS.WriteStream
|
|
})
|
|
|
|
try {
|
|
await delay(20)
|
|
const scroll = expose.current!.scroll!
|
|
|
|
scroll.scrollTo(0)
|
|
await delay(20)
|
|
scroll.scrollTo(5)
|
|
const adjustScrollTop = vi.spyOn(scroll, 'adjustScrollTop')
|
|
|
|
instance.rerender(React.createElement(Harness, { columns: 80, expose, initialHeights, items }))
|
|
await delay(40)
|
|
|
|
expect(adjustScrollTop).not.toHaveBeenCalled()
|
|
expect(scroll.getScrollTop()).toBe(5)
|
|
expect(scroll.isSticky()).toBe(false)
|
|
expect(expose.current!.virtualHistory.start).toBeGreaterThan(0)
|
|
expect(expose.current!.virtualHistory.offsets[1]).toBe(2)
|
|
expect(expose.current!.virtualHistory.offsets[items.length]).toBe(40)
|
|
} finally {
|
|
instance.unmount()
|
|
instance.cleanup()
|
|
}
|
|
})
|
|
|
|
it('does not let outgoing transcript refs compensate a new layout generation', async () => {
|
|
const outgoing = Array.from({ length: 20 }, (_, index) => ({ height: 2, key: `old-${index}` }))
|
|
const incoming = Array.from({ length: 20 }, (_, index) => ({ height: 2, key: `new-${index}` }))
|
|
const expose = { current: null as Exposed | null }
|
|
const streams = makeStreams()
|
|
const initialHeights = new Map(outgoing.map(item => [item.key, item.height]))
|
|
|
|
const instance = renderSync(React.createElement(Harness, { expose, initialHeights, items: outgoing }), {
|
|
patchConsole: false,
|
|
stderr: streams.stderr as NodeJS.WriteStream,
|
|
stdin: streams.stdin as NodeJS.ReadStream,
|
|
stdout: streams.stdout as NodeJS.WriteStream
|
|
})
|
|
|
|
try {
|
|
await delay(20)
|
|
const scroll = expose.current!.scroll!
|
|
|
|
scroll.scrollTo(5)
|
|
await delay(20)
|
|
const adjustScrollTop = vi.spyOn(scroll, 'adjustScrollTop')
|
|
|
|
const replacementCache = new Map<string, number>([
|
|
...outgoing.map(item => [item.key, item.key === 'old-1' ? 1 : item.height] as const),
|
|
...incoming.map(item => [item.key, item.height] as const)
|
|
])
|
|
|
|
instance.rerender(
|
|
React.createElement(Harness, {
|
|
expose,
|
|
generation: 1,
|
|
initialHeights: replacementCache,
|
|
items: incoming
|
|
})
|
|
)
|
|
await delay(40)
|
|
|
|
expect(adjustScrollTop).not.toHaveBeenCalled()
|
|
expect(scroll.getScrollTop()).toBe(5)
|
|
expect(expose.current!.virtualHistory.offsets[incoming.length]).toBe(40)
|
|
} finally {
|
|
instance.unmount()
|
|
instance.cleanup()
|
|
}
|
|
})
|
|
|
|
it('corrects and compensates a same-layout row measured at unmount', async () => {
|
|
const items = Array.from({ length: 20 }, (_, index) => ({ height: 2, key: `item-${index}` }))
|
|
const expose = { current: null as Exposed | null }
|
|
const streams = makeStreams()
|
|
const initialHeights = new Map(items.map(item => [item.key, item.height]))
|
|
|
|
const instance = renderSync(React.createElement(Harness, { expose, initialHeights, items }), {
|
|
patchConsole: false,
|
|
stderr: streams.stderr as NodeJS.WriteStream,
|
|
stdin: streams.stdin as NodeJS.ReadStream,
|
|
stdout: streams.stdout as NodeJS.WriteStream
|
|
})
|
|
|
|
try {
|
|
await delay(20)
|
|
const scroll = expose.current!.scroll!
|
|
|
|
scroll.scrollTo(0)
|
|
await delay(20)
|
|
scroll.scrollTo(5)
|
|
const adjustScrollTop = vi.spyOn(scroll, 'adjustScrollTop')
|
|
const staleHeights = new Map(initialHeights)
|
|
|
|
staleHeights.set(items[0]!.key, 1)
|
|
instance.rerender(React.createElement(Harness, { expose, initialHeights: staleHeights, items }))
|
|
await delay(40)
|
|
|
|
expect(adjustScrollTop).toHaveBeenCalledOnce()
|
|
expect(adjustScrollTop).toHaveBeenCalledWith(1)
|
|
expect(scroll.getScrollTop()).toBe(6)
|
|
expect(scroll.isSticky()).toBe(false)
|
|
expect(expose.current!.virtualHistory.start).toBeGreaterThan(0)
|
|
expect(expose.current!.virtualHistory.offsets[1]).toBe(2)
|
|
} finally {
|
|
instance.unmount()
|
|
instance.cleanup()
|
|
}
|
|
})
|
|
|
|
it('does not compensate for measured height changes in or below the viewport', async () => {
|
|
const before = Array.from({ length: 20 }, (_, index) => ({ height: 2, key: `item-${index}` }))
|
|
const visibleChanged = before.map((item, index) => (index === 1 ? { ...item, height: 5 } : item))
|
|
const belowChanged = visibleChanged.map((item, index) => (index === 8 ? { ...item, height: 5 } : item))
|
|
const expose = { current: null as Exposed | null }
|
|
const streams = makeStreams()
|
|
const initialHeights = new Map(before.map(item => [item.key, item.height]))
|
|
|
|
const instance = renderSync(React.createElement(Harness, { expose, initialHeights, items: before }), {
|
|
patchConsole: false,
|
|
stderr: streams.stderr as NodeJS.WriteStream,
|
|
stdin: streams.stdin as NodeJS.ReadStream,
|
|
stdout: streams.stdout as NodeJS.WriteStream
|
|
})
|
|
|
|
try {
|
|
await delay(20)
|
|
expose.current!.scroll!.scrollTo(3)
|
|
await delay(20)
|
|
|
|
instance.rerender(React.createElement(Harness, { expose, initialHeights, items: visibleChanged }))
|
|
await delay(40)
|
|
expect(expose.current!.scroll!.getScrollTop()).toBe(3)
|
|
|
|
instance.rerender(React.createElement(Harness, { expose, initialHeights, items: belowChanged }))
|
|
await delay(40)
|
|
expect(expose.current!.scroll!.getScrollTop()).toBe(3)
|
|
} finally {
|
|
instance.unmount()
|
|
instance.cleanup()
|
|
}
|
|
})
|
|
|
|
it('does not compensate measured heights while sticky at the live tail', async () => {
|
|
const before = Array.from({ length: 20 }, (_, index) => ({ height: 2, key: `item-${index}` }))
|
|
const after = before.map((item, index) => (index === 14 ? { ...item, height: 5 } : item))
|
|
const expose = { current: null as Exposed | null }
|
|
const streams = makeStreams()
|
|
const initialHeights = new Map(before.map(item => [item.key, item.height]))
|
|
|
|
const instance = renderSync(React.createElement(Harness, { expose, initialHeights, items: before }), {
|
|
patchConsole: false,
|
|
stderr: streams.stderr as NodeJS.WriteStream,
|
|
stdin: streams.stdin as NodeJS.ReadStream,
|
|
stdout: streams.stdout as NodeJS.WriteStream
|
|
})
|
|
|
|
try {
|
|
await delay(20)
|
|
const adjustScrollTop = vi.spyOn(expose.current!.scroll!, 'adjustScrollTop')
|
|
|
|
instance.rerender(React.createElement(Harness, { expose, initialHeights, items: after }))
|
|
await delay(40)
|
|
|
|
expect(adjustScrollTop).not.toHaveBeenCalled()
|
|
expect(expose.current!.scroll!.isSticky()).toBe(true)
|
|
} finally {
|
|
instance.unmount()
|
|
instance.cleanup()
|
|
}
|
|
})
|
|
|
|
it('ignores stale reused offset-array entries after the item count shrinks', async () => {
|
|
const beforeShrink = Array.from({ length: 1400 }, (_, index) => ({ height: 1, key: `old${index}` }))
|
|
const afterShrink = Array.from({ length: MAX_HISTORY }, (_, index) => ({ height: 7, key: `new${index}` }))
|
|
const expose = { current: null as Exposed | null }
|
|
const streams = makeStreams()
|
|
|
|
const instance = renderSync(React.createElement(Harness, { expose, items: beforeShrink }), {
|
|
patchConsole: false,
|
|
stderr: streams.stderr as NodeJS.WriteStream,
|
|
stdin: streams.stdin as NodeJS.ReadStream,
|
|
stdout: streams.stdout as NodeJS.WriteStream
|
|
})
|
|
|
|
try {
|
|
await delay(20)
|
|
instance.rerender(React.createElement(Harness, { expose, items: afterShrink }))
|
|
await delay(20)
|
|
|
|
const scroll = expose.current!.scroll!
|
|
const transcriptHeight = expose.current!.virtualHistory.offsets[afterShrink.length] ?? 0
|
|
|
|
expect(transcriptHeight).toBe(5600)
|
|
expect(scroll.getScrollTop()).toBe(transcriptHeight - scroll.getViewportHeight())
|
|
|
|
scroll.scrollBy(-1)
|
|
await delay(80)
|
|
|
|
expect(scroll.getPendingDelta()).toBe(0)
|
|
expect(viewportIsMounted(afterShrink, expose.current!.virtualHistory, scroll)).toBe(true)
|
|
} finally {
|
|
instance.unmount()
|
|
instance.cleanup()
|
|
}
|
|
})
|
|
})
|