/** * The no-shift probe of U2 (adjustment A14, plan Task 3): a state change of the annotations * tab moves no box. The boxes of the canvas, the strip, the aside and the draft header, * the page's scroll height, its scrollbar gutter and its client width are read before and * after `act`; a layout-shift observer adds up every entry in between, the ones following * an input included (a message appearing after a drop is still a shift). */ import { expect, type Page } from '@playwright/test' /** * What may change by design until a later task, named at the call site only: the side * panel's own content (its height, the scroll height, and shifts whose every moved node is * inside it) while it still swaps the overview, the properties and the creation panel. */ export type ShiftExemption = 'aside-content' interface Box { x: number y: number width: number height: number } interface Snapshot { boxes: Record scrollHeight: number gutter: string clientWidth: number } const PARTS = { canvas: '[data-testid="annotation-canvas"]', strip: '[data-testid="edit-strip"]', aside: '[data-testid="editor-tab-annotations"] aside', header: 'header:has(> nav + div > h1)', } as const function snapshot(page: Page): Promise { return page.evaluate((parts) => { const shown = (selector: string) => [...document.querySelectorAll(selector)].find( (element) => (element as HTMLElement).offsetParent !== null, ) const boxes: Record = {} for (const [name, selector] of Object.entries(parts)) { const rect = shown(selector)?.getBoundingClientRect() boxes[name] = rect ? { x: rect.x, y: rect.y, width: rect.width, height: rect.height } : null } const root = document.documentElement return { boxes, scrollHeight: root.scrollHeight, gutter: getComputedStyle(root).scrollbarGutter, clientWidth: root.clientWidth, } }, PARTS) } /** The page side of the probe: the summed shift and what moved, for the failure message. */ interface ShiftScope { __shift: { total: number; moved: string[] } __shiftObserver?: PerformanceObserver } /** Starts summing layout-shift entries; read back with `shiftTotal`. */ function observeShifts(page: Page, asideExempt: boolean): Promise { return page.evaluate( ({ exempt, aside }) => { const scope = window as unknown as ShiftScope scope.__shiftObserver?.disconnect() scope.__shift = { total: 0, moved: [] } const observer = new PerformanceObserver((list) => { for (const entry of list.getEntries()) { const shift = entry as unknown as { value: number sources: { node?: Node }[] } const inAside = shift.sources.every((source) => (source.node as Element | undefined)?.closest?.(aside), ) if (exempt && inAside) continue scope.__shift.total += shift.value for (const source of shift.sources) { const node = source.node as Element | undefined scope.__shift.moved.push( node?.outerHTML?.slice(0, 160) ?? String(source.node), ) } } }) observer.observe({ type: 'layout-shift' }) scope.__shiftObserver = observer }, { exempt: asideExempt, aside: PARTS.aside }, ) } /** Two frames for layout to settle, then the pending entries and the total. */ function shiftTotal(page: Page): Promise { return page.evaluate(async () => { await new Promise((done) => requestAnimationFrame(() => requestAnimationFrame(done)), ) const scope = window as unknown as ShiftScope const observer = scope.__shiftObserver! const pending = observer.takeRecords() observer.disconnect() for (const entry of pending) { scope.__shift.total += (entry as unknown as { value: number }).value } return scope.__shift }) } /** * Runs `act` and asserts nothing moved. `exempt: ['aside-content']` lets the side panel's * content change (see `ShiftExemption`); the aside's position and width, the canvas, the * strip and the header are still checked, and every shift outside the aside. */ export async function expectNoShift( page: Page, act: () => Promise, exempt: readonly ShiftExemption[] = [], ): Promise { const before = await snapshot(page) const loose = exempt.includes('aside-content') await observeShifts(page, loose) await act() const shift = await shiftTotal(page) const after = await snapshot(page) const drop = (shot: Snapshot) => ({ ...shot, scrollHeight: loose ? 0 : shot.scrollHeight, boxes: { ...shot.boxes, aside: loose && shot.boxes.aside ? { ...shot.boxes.aside, height: 0 } : shot.boxes.aside, }, }) expect(drop(after)).toEqual(drop(before)) expect(shift.total, `layout shift of ${shift.moved.join(' | ')}`).toBe(0) }