import { fr } from '@/i18n/fr'
import type { Locator, Page, TestInfo } from '@playwright/test'
import { expect, expectAccessible, test } from '../support/browser'
import { expectNoShift } from '../support/layout'
import { dropLateReplays, routeToSandbox } from '../support/sandbox'
import {
place,
clickDrawing,
clientOf,
editorActor,
shownNumber,
shownShape,
openEditor,
openSection,
pickAnnotation,
pointOf,
saveDraft,
seedDraft,
selectionTag,
selectTab,
annotationList,
serverDocument,
shapeWith,
standardShape,
openProperties,
scrollToTop,
} from '../support/editor'
// V1-2.6 geometry and adversarial cases (contract C7, C8, C21; owner 2026-11-04): a click
// near the edge of a frame (the corrected position shown, confirmed and cancelled), a
// point inherited out of its frame repaired with the move mode (U2 Task 4), a crop change
// refused when it would invalidate a point, an unmeasured view with its tools disabled,
// and the touch path (touch-action, pointer capture) in a real browser.
const dict = fr
const isPhone = (info: TestInfo) => info.project.name === 'chromium-375'
const creation = (page: Page) => page.getByTestId('annotation-creation')
const notice = (page: Page) => page.getByTestId('correction-notice')
const tool = (page: Page, id: string) =>
page.getByRole('button', {
name: dict[`editor.annotations.tool.${id}`],
exact: true,
})
const viewChip = (page: Page, name: string) =>
page
.getByRole('group', { name: dict['editor.annotations.views'] })
.getByRole('button', { name })
/**
* The x and y the correction proposes, read from the drawing (R-4: the notice in the
* creation dialog says it without numbers).
*/
async function proposed(page: Page): Promise<{ x: string; y: string }> {
const circle = page.getByTestId('overlay-correction').locator('circle')
const x = await circle.getAttribute('cx')
const y = await circle.getAttribute('cy')
if (x === null || y === null) throw new Error('no proposed position drawn')
return { x, y }
}
/** A mouse drag on the drawing in the move mode, between two points in drawing units. */
async function dragInMode(
page: Page,
from: { x: number; y: number },
to: { x: number; y: number },
) {
const start = await clientOf(page, from.x, from.y)
const end = await clientOf(page, to.x, to.y)
await page.mouse.move(start.x, start.y)
await page.mouse.down()
await page.mouse.move(end.x, end.y, { steps: 6 })
await page.mouse.up()
}
async function fillNames(page: Page, fr: string, en: string) {
await creation(page).getByLabel(dict['editor.annotations.name_fr']).fill(fr)
await creation(page).getByLabel(dict['editor.annotations.name_en']).fill(en)
await creation(page)
.getByLabel(dict['editor.annotations.laterality'])
.selectOption('unpaired')
}
async function open(page: Page, ...annotations: unknown[]) {
const actor = await editorActor('fr')
const seed = await seedDraft(actor, { shape: shapeWith(...annotations) })
await openEditor(page, dict, actor, seed.sheetId)
await expect(tool(page, 'point')).toBeEnabled()
return { actor, seed }
}
test.describe('editor geometry (adversarial)', () => {
test.use({ locale: 'fr-FR', actionTimeout: 15_000 })
test.beforeEach(async ({ context }, info) => {
test.skip(isPhone(info), 'editing needs 1 024 px') // floor-guard: allow C16 editing needs >= 1024 px; phone read-only covered in editor-access
await routeToSandbox(context)
})
test.afterEach(async ({ context }) => {
await dropLateReplays(context)
})
test('a click near the edge: corrected position shown, cancelled, then confirmed', async ({
page,
requests,
}) => {
const { actor } = await open(page)
requests.forbid(actor.account.email, actor.account.password)
await tool(page, 'point').click()
await clickDrawing(page, 3, 3)
await fillNames(page, 'Bord', 'Edge')
await creation(page)
.getByRole('button', { name: dict['editor.annotations.create'] })
.click()
await expect(notice(page)).toBeVisible()
// R-4: the notice is in the creation dialog, its text without numbers.
await expect(
page.getByRole('dialog', { name: dict['editor.annotations.new.point'] }),
).toContainText(dict['editor.annotations.correction'])
await expect(page.getByTestId('overlay-click-cross')).toBeAttached()
const shown = await proposed(page)
await expect(selectionTag(page)).toHaveCount(0) // an insertion selects it
// Cancelled: the notice goes, nothing was inserted.
await notice(page)
.getByRole('button', {
name: dict['editor.annotations.correction_cancel'],
})
.click()
await expect(notice(page)).toHaveCount(0)
await expect(selectionTag(page)).toHaveCount(0) // an insertion selects it
// Confirmed: the same attempt again, the corrected position inserted.
await creation(page)
.getByRole('button', { name: dict['editor.annotations.create'] })
.click()
await expect(notice(page)).toBeVisible()
expect(await proposed(page)).toEqual(shown)
await notice(page)
.getByRole('button', { name: dict['editor.annotations.correction_use'] })
.click()
await expect(creation(page)).toHaveCount(0)
await expect(selectionTag(page)).toContainText('Bord')
await expect(shownShape(page)).toHaveAttribute('cx', shown.x)
await expect(shownShape(page)).toHaveAttribute('cy', shown.y)
})
test('a click near the edge of a detail crop is corrected inside the crop', async ({
page,
requests,
}) => {
const { actor } = await open(page)
requests.forbid(actor.account.email, actor.account.password)
await viewChip(page, 'Détail A').click()
await tool(page, 'point').click()
await clickDrawing(page, 102, 102)
await fillNames(page, 'Bord détail', 'Detail edge')
await creation(page)
.getByRole('button', { name: dict['editor.annotations.create'] })
.click()
await expect(notice(page)).toBeVisible()
const shown = await proposed(page)
expect(Number(shown.x)).toBeGreaterThan(100)
expect(Number(shown.y)).toBeGreaterThan(100)
// Cancelled first: nothing is added to the crop's view.
await notice(page)
.getByRole('button', {
name: dict['editor.annotations.correction_cancel'],
})
.click()
await expect(notice(page)).toHaveCount(0)
await expect(selectionTag(page)).toHaveCount(0) // an insertion selects it
// Then confirmed: the same attempt again inserts the corrected position.
await creation(page)
.getByRole('button', { name: dict['editor.annotations.create'] })
.click()
expect(await proposed(page)).toEqual(shown)
await notice(page)
.getByRole('button', { name: dict['editor.annotations.correction_use'] })
.click()
await expect(selectionTag(page)).toContainText('Bord détail')
})
test('a point inherited out of its frame is repaired with the move mode', async ({
page,
requests,
}) => {
const { actor } = await open(
page,
pointOf('out', 'detail-a', { cx: 110, cy: 110, r: 30 }, 'Hors cadre'),
)
requests.forbid(actor.account.email, actor.account.password)
await viewChip(page, 'Détail A').click()
await pickAnnotation(page, dict, /Hors cadre/)
// The issue: an alert in the properties dialog's read mode, its text in the strip.
const properties = await openProperties(page, dict)
const issue = (
await properties
.getByTestId('annotation-geometry-issues')
.locator('li')
.first()
.innerText()
).trim()
await page.keyboard.press('Escape')
await expect(page.getByRole('dialog')).toHaveCount(0)
const notice = page.getByTestId('edit-strip-notice')
await expect(notice).toContainText(issue)
const verification = page.getByRole('tab', {
name: dict['editor.tab.verification'],
})
const errorsBefore = Number(
(await verification.innerText()).replace(/\D/g, ''),
)
expect(errorsBefore).toBeGreaterThan(0)
const move = page.getByRole('button', {
name: dict['editor.annotations.move.point'],
})
const confirm = page.getByRole('button', {
name: dict['editor.annotations.move.confirm'],
})
// A partial move (still out of the frame): refused by the core, the point restored.
// Nothing around the drawing moves (A14), from the page's top here.
await scrollToTop(page)
await expectNoShift(page, () => move.click())
await dragInMode(page, { x: 250, y: 250 }, { x: 260, y: 260 })
await expectNoShift(page, async () => {
await confirm.click()
await expect(page.getByTestId('gesture-message')).toBeVisible()
})
await expect(page.getByTestId('gesture-message')).toContainText(
dict['editor.annotations.message.move_refused'].split(' :')[0],
)
await expect(page.getByTestId('overlay-refused-place')).toBeAttached()
await expect(shownShape(page)).toHaveAttribute('cx', '110')
await expect(verification).toContainText(String(errorsBefore))
// M-3: the same refusal again is a new pill, announced again; nothing moves (A14).
const pill = page.getByTestId('gesture-message')
await pill.evaluate((element) => element.setAttribute('data-first', ''))
await expectNoShift(page, () => move.click())
await dragInMode(page, { x: 250, y: 250 }, { x: 260, y: 260 })
await expectNoShift(page, async () => {
await confirm.click()
await expect(
page.locator('[data-testid="gesture-message"]:not([data-first])'),
).toBeVisible()
})
await expect(pill).toHaveCount(1)
await expect(page.getByRole('alert').filter({ has: pill })).toHaveCount(0)
await expect(pill).toHaveAttribute('role', 'alert')
await expect(pill).toContainText(
dict['editor.annotations.message.move_refused'].split(' :')[0],
)
await expect(shownShape(page)).toHaveAttribute('cx', '110')
// Far enough inside, from the page's end: kept, the issue gone, one error less. The
// issue leaving no longer shortens the page (it lives in the strip and the dialog, the
// side column keeps the overview, U2 Task 6), so the scroll clamp moves nothing. The
// buttons are pressed in place (no scroll into view), the page stays at its end.
await page.evaluate(() => window.scrollTo(0, document.body.scrollHeight))
const end = await page.evaluate(() => window.scrollY)
expect(end, 'the page scrolls: its end is not its top').toBeGreaterThan(0)
await expectNoShift(page, () => move.dispatchEvent('click'))
await dragInMode(page, { x: 250, y: 250 }, { x: 290, y: 290 })
await expectNoShift(page, async () => {
await confirm.dispatchEvent('click')
await expect(notice).not.toContainText(issue)
})
expect(await page.evaluate(() => window.scrollY)).toBe(end)
expect(Math.abs((await shownNumber(page, 'cx')) - 150)).toBeLessThan(2)
const after = (await verification.innerText()).replace(/\D/g, '')
expect(Number(after || 0)).toBeLessThan(errorsBefore)
})
test('a crop change that would invalidate a point is refused, then reverted', async ({
page,
requests,
}) => {
const { actor } = await open(
page,
pointOf(
'inside',
'detail-a',
{ cx: 350, cy: 300, r: 20 },
'Dans le cadre',
),
)
requests.forbid(actor.account.email, actor.account.password)
await openSection(page, dict, 'views')
const detail = page.getByRole('listitem', { name: 'Détail A' })
await detail
.getByRole('button', { name: dict['editor.views.crop.toggle'] })
.click()
const width = detail.getByLabel(dict['editor.views.crop.width'], {
exact: true,
})
await expect(width).toHaveValue('300')
await width.fill('100')
await width.press('Enter')
const refusal = detail.getByRole('alert')
await expect(
refusal.getByText(dict['editor.views.crop.not_applied']),
).toBeVisible()
await expect(refusal).toContainText('Dans le cadre')
await refusal
.getByRole('button', { name: dict['editor.views.crop.revert'] })
.click()
await expect(width).toHaveValue('300')
})
test('attaching a drawing to an unmeasured view repairs the annotations outside its frame', async ({
page,
requests,
}) => {
const zone = {
...pointOf('out-zone', 'main', { cx: 0, cy: 0, r: 1 }, 'Zone hors cadre'),
kind: 'zone',
geometry: {
type: 'polygon',
points: [
[10, 10],
[400, 10],
[400, 400],
],
},
}
const point = pointOf(
'out-point',
'main',
{ cx: 500, cy: 400, r: 20 },
'Point hors cadre',
)
const actor = await editorActor('fr')
requests.forbid(actor.account.email, actor.account.password)
const seed = await seedDraft(actor, {
drawing: null,
shape: (document) => {
standardShape(document)
const views = document.views as { id: string }[]
document.views = views.filter((view) => view.id === 'main')
document.annotations = [point, zone]
},
})
await openEditor(page, dict, actor, seed.sheetId)
await openSection(page, dict, 'views')
await page.getByTestId('view-main-file').setInputFiles({
name: 'petit.svg',
mimeType: 'image/svg+xml',
buffer: Buffer.from(
'',
),
})
const dialog = page.getByRole('dialog', {
name: dict['editor.views.repair.title'],
})
await expect(dialog).toBeVisible()
const row = dialog.getByTestId('repair-out-point')
await expect(
row.getByLabel(dict['editor.annotations.geometry.cx']),
).toHaveValue('85')
await expectAccessible(page, 'the repair dialog')
// A value the core refuses: nothing applied, the typed value kept.
const cx = row.getByLabel(dict['editor.annotations.geometry.cx'])
await cx.fill('900')
await cx.press('Enter')
await dialog
.getByRole('button', { name: dict['editor.views.repair.apply'] })
.click()
await expect(
dialog.getByText(dict['editor.views.repair.refused']),
).toBeVisible()
await expect(cx).toHaveValue('900')
await cx.fill('60')
await cx.press('Enter')
await dialog
.getByRole('button', { name: dict['editor.views.repair.apply'] })
.click()
await expect(dialog).toBeHidden()
await expect(page.getByText(dict['editor.upload.done'])).toBeVisible()
await saveDraft(page, dict, seed.revision + 1)
const saved = await serverDocument<{
views: { id: string; svg_asset_id: string | null }[]
annotations: { id: string; geometry: Record }[]
}>(seed.draftId)
expect(saved.views[0].svg_asset_id).not.toBeNull()
const byId = Object.fromEntries(saved.annotations.map((a) => [a.id, a]))
expect(byId['out-point'].geometry).toMatchObject({ type: 'circle', cx: 60 })
expect(byId['out-zone'].geometry).toEqual({
type: 'polygon',
points: [
[10, 10],
[100, 10],
[100, 100],
],
})
})
test('a free path outside the new frame blocks the attach, is never reshaped and survives a save', async ({
page,
requests,
}) => {
const seededPath =
'M 300 300 l 40 0 C 350 320 380 360 400 400 q 20 -30 -40 -50 ' +
'A 30 20 0 0 1 320 330 H 310 V 305 Z'
const path = {
...pointOf('out-path', 'main', { cx: 0, cy: 0, r: 1 }, 'Tracé libre'),
kind: 'zone',
geometry: { type: 'path', d: seededPath },
}
const point = pointOf(
'out-point',
'main',
{ cx: 500, cy: 400, r: 20 },
'Point hors cadre',
)
const actor = await editorActor('fr')
requests.forbid(actor.account.email, actor.account.password)
const seed = await seedDraft(actor, {
drawing: null,
shape: (document) => {
standardShape(document)
const views = document.views as { id: string }[]
document.views = views.filter((view) => view.id === 'main')
document.annotations = [point, path]
},
})
await openEditor(page, dict, actor, seed.sheetId)
await openSection(page, dict, 'views')
await page.getByTestId('view-main-file').setInputFiles({
name: 'petit.svg',
mimeType: 'image/svg+xml',
buffer: Buffer.from(
'',
),
})
const dialog = page.getByRole('dialog', {
name: dict['editor.views.repair.title'],
})
await expect(dialog).toBeVisible()
const row = dialog.getByTestId('repair-out-path')
await expect(
row.getByText(dict['editor.views.repair.path_blocked']),
).toBeVisible()
await expect(row.getByRole('button')).toHaveCount(0)
await expect(
dialog.getByRole('button', { name: dict['editor.views.repair.apply'] }),
).toBeDisabled()
await dialog
.getByRole('button', { name: dict['editor.views.repair.cancel'] })
.click()
await expect(dialog).toBeHidden()
// An unrelated change is saved: the path is still the seeded one, byte for byte.
await selectTab(page, dict, 'general')
const nameFr = place(page, 'general').getByLabel(
dict['editor.general.name_fr'],
{
exact: true,
},
)
await nameFr.fill('Fiche sans toucher au tracé')
await nameFr.press('Tab')
await saveDraft(page, dict, seed.revision + 1)
const saved = await serverDocument<{
annotations: { id: string; geometry: Record }[]
}>(seed.draftId)
const kept = saved.annotations.find((a) => a.id === 'out-path')
expect(kept?.geometry).toEqual({ type: 'path', d: seededPath })
})
test('an unmeasured view: drawing tools and add buttons disabled, the hint shown', async ({
page,
requests,
}) => {
const actor = await editorActor('fr')
requests.forbid(actor.account.email, actor.account.password)
const seed = await seedDraft(actor, { drawing: null, shape: standardShape })
await openEditor(page, dict, actor, seed.sheetId)
// No measurable view: the draft opens on Général (C40).
await selectTab(page, dict, 'annotations')
await expect(
page.getByText(dict['editor.annotations.unmeasured.hint'], {
exact: false,
}),
).toBeVisible()
for (const id of ['point', 'zone', 'link'])
await expect(tool(page, id)).toBeDisabled()
for (const kind of ['point', 'zone', 'detail_trigger'])
await expect(
page.getByRole('button', {
name: dict[`editor.annotations.add.${kind}`],
}),
).toBeDisabled()
await expect(tool(page, 'select')).toBeEnabled()
await expectAccessible(page, 'an unmeasured view with its tools disabled')
})
})
test.describe('editor touch path (real browser)', () => {
test.use({
locale: 'fr-FR',
actionTimeout: 15_000,
hasTouch: true,
viewport: { width: 1280, height: 800 },
})
test.beforeEach(async ({ context }, info) => {
test.skip(isPhone(info), 'touch at 1 024 px runs on desktop') // floor-guard: allow C16 editing needs >= 1024 px; phone read-only covered in editor-access
await routeToSandbox(context)
})
test.afterEach(async ({ context }) => {
await dropLateReplays(context)
})
test('touch-action follows the tool; a touch drag moves the selected marker', async ({
page,
context,
requests,
}) => {
const { actor } = await open(
page,
pointOf('moving', 'main', { cx: 500, cy: 400, r: 60 }, 'Tactile'),
)
requests.forbid(actor.account.email, actor.account.password)
const box = page.getByTestId('annotation-canvas')
const touchAction = () =>
box.evaluate((el) => getComputedStyle(el).touchAction)
await expect.poll(touchAction).toBe('pan-x pan-y')
await tool(page, 'point').click()
await expect.poll(touchAction).toBe('none')
await tool(page, 'select').click()
await expect.poll(touchAction).toBe('pan-x pan-y')
// A movable selection needs the touch itself: the browser reads touch-action at
// touchstart, so a drag of the selected marker must not be left to the pan.
await pickAnnotation(page, dict, /Tactile/)
await expect.poll(touchAction).toBe('none')
await expect(shownShape(page)).toHaveAttribute('cx', '500')
const from = await clientOf(page, 500, 400)
const to = await clientOf(page, 620, 400)
const cdp = await context.newCDPSession(page)
const touch = (
type: 'touchStart' | 'touchMove' | 'touchEnd',
at: { x: number; y: number } | null,
) =>
cdp.send('Input.dispatchTouchEvent', {
type,
touchPoints: at ? [{ x: at.x, y: at.y }] : [],
})
await touch('touchStart', from)
for (let step = 1; step <= 8; step++)
await touch('touchMove', {
x: from.x + ((to.x - from.x) * step) / 8,
y: from.y,
})
await touch('touchEnd', null)
await expect(shownShape(page)).not.toHaveAttribute('cx', '500')
expect(Math.abs((await shownNumber(page, 'cx')) - 620)).toBeLessThan(3)
})
})
// U2 Task 14 (owner point 1): on the editable layout the strip stays right under the sticky
// top bar at every scroll position, without moving anything in the flow.
const VIEWPORTS = [
{ width: 1024, height: 768 },
{ width: 1180, height: 820 },
{ width: 1280, height: 800 },
]
const topBar = (page: Page) =>
page.locator('header:has([data-testid="topbar-account"])')
/** Enough annotations for the overview to grow the page well past one screen. */
const manyPoints = () =>
Array.from({ length: 14 }, (_, i) =>
pointOf(`pt-${i}`, 'main', { cx: 100 + i * 40, cy: 100, r: 10 }, `Pt ${i}`),
)
/** The strip's and the bar's boxes, and what is painted at the strip's centre. */
function stripGeometry(page: Page) {
return page.evaluate(() => {
const strip = document.querySelector('[data-testid="edit-strip"]')!
const bar = document.querySelector(
'header:has([data-testid="topbar-account"])',
)!
const box = strip.getBoundingClientRect()
const hit = document.elementFromPoint(
box.x + box.width / 2,
box.y + box.height / 2,
)
return {
barBottom: bar.getBoundingClientRect().bottom,
top: box.top,
bottom: box.bottom,
covered: !hit || !strip.contains(hit),
scrollY: window.scrollY,
limit: document.documentElement.scrollHeight - window.innerHeight,
innerHeight: window.innerHeight,
}
})
}
/**
* The pinned drawing column (U2 Task 17): its box, the canvas box, what is painted at the
* canvas's top centre.
*/
function columnGeometry(page: Page) {
return page.evaluate(() => {
const rect = (css: string) =>
document.querySelector(css)!.getBoundingClientRect()
const box = rect('[data-drawing-column]')
const drawing = rect('[data-testid="annotation-canvas"]')
const hit = document.elementFromPoint(
drawing.x + drawing.width / 2,
drawing.y + 2,
)
return {
top: box.top,
bottom: box.bottom,
canvas: { y: drawing.y, width: drawing.width, height: drawing.height },
canvasTopPainted: !!hit?.closest('[data-testid="annotation-canvas"]'),
// Not capped: the canvas box still runs to the column's right edge.
canvasFills: Math.abs(rect('[data-canvas-box]').right - box.right) < 0.5,
}
})
}
/**
* Whether the page scrolls sideways: a scroll attempt moves it only if something overflows
* (scrollWidth against clientWidth hides up to the scrollbar gutter's width). It scrolls the
* page sideways and back, so it fires scroll events.
*/
function scrollsSideways(page: Page) {
return page.evaluate(() => {
window.scrollTo(100, window.scrollY)
const moved = window.scrollX > 0
window.scrollTo(0, window.scrollY)
return moved
})
}
/**
* The focused element's top against the bottom of what covers it (the strip in the drawing
* place, else the bar); null on the sticky chrome itself, whose focus never scrolls the page.
*/
function focusedUnderStrip(page: Page) {
return page.evaluate(() => {
const active = document.activeElement as HTMLElement
const strip = document.querySelector('[data-testid="edit-strip"]')!
const label = active.getAttribute('aria-label') ?? active.textContent ?? ''
const bar = document.querySelector(
'header:has([data-testid="topbar-account"])',
)!
const inPlace =
!!active.closest('[data-place="annotations.drawing"]') &&
!strip.contains(active)
// Below the strip in the drawing place, below the bar elsewhere; the sticky chrome
// itself (the strip's commands, the bar's links) never scrolls the page; the shell's own
// links, outside the editor page, are not its concern.
const sticky =
strip.contains(active) ||
bar.contains(active) ||
!active.closest('[data-editor-workspace]')
return {
limit: sticky
? null
: inPlace
? strip.getBoundingClientRect().bottom
: bar.getBoundingClientRect().bottom,
name: `${active.tagName} « ${label.trim().slice(0, 30)} »`,
top: active.getBoundingClientRect().top,
}
})
}
/**
* A window too short for the pinned drawing column (U2 Task 17: pinned from 40.25 rem high):
* the drawing scrolls under the strip as before, and the strip's margin brings a focus out.
*/
const belowPinnedHeight = (page: Page) =>
page.setViewportSize({ width: page.viewportSize()!.width, height: 600 })
// Criterion 25: the header's « Enregistrer » and the tab row's « Défaire » and « Refaire » sit
// outside the drawing place; a keyboard focus on them, the page scrolled, never lands under the bar.
const HEADER_WIDTHS = [820, 1024, 1280]
/** Focuses the tabbable next to `target` without scrolling, then scrolls it under the bar. */
function parkBesideTarget(target: Locator, key: 'Tab' | 'Shift+Tab') {
return target.evaluate((el, step) => {
const tabbable = [
...document.querySelectorAll(
'a[href], button, input, select, textarea, [tabindex]',
),
].filter((n) => n.tabIndex >= 0 && n.getClientRects().length > 0)
const beside =
tabbable[tabbable.indexOf(el as HTMLElement) + (step === 'Tab' ? -1 : 1)]
beside.focus({ preventScroll: true })
const bar = document.querySelector(
'header:has([data-testid="topbar-account"])',
)!
const top = el.getBoundingClientRect().top + window.scrollY
window.scrollTo(0, top - bar.getBoundingClientRect().bottom + 10)
}, key)
}
for (const width of HEADER_WIDTHS) {
test.describe(`the editor header's controls under the top bar at ${width} px (criterion 25)`, () => {
test.use({
locale: 'fr-FR',
actionTimeout: 15_000,
viewport: { width, height: 768 },
})
test.beforeEach(async ({ context }, info) => {
test.skip(isPhone(info), 'the phone project has its own viewport') // floor-guard: allow C16 sticky bar probed at 820, 1 024 and 1 280 px
await routeToSandbox(context)
})
test.afterEach(async ({ context }) => {
await dropLateReplays(context)
})
test('Tab and Shift+Tab onto « Enregistrer », « Défaire » and « Refaire » end below the bar', async ({
page,
}) => {
const actor = await editorActor('fr')
const seed = await seedDraft(actor, { shape: shapeWith(...manyPoints()) })
await openEditor(page, dict, actor, seed.sheetId)
// A committed edit enables « Enregistrer » and « Défaire »; back on the annotations tab.
await selectTab(page, dict, 'general')
const name = page.getByLabel(dict['editor.general.name_en'], {
exact: true,
})
// Read-only below 1 024 px: the name is text and only the tab row's controls remain.
const editable = await name.evaluate((el) => el.tagName === 'INPUT')
if (editable) {
await name.fill(`Edited ${Date.now()}`)
await name.press('Enter')
}
await selectTab(page, dict, 'annotations')
const named = (label: string) =>
page.getByRole('button', { name: label, exact: true })
const targets = [
page.getByRole('tab', { name: dict['editor.tab.annotations'] }),
...(editable
? [
named(dict['common.save']),
named(dict['editor.history.undo_title']),
named(dict['editor.history.redo_title']),
]
: []),
]
if (editable) await expect(targets[1]).toBeEnabled()
for (const target of targets) {
for (const key of ['Tab', 'Shift+Tab'] as const) {
await parkBesideTarget(target, key)
const bar = await topBar(page).boundingBox()
const before = (await target.boundingBox())!
expect(before.y, 'precondition: starts under the bar').toBeLessThan(
bar!.y + bar!.height,
)
const label =
(await target.getAttribute('aria-label')) ??
(await target.textContent())
await page.keyboard.press(key)
await expect(target, `${key} onto ${label}`).toBeFocused()
const after = (await target.boundingBox())!
const barBottom = (await topBar(page).boundingBox())!.y + bar!.height
expect
.soft(
after.y,
`${key} onto ${label}: top ${after.y} vs bar bottom ${barBottom}`,
)
.toBeGreaterThanOrEqual(barBottom - 0.5)
}
}
})
})
}
for (const viewport of VIEWPORTS) {
test.describe(`the strip under the top bar at ${viewport.width} px (U2 Task 14)`, () => {
test.use({
locale: 'fr-FR',
actionTimeout: 15_000,
hasTouch: true,
viewport,
})
test.beforeEach(async ({ context }, info) => {
test.skip(isPhone(info), 'editing needs 1 024 px') // floor-guard: allow C16 editing needs >= 1024 px; phone read-only covered in editor-access
await routeToSandbox(context)
})
test.afterEach(async ({ context }) => {
await dropLateReplays(context)
})
test('at every scroll step the strip is below the bar and visible; nothing shifts', async ({
page,
context,
}) => {
await open(page, ...manyPoints())
await pickAnnotation(page, dict, 'Pt 0')
await expect(selectionTag(page)).toContainText('Pt 0')
const flowTop = (selector: string) =>
page.evaluate(
(css) =>
document.querySelector(css)!.getBoundingClientRect().top +
window.scrollY,
selector,
)
const asideTop = await flowTop('[data-annotation-aside="edit"]')
const start = await stripGeometry(page)
const { canvas } = await columnGeometry(page)
expect(start.limit, 'the page must scroll').toBeGreaterThan(300)
for (let y = 0; y <= start.limit + 150; y += 150) {
await page.evaluate((to) => window.scrollTo(0, to), y)
const now = await stripGeometry(page)
const at = `scrollY ${now.scrollY}`
expect(
now.top,
`strip top below the bar at ${at}`,
).toBeGreaterThanOrEqual(now.barBottom - 0.5)
expect(now.bottom, `strip bottom in view at ${at}`).toBeLessThanOrEqual(
now.innerHeight,
)
expect(now.covered, `strip painted at ${at}`).toBe(false)
// Task 17: the drawing column (chips to message line) is never under the strip
// and fits the window; the canvas keeps its size; nothing scrolls sideways.
const pinned = await columnGeometry(page)
expect(
pinned.top,
`column top below the strip at ${at}`,
).toBeGreaterThanOrEqual(now.bottom - 0.5)
// Stuck with the strip, all of it is in view (before, the page top shows its top).
if (now.top <= now.barBottom + 0.5)
expect(
pinned.bottom,
`column bottom in view at ${at}`,
).toBeLessThanOrEqual(now.innerHeight + 0.5)
expect(pinned.canvasTopPainted, `canvas top painted at ${at}`).toBe(
true,
)
expect(pinned.canvas.width, `canvas width at ${at}`).toBe(canvas.width)
expect(pinned.canvas.height, `canvas height at ${at}`).toBe(
canvas.height,
)
expect(await scrollsSideways(page), `no sideways scroll at ${at}`).toBe(
false,
)
expect(pinned.canvasFills, `canvas not capped at ${at}`).toBe(true)
}
// Sticky leaves the flow alone: the aside keeps its place.
expect(await flowTop('[data-annotation-aside="edit"]')).toBe(asideTop)
const bottom = (await stripGeometry(page)).scrollY
const command = page
.getByTestId('edit-strip')
.getByRole('button', { name: dict['editor.annotations.properties'] })
// A finger on a strip command after the scroll hits it (a hit check that had to
// scroll again would move the page), and no box moves.
const cdp = await context.newCDPSession(page)
const box = (await command.boundingBox())!
expect(
box.y,
'the command is in view, under the bar',
).toBeGreaterThanOrEqual((await stripGeometry(page)).barBottom)
await expectNoShift(page, async () => {
const at = { x: box.x + box.width / 2, y: box.y + box.height / 2 }
await cdp.send('Input.dispatchTouchEvent', {
type: 'touchStart',
touchPoints: [at],
})
await cdp.send('Input.dispatchTouchEvent', {
type: 'touchEnd',
touchPoints: [],
})
await expect(page.getByRole('dialog')).toBeVisible()
await page.keyboard.press('Escape')
await expect(page.getByRole('dialog')).toHaveCount(0)
})
expect((await stripGeometry(page)).scrollY).toBe(bottom)
})
test('a focus never scrolls onto the bar or the strip, nor lands under them', async ({
page,
}) => {
// A marker large enough on the phone preview for its moves to be accepted.
const big = pointOf(
'pt-big',
'main',
{ cx: 500, cy: 400, r: 40 },
'Pt Big',
)
await open(page, ...manyPoints(), big)
await pickAnnotation(page, dict, 'Pt Big')
// At the page top the add row is below the fold: its focus reveals it with the least
// scroll, never onto the bar or the strip, and the column stays below the strip.
await page.evaluate(() => window.scrollTo(0, 0))
const add = page.locator('[data-add-kind="point"]')
const unrevealed = (await add.boundingBox())!
expect(
unrevealed.y,
'precondition: the add button is below the fold',
).toBeGreaterThan(await page.evaluate(() => window.innerHeight))
await add.focus()
const revealed = await stripGeometry(page)
const addBox = (await add.boundingBox())!
expect(addBox.y, 'the add button below the strip').toBeGreaterThanOrEqual(
revealed.bottom - 0.5,
)
expect(addBox.y + addBox.height).toBeLessThanOrEqual(
revealed.innerHeight + 0.5,
)
expect((await columnGeometry(page)).top).toBeGreaterThanOrEqual(
revealed.bottom - 0.5,
)
await page.evaluate(() => window.scrollTo(0, 300))
const before = (await stripGeometry(page)).scrollY
// The keyboard's focus move on the strip's command and on the bar's first control.
for (const target of [
page
.getByTestId('edit-strip')
.getByRole('button', { name: dict['editor.annotations.properties'] }),
topBar(page).getByRole('link').first(),
]) {
await target.focus()
expect(
(await stripGeometry(page)).scrollY,
'focus on sticky chrome',
).toBe(before)
}
// U2 Task 17: nor on the pinned column's controls (the line's « Défaire », a view
// chip, the handle, an add button, the canvas box), each below the strip. A commit
// puts « Défaire » in the message line for 6 s.
await page.getByTestId('point-handle').focus()
await page.keyboard.press('ArrowRight')
await page.keyboard.press('Enter')
const line = page.getByTestId('gesture-line')
const undo = line.getByRole('button', {
name: dict['editor.history.undo_title'],
})
await expect(undo).toBeVisible()
for (const target of [
undo,
viewChip(page, 'Vue principale'),
page.getByTestId('point-handle'),
page.locator('[data-add-kind="point"]'),
page.getByTestId('annotation-canvas'),
]) {
await target.focus()
const label = await target.evaluate(
(el) => el.getAttribute('aria-label') ?? el.textContent,
)
expect((await stripGeometry(page)).scrollY, `focus on ${label}`).toBe(
before,
)
expect(
(await target.boundingBox())!.y,
`${label} below the strip`,
).toBeGreaterThanOrEqual((await stripGeometry(page)).bottom - 0.5)
}
// A row hidden under the strip comes out below it, not under it. The row sits low in the
// page: a short window lets the page scroll far enough to put it under the strip.
await page.setViewportSize({
width: page.viewportSize()!.width,
height: 400,
})
const row = annotationList(page, dict).getByRole('button').first()
await page.evaluate(
(el) => {
const top = el.getBoundingClientRect().top + window.scrollY
window.scrollTo(0, top - 100)
},
await row.elementHandle(),
)
const hidden = await stripGeometry(page)
expect(
(await row.boundingBox())!.y,
'precondition: the row starts under the strip',
).toBeLessThan(hidden.bottom)
await row.focus()
const now = await stripGeometry(page)
const top = (await row.boundingBox())!.y
expect(top, 'the focused row is below the strip').toBeGreaterThanOrEqual(
now.bottom,
)
})
test(
'a vertex handle (SVG) focused under the strip ends below it ' +
'(window below the pinned height)',
async ({ page }) => {
await belowPinnedHeight(page)
await open(page, ...manyPoints(), {
...pointOf('zone-v', 'main', { cx: 0, cy: 0, r: 1 }, 'Zone V'),
kind: 'zone',
geometry: {
type: 'polygon',
points: [
[300, 200],
[600, 200],
[600, 500],
[300, 500],
],
},
})
await pickAnnotation(page, dict, 'Zone V')
const vertex = page.locator('[data-vertex="0"]')
await expect(vertex).toBeVisible()
await page.evaluate(() => {
const el = document.querySelector('[data-vertex="0"]')!
window.scrollTo(
0,
el.getBoundingClientRect().top + window.scrollY - 80,
)
})
const strip = await stripGeometry(page)
const before = (await vertex.boundingBox())!
expect(
before.y,
'precondition: the handle starts under the strip',
).toBeLessThan(strip.bottom)
await vertex.focus()
const after = (await vertex.boundingBox())!
expect(
after.y,
'the focused handle is below the strip',
).toBeGreaterThanOrEqual((await stripGeometry(page)).bottom)
},
)
test(
"Tab and Shift+Tab onto the drawing place's native controls land below the strip " +
'(window below the pinned height)',
async ({ page }) => {
await belowPinnedHeight(page)
await open(page, ...manyPoints())
await pickAnnotation(page, dict, 'Pt 0')
// A commit puts « Défaire » in the message line under the drawing.
await page.getByTestId('point-handle').focus()
await page.keyboard.press('ArrowRight')
await page.keyboard.press('Enter')
await expect(page.getByTestId('gesture-message')).toBeVisible()
// Each walk starts on the canvas box, the page scrolled so the canvas top and the
// aside's top sit under the strip; the focus starts there without a scroll.
for (const key of ['Shift+Tab', 'Tab']) {
await page.evaluate(() => {
const canvas = document.querySelector(
'[data-testid="annotation-canvas"]',
)!
const top = canvas.getBoundingClientRect().top + window.scrollY
window.scrollTo(0, top - 100)
canvas.focus({ preventScroll: true })
})
for (let step = 0; step < 40; step++) {
await page.keyboard.press(key)
const at = await focusedUnderStrip(page)
if (at.limit === null) continue
expect(
at.top,
`${key} ${step + 1}: ${at.name} below the strip or the bar`,
).toBeGreaterThanOrEqual(at.limit - 0.5)
}
}
},
)
test(
'Delete from the keyboard focuses the next vertex below the strip ' +
'(window below the pinned height)',
async ({ page }) => {
await belowPinnedHeight(page)
await open(page, ...manyPoints(), {
...pointOf('zone-k', 'main', { cx: 0, cy: 0, r: 1 }, 'Zone K'),
kind: 'zone',
geometry: {
type: 'polygon',
points: [
[300, 600],
[300, 150],
[600, 150],
[600, 600],
],
},
})
await pickAnnotation(page, dict, 'Zone K')
// The next vertex (drawn higher) starts under the strip, the focused one below it.
const top = await page.evaluate(() => {
const next = document.querySelector('[data-vertex="1"]')!
const y = next.getBoundingClientRect().top + window.scrollY
window.scrollTo(0, y - 90)
document
.querySelector('[data-vertex="0"]')!
.focus({ preventScroll: true })
return next.getBoundingClientRect().top
})
const strip = await stripGeometry(page)
expect(
top,
'precondition: the next vertex is under the strip',
).toBeLessThan(strip.bottom)
await page.keyboard.press('Delete')
await expect(page.locator('[data-vertex="3"]')).toHaveCount(0)
const at = await focusedUnderStrip(page)
expect(at.name).toContain('Sommet')
expect(at.top, `${at.name} below the strip`).toBeGreaterThanOrEqual(
(await stripGeometry(page)).bottom - 0.5,
)
},
)
test(
'pinned: Delete and Insert from the keyboard keep the page still, ' +
'the vertex below the strip',
async ({ page }) => {
await open(page, ...manyPoints(), {
...pointOf('zone-k', 'main', { cx: 0, cy: 0, r: 1 }, 'Zone K'),
kind: 'zone',
geometry: {
type: 'polygon',
points: [
[300, 600],
[300, 150],
[600, 150],
[600, 600],
],
},
})
await pickAnnotation(page, dict, 'Zone K')
await page.evaluate(() => window.scrollTo(0, 400))
// A pinned handle carries no strip margin: its focus does not scroll the page.
await page.locator('[data-vertex="0"]').focus()
const before = (await stripGeometry(page)).scrollY
expect(before, 'the focus on a pinned handle').toBe(400)
for (const [key, last] of [
['Delete', 0],
['Insert', 1],
] as const) {
await page.keyboard.press(key)
await expect(page.locator('[data-vertex="3"]')).toHaveCount(last)
const at = await focusedUnderStrip(page)
expect(at.name, key).toContain('Sommet')
expect(
at.top,
`${key}: ${at.name} below the strip`,
).toBeGreaterThanOrEqual((await stripGeometry(page)).bottom - 0.5)
expect((await stripGeometry(page)).scrollY, `${key}: the page`).toBe(
before,
)
}
},
)
test('pinned: a row selection moves neither the page nor the drawing on screen', async ({
page,
}) => {
await open(page, ...manyPoints())
for (const name of ['Pt 3', 'Pt 4']) {
const row = annotationList(page, dict).getByRole('button', { name })
// The row at mid-window, the page scrolled past the point where the column sticks.
await row.evaluate((el) => {
const top = el.getBoundingClientRect().top + window.scrollY
window.scrollTo(0, top - window.innerHeight / 2)
})
expect((await stripGeometry(page)).scrollY).toBeGreaterThan(300)
const box = (await row.boundingBox())!
const strip = await stripGeometry(page)
expect(box.y, `precondition: ${name} in view`).toBeGreaterThan(
strip.bottom,
)
expect(box.y + box.height).toBeLessThan(strip.innerHeight)
const before = await columnGeometry(page)
// A real pointer press on the visible row: no bring-into-view scroll.
await page.mouse.click(box.x + box.width / 2, box.y + box.height / 2)
await expect(selectionTag(page)).toContainText(name)
expect((await stripGeometry(page)).scrollY, name).toBe(strip.scrollY)
expect((await columnGeometry(page)).canvas, name).toEqual(before.canvas)
}
})
test('with the strip hidden only the bar offset is applied', async ({
page,
}) => {
await open(page, ...manyPoints())
const margin = () =>
page.evaluate(
() =>
getComputedStyle(
document.querySelector(
'[data-place="annotations.drawing"] [data-focus-key]',
)!,
).scrollMarginTop,
)
expect(parseFloat(await margin()), 'the strip is shown').toBeGreaterThan(
100,
)
await openSection(page, dict, 'categories')
await expect(page.getByTestId('edit-strip')).toBeHidden()
// Only the bar's margin (its height and the 0.5 rem gap) remains, not the strip's.
const bar = (await topBar(page).boundingBox())!
expect(parseFloat(await margin()), 'the strip is hidden').toBe(
bar.height + 8,
)
})
})
}
// U2 Task 17 at shorter windows: 1 180 x 700 pins a capped canvas (its size set by the window,
// never by the scroll); 1 024 x 600 is below the pinned height (nothing pinned or capped).
const SHORT_WINDOWS = [
{ width: 1180, height: 700, pinned: true },
{ width: 1024, height: 600, pinned: false },
]
for (const { pinned, ...viewport } of SHORT_WINDOWS) {
test.describe(`the drawing column at ${viewport.width} x ${viewport.height} (U2 Task 17)`, () => {
test.use({ locale: 'fr-FR', actionTimeout: 15_000, viewport })
test.beforeEach(async ({ context }, info) => {
test.skip(isPhone(info), 'editing needs 1 024 px') // floor-guard: allow C16 editing needs >= 1024 px; phone read-only covered in editor-access
await routeToSandbox(context)
})
test.afterEach(async ({ context }) => {
await dropLateReplays(context)
})
test('no sideways scroll at any scroll step; pinned, the column fits the window', async ({
page,
}) => {
await open(page, ...manyPoints())
const start = await stripGeometry(page)
const { canvas, canvasFills } = await columnGeometry(page)
expect(canvasFills, 'the canvas is capped only when pinned').toBe(!pinned)
for (let y = 0; y <= start.limit + 150; y += 150) {
await page.evaluate((to) => window.scrollTo(0, to), y)
const strip = await stripGeometry(page)
const now = await columnGeometry(page)
const at = `scrollY ${strip.scrollY}`
expect(await scrollsSideways(page), `no sideways scroll at ${at}`).toBe(
false,
)
expect(now.canvas.width, `canvas width at ${at}`).toBe(canvas.width)
if (!pinned) continue
expect(
now.top,
`column below the strip at ${at}`,
).toBeGreaterThanOrEqual(strip.bottom - 0.5)
if (strip.top <= strip.barBottom + 0.5)
expect(now.bottom, `column in view at ${at}`).toBeLessThanOrEqual(
strip.innerHeight + 0.5,
)
}
})
})
}