Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

fix(web): preserve reading position during pagination input (#1110)

Generbbb34276e093
diff --git a/src/web/src/components/community/messages/message-list.pending-scroll.dom.test.ts b/src/web/src/components/community/messages/message-list.pending-scroll.dom.test.ts
new file mode 100644
index 000000000..10ea7334d
--- /dev/null
+++ b/src/web/src/components/community/messages/message-list.pending-scroll.dom.test.ts
@@ -0,0 +1,174 @@
+import React from "react"
+import { afterEach, beforeEach, describe, expect, it, onTestFinished, vi } from "vitest"
+import { act, fireEvent, render } from "@/test/react-dom-harness"
+import { installMessageScrollFixture, restoreMessageScrollFixture, resize, runFrames, scrollFixture } from "@/test/message-scroll-fixture"
+import type { MessageRequestResult } from "@/lib/community/message-position"
+import { tid } from "@/lib/community/testids"
+import { MessageList } from "./message-list"
+
+const anchorState = vi.hoisted(() => ({
+ current: null as ReturnType<typeof import("@/hooks/community/use-scroll-anchor").useScrollAnchor> | null,
+ nativeWrites: [] as Array<{ offset: number; adjustments: number; behavior?: ScrollBehavior }>,
+}))
+
+vi.mock("@/hooks/community/use-scroll-anchor", async importOriginal => {
+ const original = await importOriginal<typeof import("@/hooks/community/use-scroll-anchor")>()
+ return { ...original, useScrollAnchor: (input: Parameters<typeof original.useScrollAnchor>[0]) => {
+ const anchor = original.useScrollAnchor(input)
+ anchorState.current = anchor
+ const scroll = anchor.virtualizer.options.scrollToFn
+ anchor.virtualizer.options.scrollToFn = (offset, options, native) => {
+ anchorState.nativeWrites.push({ offset, adjustments: options.adjustments ?? 0, behavior: options.behavior })
+ scroll(offset, options, native)
+ }
+ return anchor
+ } }
+})
+vi.mock("@/hooks/use-mobile", () => ({ useBreakpoint: () => "desktop" }))
+vi.mock("./message-row", () => ({ MessageRow: () => React.createElement("div") }))
+vi.mock("@/components/ui/number-ticker", () => ({ NumberTicker: ({ value }: { value: number }) => React.createElement("span", null, value) }))
+
+beforeEach(() => { anchorState.nativeWrites = []; installMessageScrollFixture() })
+afterEach(restoreMessageScrollFixture)
+
+function message(index: number) {
+ return { id: `m${index}`, type: "chat" as const, authorId: "alice", authorName: "Alice", content: "Message", createdAt: new Date(index * 1000).toISOString() }
+}
+
+function visibleMessage(root: HTMLElement) {
+ const viewport = root.getBoundingClientRect()
+ return Array.from(root.querySelectorAll<HTMLElement>("[data-msg-id]")).find(body => {
+ const rect = body.getBoundingClientRect()
+ return rect.bottom > viewport.top + 1 && rect.top < viewport.bottom - 1
+ })
+}
+
+function messageOffset(root: HTMLElement, id: string) {
+ const body = Array.from(root.querySelectorAll<HTMLElement>("[data-msg-id]")).find(node => node.dataset.msgId === id)
+ return body ? body.getBoundingClientRect().top - root.getBoundingClientRect().top : null
+}
+
+describe("MessageList continuous input through an accepted page", () => {
+ it.each([
+ ["older", "response-first", "edge"], ["older", "rows-first", "edge"],
+ ["newer", "response-first", "edge"], ["newer", "rows-first", "edge"],
+ ["older", "response-first", "away"], ["older", "rows-first", "away"],
+ ["newer", "response-first", "away"], ["newer", "rows-first", "away"],
+ ] as const)("keeps the current reading point for %s %s while scrolling at %s", async (direction, order, position) => {
+ let messages = Array.from({ length: 50 }, (_, index) => message(index + 40))
+ const before = {}, received = {}
+ let complete!: (result: MessageRequestResult) => void
+ const completed = new Promise<MessageRequestResult>(resolve => { complete = resolve })
+ const request = { accepted: true as const, completed }
+ const older = vi.fn(() => direction === "older" ? request : { accepted: false as const })
+ const newer = vi.fn(() => direction === "newer" ? request : { accepted: false as const })
+ const view = (window = before, fetching = false) => React.createElement(MessageList, {
+ channel: "general", messages, messageWindow: window, initialScrollReady: true,
+ initialPositionMessageId: "m65", positionDataState: "ready", hasMore: true, hasMoreNewer: true,
+ isFetchingOlder: fetching && direction === "older", isFetchingNewer: fetching && direction === "newer",
+ onLoadOlder: older, onLoadNewer: newer, onOpenThread: vi.fn(),
+ })
+ const renderer = render(view())
+ resize()
+ const root = renderer.getByTestId(tid.messageScroller)
+ const trace: Array<Record<string, unknown>> = []
+ let writeCount = 0
+ let nativeWriteCount = 0
+ const record = (phase: string, input: Record<string, unknown> = {}) => {
+ const viewport = root.getBoundingClientRect()
+ const native = anchorState.current!.virtualizer
+ const candidate = native.getVirtualItemForOffset(native.scrollOffset ?? 0)
+ trace.push({ phase, time: performance.now(), timerTime: Date.now(), itemCount: messages.length, scrollTop: root.scrollTop, scrollHeight: root.scrollHeight,
+ anchorTo: native.options.anchorTo, nativeOffset: native.scrollOffset, isScrolling: native.isScrolling,
+ candidate: candidate ? { key: candidate.key, index: candidate.index, start: candidate.start, end: candidate.end } : null,
+ paginationPending: anchorState.current!.paginationRequestPending,
+ visible: Array.from(root.querySelectorAll<HTMLElement>("[data-msg-id]")).flatMap(body => {
+ const rect = body.getBoundingClientRect()
+ return rect.bottom > viewport.top + 1 && rect.top < viewport.bottom - 1
+ ? [{ id: body.dataset.msgId, offset: rect.top - viewport.top }] : []
+ }), writes: scrollFixture.scrollCalls.slice(writeCount), nativeWrites: anchorState.nativeWrites.slice(nativeWriteCount), ...input })
+ writeCount = scrollFixture.scrollCalls.length
+ nativeWriteCount = anchorState.nativeWrites.length
+ }
+ onTestFinished(() => {
+ if (process.env.ALOOK_SCROLL_TRACE === "1") process.stdout.write(`MESSAGE_PAGE_INPUT_TRACE ${JSON.stringify({ direction, order, position, trace })}\n`)
+ })
+ record("initial-ready")
+ expect(root.querySelector('[data-read-position-ready="true"]')).not.toBeNull()
+ expect(older).not.toHaveBeenCalled()
+ expect(newer).not.toHaveBeenCalled()
+ const edge = direction === "older" ? 0 : root.scrollHeight - root.clientHeight
+ fireEvent.wheel(root, { deltaY: edge - root.scrollTop })
+ act(() => root.scrollTo({ top: edge }))
+ resize(0)
+ runFrames(1)
+ const load = direction === "older" ? older : newer
+ expect(load).toHaveBeenCalledOnce()
+ record("accepted-page")
+ renderer.rerender(view(before, true))
+ for (let step = 1; step <= 3; step++) {
+ const delta = (direction === "older" ? -1 : 1) * (position === "edge" ? 30 : -120)
+ const previous = root.scrollTop
+ const max = Math.max(0, root.scrollHeight - root.clientHeight)
+ const offset = Math.max(0, Math.min(previous + delta, max))
+ fireEvent.wheel(root, { deltaY: delta })
+ act(() => root.scrollTo({ top: offset }))
+ expect((root.scrollTop - previous) * delta).toBeGreaterThanOrEqual(0)
+ expect(root.scrollTop).toBeCloseTo(offset, 0)
+ runFrames(1)
+ record(`pending-input-${step}`, { wheelDelta: delta, requestedTop: offset })
+ if (position === "edge") expect(direction === "older" ? root.scrollTop : root.scrollHeight - root.clientHeight - root.scrollTop).toBeLessThanOrEqual(1)
+ }
+ const body = visibleMessage(root)
+ expect(body).toBeDefined()
+ const readingId = body!.dataset.msgId!
+ const currentOffset = messageOffset(root, readingId)!
+ record("before-response", { readingId, readingOffset: currentOffset })
+ const publishRows = () => {
+ messages = direction === "older"
+ ? [...Array.from({ length: 39 }, (_, index) => message(index + 1)), ...messages]
+ : [...messages, ...Array.from({ length: 39 }, (_, index) => message(index + 90))]
+ }
+ if (order === "rows-first") {
+ publishRows()
+ renderer.rerender(view(before, true))
+ resize(0)
+ runFrames(1)
+ record("rows-before-receipt")
+ expect(messageOffset(root, readingId), `${direction}/${position}: rows commit before receipt preserves the reading body`).toBeCloseTo(currentOffset, 0)
+ }
+ await act(async () => { complete({ status: "success", window: received }) })
+ record("receipt-completed")
+ if (order === "response-first") publishRows()
+ renderer.rerender(view(received))
+ resize(0)
+ runFrames(1)
+ record("response-and-first-measurement")
+ const afterResponse = messageOffset(root, readingId)
+ expect(afterResponse, `${direction}/${order}/${position}: current reading row ${readingId} remains mounted`).not.toBeNull()
+ expect(Math.abs(afterResponse! - currentOffset), `${direction}/${order}/${position}: response preserves current visible message`).toBeLessThanOrEqual(1)
+ let expectedOffset = currentOffset
+ for (let step = 1; step <= 3; step++) {
+ const delta = direction === "older" ? -20 : 20
+ const previous = root.scrollTop
+ const inputDelta = Math.max(0, Math.min(previous + delta, root.scrollHeight - root.clientHeight)) - previous
+ expectedOffset -= inputDelta
+ fireEvent.wheel(root, { deltaY: delta })
+ act(() => root.scrollTo({ top: previous + delta }))
+ runFrames(1)
+ record(`post-response-input-${step}`, { wheelDelta: delta, requestedTop: previous + delta })
+ resize(0)
+ runFrames(1)
+ record(`post-input-measurement-${step}`)
+ const afterInput = messageOffset(root, readingId)
+ expect(afterInput).not.toBeNull()
+ expect(Math.abs(afterInput! - expectedOffset)).toBeLessThanOrEqual(1)
+ }
+ const settled = root.scrollTop
+ runFrames(12)
+ resize(0)
+ record("final-quiet-control")
+ expect(root.scrollTop).toBeCloseTo(settled, 0)
+ expect(load).toHaveBeenCalledOnce()
+ })
+})
diff --git a/src/web/src/hooks/community/use-scroll-anchor.ts b/src/web/src/hooks/community/use-scroll-anchor.ts
index 660de82a0..255408be4 100644
--- a/src/web/src/hooks/community/use-scroll-anchor.ts
+++ b/src/web/src/hooks/community/use-scroll-anchor.ts
@@ -1,7 +1,7 @@
import { beginPositionObservation, type PositionDecision, type PositionReason } from "@/lib/observability/position"
import { useAtom, useCreateAtom } from "@tanstack/react-store";
import { useCallback, useLayoutEffect, useRef, useState } from "react"
-import { elementScroll, measureElement, useVirtualizer, type ReactVirtualizer } from "@tanstack/react-virtual"
+import { defaultRangeExtractor, elementScroll, measureElement, useVirtualizer, type ReactVirtualizer } from "@tanstack/react-virtual"
import { COMMUNITY_VIRTUALIZER_REACT_OPTIONS, type VirtualRowsLayoutSnapshot } from "./virtualizer-react-options"
import { estimateRowHeight, computeBelowCount, type FlatItem } from "@/lib/community/message-list-items"
import { MESSAGE_RAIL_TAIL_PADDING_END_PX } from "@/lib/community/conversation-layout"
@@ -291,17 +291,19 @@ export function useScrollAnchor({
const observation = positionObservationRef.current
observation?.finish(reason, observation.decision)
}, [])
- const claimPosition = useCallback((kind: Kind) => {
+ const claimPosition = useCallback((kind: Kind, preservePage = false) => {
if (kind === "target" || kind === "present") lateNewRef.current.allowed = false
const owner = positionOwnerRef.current
virtualizerRef.current?.cancelScroll()
clearMeasurementAnchor()
scrollPaddingStartRef.current = 0
- paginationRef.current = null
+ if (!preservePage) paginationRef.current = null
observePageBody()
- setPaginationDirection(null)
+ setPaginationDirection(paginationRef.current?.direction ?? null)
finishPosition("superseded")
owner.epoch += 1
+ const anchor = paginationRef.current?.anchor
+ if (anchor) anchor.epoch = owner.epoch
beginPosition(kind)
setOwnerKind(kind)
cancelFrame()
@@ -322,7 +324,22 @@ export function useScrollAnchor({
? targetIntentRef.current : null
const wasReadable = positionKind.get() === "idle" && readReady.get()
finishPosition(reason)
- claimPosition("idle")
+ const page = paginationRef.current
+ const native = virtualizerRef.current
+ const root = scrollRef.current
+ const measurement = measurementAnchorRef.current
+ const row = measurement ? native?.getVirtualItems().find(item => item.key === measurement.key) : undefined
+ const keepMeasurement = !!(userHandover && positionKind.get() === "idle" && page?.phase === "settling"
+ && measurement?.epoch === positionOwnerRef.current.epoch && row && root
+ && row.end > root.scrollTop && row.start < root.scrollTop + root.clientHeight)
+ const preservePage = userHandover && positionKind.get() === "idle" && page !== null && (page.phase !== "settling" || keepMeasurement)
+ if (preservePage && page.anchor && !keepMeasurement && currentItemsRef.current.find(item => item.kind === "message")?.key !== page.anchor.firstKey) page.anchor = undefined
+ if (keepMeasurement && page) page.restoringBody = false
+ claimPosition("idle", preservePage)
+ if (keepMeasurement && measurement && native) {
+ measurementAnchorRef.current = { key: measurement.key, epoch: positionOwnerRef.current.epoch }
+ native.shouldAdjustScrollPositionOnItemSizeChange = adjustAnchoredMeasurement
+ }
if (userHandover && wasReadable) setReadPositionReady(true)
retireInitialPosition()
positionedTargetRef.current = targetIntentRef.current
@@ -333,7 +350,7 @@ export function useScrollAnchor({
}
settlePresentation(outcome)
scheduleGeometryRef.current()
- }, [claimPosition, finishPosition, positionKind, readReady, retireInitialPosition, setReadPositionReady, settlePresentation])
+ }, [adjustAnchoredMeasurement, claimPosition, finishPosition, positionKind, readReady, retireInitialPosition, setReadPositionReady, settlePresentation])
const readPageMessageGeometry = useCallback((key: string): { viewportOffset: number; bodyInset: number } | null => {
const root = scrollRef.current
const native = virtualizerRef.current
@@ -408,6 +425,13 @@ export function useScrollAnchor({
: Math.round(entry?.borderBoxSize?.[0]?.blockSize ?? rect.height)
},
getItemKey,
+ rangeExtractor: range => {
+ const indexes = defaultRangeExtractor(range)
+ const anchor = paginationRef.current?.anchor
+ const index = anchor?.epoch === positionOwnerRef.current.epoch && positionKind.get() === "idle"
+ ? items.findIndex(item => item.key === anchor.key) : -1
+ return index < 0 || indexes.includes(index) ? indexes : [...indexes, index].sort((a, b) => a - b)
+ },
scrollPaddingStart: scrollPaddingStartRef.current,
anchorTo: !entryChanged && ownerKind === "idle" && !awaitingTarget && !pendingLocalSubmit && !pendingLateNew
&& (paginationDirection !== null || (readPositionReady && (nativeOriginKey === null || nativeOriginKey !== items[0]?.key))) ? "end" : "start",
@@ -780,11 +804,15 @@ export function useScrollAnchor({
if (context.dataState === "empty" || context.dataState === "error") return finish()
if (page.receipt) {
const result = page.receipt.result
- if (!result) return false
- if (result.status !== "success" || result.window === page.receipt.before
- || context.messageWindow !== result.window && context.messageWindow !== page.receipt.before) return finish()
- if (context.messageWindow !== result.window || context.dataState === "pending"
- || currentItemsRef.current === page.receipt.beforeItems) return false
+ if (!result) {
+ if (context.messageWindow !== page.receipt.before || context.dataState === "pending"
+ || currentItemsRef.current === page.receipt.beforeItems) return false
+ } else {
+ if (result.status !== "success" || result.window === page.receipt.before
+ || context.messageWindow !== result.window && context.messageWindow !== page.receipt.before) return finish()
+ if (context.messageWindow !== result.window || context.dataState === "pending"
+ || currentItemsRef.current === page.receipt.beforeItems) return false
+ }
} else if (page.phase !== "settling") {
const fetching = page.direction === "older" ? context.isFetchingOlder : context.isFetchingNewer
if (fetching) { page.phase = "fetching"; return false }
@@ -823,7 +851,7 @@ export function useScrollAnchor({
const body = readPageMessageGeometry(page.anchor.key)
if (!body || Math.abs(body.viewportOffset - page.anchor.viewportOffset) > 1) return false
}
- if (native.isScrolling) return false
+ if (native.isScrolling || page.receipt && !page.receipt.result) return false
return finish()
}, [adjustAnchoredMeasurement, clearMeasurementAnchor, hasCommittedRows, holdNativeOrigin, observePageBody, positionKind, readGeometry, readPageMessageGeometry, setPaginationDirection])