diff --git a/apps/web/src/components/chat/timelineViewport.ts b/apps/web/src/components/chat/timelineViewport.ts index 65e0f50f5ae9e..2649d2b6c89b7 100644 --- a/apps/web/src/components/chat/timelineViewport.ts +++ b/apps/web/src/components/chat/timelineViewport.ts @@ -1,5 +1,6 @@ import { readHtmlRenderContentHeight } from "@t3tools/shared/htmlRender"; +import { observeTimelineSelectionDrag } from "../../fork/timelineSelectionDrag"; import { isInSideChatPane } from "../../lib/sideChatPane"; import { registerCommands } from "../../shortcuts/dispatcher"; import { @@ -131,8 +132,10 @@ export function attachTimelineViewport( top: scrollNode.scrollTop, height: scrollNode.scrollHeight, }); - // Only a frame's input reaches the timeline unseen. Any other unexplained upward move is not - // the reader's: the browser clamps scrollTop when content briefly shrinks. + // A frame's input and a dragged text selection reach the timeline unseen. Any other + // unexplained upward move is not the reader's: the browser clamps scrollTop when content + // briefly shrinks. + const selectionDrag = observeTimelineSelectionDrag(scrollNode); const frameHasInput = () => scrollNode.querySelector("iframe:hover") !== null || (document.activeElement instanceof HTMLIFrameElement && @@ -144,7 +147,7 @@ export function attachTimelineViewport( height: scrollNode.scrollHeight, programmatic: programmaticHolds > 0, }) && - frameHasInput() && + (frameHasInput() || selectionDrag.isActive()) && // LegendList updates its scroll state on the next animation frame. resolveTimelineIsAtEnd({ contentLength: scrollNode.scrollHeight, @@ -202,6 +205,7 @@ export function attachTimelineViewport( }, dispose: () => { window.removeEventListener("message", handleFrameResize, true); + selectionDrag.dispose(); listeners.clear(); followReleasedListeners.clear(); scrollNode.removeEventListener("scroll", handleScroll); diff --git a/apps/web/src/fork/timelineSelectionDrag.browser.test.tsx b/apps/web/src/fork/timelineSelectionDrag.browser.test.tsx new file mode 100644 index 0000000000000..ce59a975f3107 --- /dev/null +++ b/apps/web/src/fork/timelineSelectionDrag.browser.test.tsx @@ -0,0 +1,114 @@ +import { describe, expect, it, vi } from "vite-plus/test"; +import { cdp } from "vite-plus/test/browser"; + +import { render } from "../../test/render"; +import { attachTimelineViewport } from "../components/chat/timelineViewport"; + +const words = "the reader selects a line of this answer to cite it in a reply ".repeat(40); + +describe("timeline selection drag", () => { + it("reports the autoscroll of a selection dragged to the top edge, not a clamp during a press", async () => { + await using screen = await render( +
+
+
+

{words}

+

+ {words} +

+
+
, + // A plain scroller; the viewport needs no routes. + { router: false }, + ); + const timeline = screen.getByTestId("timeline").element() as HTMLElement; + const last = screen.getByTestId("last").element() as HTMLElement; + const tail = screen.getByTestId("tail").element() as HTMLElement; + const above = screen.getByTestId("above").element() as HTMLElement; + const frame = window.frameElement?.getBoundingClientRect(); + const mouse = (type: "mousePressed" | "mouseMoved" | "mouseReleased", x: number, y: number) => + cdp().send("Input.dispatchMouseEvent", { + type, + x: x + (frame?.left ?? 0), + y: y + (frame?.top ?? 0), + button: "left", + buttons: type === "mouseReleased" ? 0 : 1, + clickCount: 1, + }); + const scrolled = () => + new Promise((resolve) => + timeline.addEventListener("scroll", () => resolve(), { once: true }), + ); + const toEnd = async () => { + const scroll = scrolled(); + timeline.scrollTop = timeline.scrollHeight; + await scroll; + }; + // Content that shrinks and grows back in one task clamps scrollTop with no input at all. + const clamp = async () => { + const scroll = scrolled(); + tail.style.height = "100px"; + void timeline.scrollTop; + tail.style.height = "900px"; + await scroll; + }; + // A line of the last paragraph in the scrolled-to-end view, below the autoscroll edge. + const textPoint = () => { + const box = timeline.getBoundingClientRect(); + return { x: box.left + 40, y: box.top + 60 }; + }; + + await using stack = new AsyncDisposableStack(); + await toEnd(); + const viewport = attachTimelineViewport(timeline); + stack.defer(() => viewport.dispose()); + stack.defer(async () => { + await mouse("mouseReleased", 0, 0); + document.getSelection()?.removeAllRanges(); + }); + const sources: string[] = []; + viewport.subscribe((navigation) => { + if (navigation.source === "scroll") sources.push(navigation.source); + }); + + const start = textPoint(); + // A still press near the top that layout moves above the timeline's edge is no drag. + const nearTop = { x: start.x, y: timeline.getBoundingClientRect().top + 10 }; + document.getSelection()!.selectAllChildren(last); + await mouse("mousePressed", nearTop.x, nearTop.y); + above.style.paddingTop = "160px"; + await clamp(); + await mouse("mouseReleased", nearTop.x, nearTop.y); + above.style.paddingTop = "120px"; + expect(sources).toEqual([]); + + await toEnd(); + await mouse("mousePressed", start.x, start.y); + await mouse("mouseMoved", start.x + 120, start.y + 60); + expect(document.getSelection()!.isCollapsed).toBe(false); + await clamp(); + await mouse("mouseReleased", start.x + 120, start.y + 60); + expect(sources).toEqual([]); + + await toEnd(); + const end = timeline.scrollTop; + // A press on selected text would start a drag of that text instead of a new selection. + document.getSelection()!.removeAllRanges(); + await mouse("mousePressed", start.x, start.y); + // Chromium autoscrolls while the pointer is just inside the top edge. + const edge = { x: start.x + 60, y: timeline.getBoundingClientRect().top + 5 }; + await mouse("mouseMoved", edge.x, edge.y); + await vi.waitFor(() => expect(timeline.scrollTop).toBeLessThan(end - 100), { timeout: 10_000 }); + await mouse("mouseReleased", edge.x, edge.y); + const dragScrolls = sources.length; + expect(dragScrolls).toBeGreaterThan(0); + + // The press ended, so a clamp with the selection still in place is no drag. + await toEnd(); + await clamp(); + expect(sources).toHaveLength(dragScrolls); + }); +}); diff --git a/apps/web/src/fork/timelineSelectionDrag.ts b/apps/web/src/fork/timelineSelectionDrag.ts new file mode 100644 index 0000000000000..b4f7fdce8289d --- /dev/null +++ b/apps/web/src/fork/timelineSelectionDrag.ts @@ -0,0 +1,62 @@ +// Chromium starts selection autoscroll this many device px inside a scroller's edge. Zoomed +// out, that is more CSS px; zoomed in, 20 CSS px still covers it. +const AUTOSCROLL_EDGE_DEVICE_PX = 20; + +/** + * Whether the browser is autoscrolling the timeline for a text selection the reader drags + * to its top edge. That scroll comes with no wheel, key or touch event. + */ +export function observeTimelineSelectionDrag(scrollNode: HTMLElement): { + readonly isActive: () => boolean; + readonly dispose: () => void; +} { + // Measured on each move, so layout moving under a still pointer is no drag. + let press: { readonly pointerId: number; readonly atEdge: boolean } | null = null; + const end = () => { + press = null; + window.removeEventListener("pointermove", handlePointerMove, true); + window.removeEventListener("pointerup", handlePointerEnd, true); + window.removeEventListener("pointercancel", handlePointerEnd, true); + }; + const handlePointerMove = (event: PointerEvent) => { + if (event.pointerId !== press?.pointerId) return; + // A chorded press releases the primary button with a move, not a pointerup. + if ((event.buttons & 1) === 0) end(); + else { + const edge = AUTOSCROLL_EDGE_DEVICE_PX / Math.min(1, window.devicePixelRatio); + const atEdge = event.clientY <= scrollNode.getBoundingClientRect().top + edge; + press = { pointerId: event.pointerId, atEdge }; + } + }; + const handlePointerEnd = (event: PointerEvent) => { + if (event.pointerId === press?.pointerId) end(); + }; + const handlePointerDown = (event: PointerEvent) => { + if (event.button !== 0 || !event.isPrimary) return; + end(); + press = { pointerId: event.pointerId, atEdge: false }; + // The drag goes on outside the timeline, and the release can land outside the window. + window.addEventListener("pointermove", handlePointerMove, { capture: true, passive: true }); + window.addEventListener("pointerup", handlePointerEnd, { capture: true, passive: true }); + window.addEventListener("pointercancel", handlePointerEnd, { capture: true, passive: true }); + }; + scrollNode.addEventListener("pointerdown", handlePointerDown, { passive: true }); + // A release in another window or tab reaches this page as a blur only. + window.addEventListener("blur", end); + return { + // The browser's clamp after content shrinks moves scrollTop during a press too, but the + // pointer is not dragging at the top edge then. + isActive: () => { + if (!press?.atEdge) return false; + const selection = scrollNode.ownerDocument.getSelection(); + return ( + selection !== null && !selection.isCollapsed && scrollNode.contains(selection.anchorNode) + ); + }, + dispose: () => { + end(); + scrollNode.removeEventListener("pointerdown", handlePointerDown); + window.removeEventListener("blur", end); + }, + }; +}