Task 3 review, fix round 1. - The gesture message closes for good on any document or history change (store subscription): undo then redo no longer revives it. - Hover and focus hold only the message they were taken on: after « Défaire » the next message expires. - An accepted drop clears the strip's refusal hint again. - Controller ruling: the message has its own fixed row under the add buttons, column width; a refused gesture's full text also shows in the strip notice (red, aria-hidden copy of the row's alert). - expectNoShift: native requestAnimationFrame kept before page.clock (keepNativeFrames), every part box asserted non-null, message row measured; the e2e checks the message is not truncated. No assertion removed; the refused-drop unit test gains the strip copy.
176 lines
6.2 KiB
TypeScript
176 lines
6.2 KiB
TypeScript
/**
|
|
* 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 message row, 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<string, Box | null>
|
|
scrollHeight: number
|
|
gutter: string
|
|
clientWidth: number
|
|
}
|
|
|
|
const PARTS = {
|
|
canvas: '[data-testid="annotation-canvas"]',
|
|
strip: '[data-testid="edit-strip"]',
|
|
line: '[data-testid="gesture-line"]',
|
|
aside: '[data-testid="editor-tab-annotations"] aside',
|
|
header: 'header:has(> nav + div > h1)',
|
|
} as const
|
|
|
|
function snapshot(page: Page): Promise<Snapshot> {
|
|
return page.evaluate((parts) => {
|
|
const shown = (selector: string) =>
|
|
[...document.querySelectorAll(selector)].find(
|
|
(element) => (element as HTMLElement).offsetParent !== null,
|
|
)
|
|
const boxes: Record<string, Box | null> = {}
|
|
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
|
|
/** The browser's own requestAnimationFrame, kept before `page.clock` replaces it. */
|
|
__nativeRaf?: (callback: FrameRequestCallback) => number
|
|
}
|
|
|
|
/**
|
|
* Keeps the native requestAnimationFrame: call it before `page.clock.install()`, whose fake
|
|
* frames would let the two-frame wait end before the real layout (and its shift) happens.
|
|
*/
|
|
export async function keepNativeFrames(page: Page): Promise<void> {
|
|
await page.addInitScript(() => {
|
|
const scope = window as unknown as ShiftScope
|
|
const raf = window.requestAnimationFrame
|
|
// Kept only when this script ran before the clock's (else the probe would wait on fakes).
|
|
if (String(raf).includes('[native code]'))
|
|
scope.__nativeRaf = raf.bind(window)
|
|
else throw new Error('keepNativeFrames ran after page.clock.install()')
|
|
})
|
|
}
|
|
|
|
/** Starts summing layout-shift entries; read back with `shiftTotal`. */
|
|
function observeShifts(page: Page, asideExempt: boolean): Promise<void> {
|
|
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<ShiftScope['__shift']> {
|
|
return page.evaluate(async () => {
|
|
const scope = window as unknown as ShiftScope
|
|
const faked = !String(window.requestAnimationFrame).includes(
|
|
'[native code]',
|
|
)
|
|
if (faked && !scope.__nativeRaf) {
|
|
throw new Error(
|
|
'page.clock fakes the frames: call keepNativeFrames first',
|
|
)
|
|
}
|
|
const frame = scope.__nativeRaf ?? window.requestAnimationFrame.bind(window)
|
|
await new Promise((done) => frame(() => frame(done)))
|
|
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<void>,
|
|
exempt: readonly ShiftExemption[] = [],
|
|
): Promise<void> {
|
|
const before = await snapshot(page)
|
|
// A selector that stops matching would compare null with null: every part must be there.
|
|
for (const [name, box] of Object.entries(before.boxes)) {
|
|
expect(box, `${name} box before the act`).not.toBeNull()
|
|
}
|
|
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)
|
|
}
|