Skip to content
Merged
Show file tree
Hide file tree
Changes from 1 commit
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
131 changes: 131 additions & 0 deletions packages/app/e2e/session/session-scroll-position.spec.ts
Original file line number Diff line number Diff line change
Expand Up @@ -15,6 +15,10 @@ type TimelineMetrics = {
distanceFromBottom: number
}

type TimelineScrollSample = TimelineMetrics & {
url: string
}

function timelineMetrics(page: Page) {
return page.evaluate((turnListSelector) => {
const list = document.querySelector(turnListSelector)
Expand Down Expand Up @@ -46,6 +50,83 @@ async function scrollTimelineToBottom(page: Page) {
expect(found, "session timeline viewport should exist").toBe(true)
}

async function installTimelineScrollProbe(page: Page) {
await page.evaluate(
({ maxSamples, turnListSelector }) => {
const read = () => {
const list = document.querySelector(turnListSelector)
const viewport = list?.closest(".scroll-view__viewport")
if (!(viewport instanceof HTMLElement)) return null
Comment thread
Astro-Han marked this conversation as resolved.
Resolved
return {
url: window.location.href,
top: viewport.scrollTop,
height: viewport.scrollHeight,
client: viewport.clientHeight,
distanceFromBottom: viewport.scrollHeight - viewport.clientHeight - viewport.scrollTop,
}
}
const changed = (a: NonNullable<ReturnType<typeof read>>, b: NonNullable<ReturnType<typeof read>>) =>
a.url !== b.url ||
a.top !== b.top ||
a.height !== b.height ||
a.client !== b.client ||
a.distanceFromBottom !== b.distanceFromBottom
const samples: NonNullable<ReturnType<typeof read>>[] = []
const push = () => {
const next = read()
if (!next) return
const prev = samples[samples.length - 1]
if (prev && !changed(prev, next)) return
if (samples.length < maxSamples) samples.push(next)
}
push()
let frame = requestAnimationFrame(function tick() {
push()
frame = requestAnimationFrame(tick)
})
const observer = new MutationObserver(push)
observer.observe(document.body, { childList: true, subtree: true })
const first = read()
const viewport = first
? document.querySelector(turnListSelector)?.closest(".scroll-view__viewport")
: undefined
if (viewport instanceof HTMLElement) viewport.addEventListener("scroll", push, { passive: true })
const win = window as typeof window & {
__opencode_e2e?: Record<string, unknown> & {
timelineScrollProbe?: { stop: () => unknown }
}
}
win.__opencode_e2e = {
...win.__opencode_e2e,
timelineScrollProbe: {
Comment thread
Astro-Han marked this conversation as resolved.
Resolved
stop() {
cancelAnimationFrame(frame)
observer.disconnect()
if (viewport instanceof HTMLElement) viewport.removeEventListener("scroll", push)
push()
delete win.__opencode_e2e?.timelineScrollProbe
return samples
},
},
}
},
{ maxSamples: 256, turnListSelector: sessionTurnListSelector },
)
}

async function stopTimelineScrollProbe(page: Page) {
return page.evaluate(() => {
const win = window as typeof window & {
__opencode_e2e?: {
timelineScrollProbe?: { stop: () => unknown }
}
}
const probe = win.__opencode_e2e?.timelineScrollProbe
if (!probe) throw new Error("timeline scroll probe was not installed")
return probe.stop()
}) as Promise<TimelineScrollSample[]>
}

async function sendVisiblePrompt(input: { page: Page; text: string }) {
const prompt = input.page.locator(promptSelector)
await expect(prompt).toBeVisible()
Expand Down Expand Up @@ -169,6 +250,56 @@ test("keeps the latest turn in view when sending from an old message hash", asyn
})
})

test("does not jump to the top after sending from an old message hash", async ({ page, project }) => {
test.setTimeout(120_000)

await project.open()
const sdk = project.sdk

await withSession(sdk, `e2e send top guard ${Date.now()}`, async (session) => {
project.trackSession(session.id)

await seedSessionTurns({ sdk, sessionID: session.id, count: 18 })

await project.gotoSession(session.id)
await expect(page.locator(sessionMessageItemSelector)).toHaveCount(INITIAL_SESSION_WINDOW_MESSAGES, {
timeout: 30_000,
})
await scrollTimelineToBottom(page)
await expect.poll(async () => (await expectTimelineMetrics(page)).distanceFromBottom).toBeLessThan(20)

const ids = await page.locator(sessionMessageItemSelector).evaluateAll((items) =>
items.map((item) => (item instanceof HTMLElement ? item.dataset.messageId : undefined)).filter(Boolean),
)
const oldID = ids[1]
if (!oldID) throw new Error("expected an older rendered message id")

await page.goto(`${page.url()}#message-${oldID}`)
await expect(page.locator(`#message-${oldID}`)).toBeVisible()
await expect.poll(async () => (await expectTimelineMetrics(page)).distanceFromBottom).toBeGreaterThan(100)

await installTimelineScrollProbe(page)
let samples: TimelineScrollSample[] = []
try {
await sendVisiblePrompt({ page, text: `top guard ${Date.now()}` })
await expect.poll(() => page.url()).not.toContain("#message-")
await expect
.poll(async () => (await expectTimelineMetrics(page)).distanceFromBottom, { timeout: 30_000 })
.toBeLessThan(40)
} finally {
samples = await stopTimelineScrollProbe(page)
}

const topJumps = samples.filter(
(sample) =>
sample.height > sample.client + 100 &&
sample.top < 20 &&
sample.distanceFromBottom > 100,
)
expect(topJumps).toEqual([])
Comment thread
coderabbitai[bot] marked this conversation as resolved.
Resolved
})
})

test("renders the full initial session window when switching sessions", async ({ page, project }) => {
test.setTimeout(120_000)

Expand Down
45 changes: 45 additions & 0 deletions packages/app/src/pages/session/session-auto-scroll.test.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,45 @@
import { describe, expect, test } from "bun:test"
import { createAutoScroll } from "@opencode-ai/ui/hooks"
import { createRoot } from "solid-js"

describe("session auto scroll", () => {
test("disables overflow anchoring before forcing the timeline to bottom", () => {
createRoot((dispose) => {
const el = document.createElement("div")
let top = 500
let anchorAtScroll = ""

Object.defineProperties(el, {
clientHeight: { value: 100, configurable: true },
scrollHeight: { value: 1000, configurable: true },
scrollTop: {
configurable: true,
get: () => top,
set: (value) => {
anchorAtScroll = el.style.overflowAnchor
top = value
},
},
})

const autoScroll = createAutoScroll({
working: () => true,
overflowAnchor: "dynamic",
})

autoScroll.scrollRef(el)
autoScroll.pause()
el.style.overflowAnchor = "auto"

expect(autoScroll.userScrolled()).toBe(true)
expect(el.style.overflowAnchor).toBe("auto")

autoScroll.forceScrollToBottom()

expect(anchorAtScroll).toBe("none")
expect(top).toBe(1000)

dispose()
})
})
})
40 changes: 22 additions & 18 deletions packages/ui/src/hooks/create-auto-scroll.tsx
Original file line number Diff line number Diff line change
Expand Up @@ -34,6 +34,22 @@ export function createAutoScroll(options: AutoScrollOptions) {
return el.scrollHeight - el.clientHeight > 1
}

const updateOverflowAnchor = (el: HTMLElement) => {
const mode = options.overflowAnchor ?? "dynamic"

if (mode === "none") {
el.style.overflowAnchor = "none"
return
}

if (mode === "auto") {
el.style.overflowAnchor = "auto"
return
}

el.style.overflowAnchor = store.userScrolled ? "auto" : "none"
}

// Browsers can dispatch scroll events asynchronously. If new content arrives
// between us calling `scrollTo()` and the subsequent `scroll` event firing,
// the handler can see a non-zero `distanceFromBottom` and incorrectly assume
Expand Down Expand Up @@ -79,9 +95,13 @@ export function createAutoScroll(options: AutoScrollOptions) {
const scrollToBottom = (force: boolean) => {
if (!force && !active()) return

if (force && store.userScrolled) setStore("userScrolled", false)

const el = store.scrollRef

if (force && store.userScrolled) {
setStore("userScrolled", false)
if (el) updateOverflowAnchor(el)
}

if (!el) return

if (!force && store.userScrolled) return
Expand Down Expand Up @@ -153,22 +173,6 @@ export function createAutoScroll(options: AutoScrollOptions) {
}
}

const updateOverflowAnchor = (el: HTMLElement) => {
const mode = options.overflowAnchor ?? "dynamic"

if (mode === "none") {
el.style.overflowAnchor = "none"
return
}

if (mode === "auto") {
el.style.overflowAnchor = "auto"
return
}

el.style.overflowAnchor = store.userScrolled ? "auto" : "none"
}

createResizeObserver(
() => store.contentRef,
() => {
Expand Down
Loading