feat(editor): two-finger pan, touch hint, loupe, touch-sized handles
useFraming gains twoPointerPan (the editor's pinch also pans by the midpoint and scales from the spread since the pinch began; the catalogue passes nothing). A futile one-finger drag shows the R-1 hint unless two fingers already worked in this editor visit (work store flag). A finger drag of a handle shows the loupe (technique A: the drawing copied once, data-anno-id stripped, outline on top). editor-touch.spec covers 1 024, 1 180 and 1 280 px with CDP touch. measure-drag.ts is the hand-run smoothness measure (MEASURE_DRAG=1). equineShape moved from editor-zones.spec to support/editor.ts, no assertion changed.
This commit is contained in:
1 parent
3a7715486b
commit
85231a2680
18 files changed
+1338
-53
No files matched your search
@@ -0,0 +1,34 @@
|
||||
import { test } from '../support/browser'
|
||||
import { measureDrag } from '../support/measure-drag'
|
||||
import { dropLateReplays, routeToSandbox } from '../support/sandbox'
|
||||
|
||||
// U2 Task 8: the hand-run smoothness measure (support/measure-drag.ts). Skipped unless
|
||||
// MEASURE_DRAG=1: a timing figure, never a suite assertion.
|
||||
|
||||
test.describe('drag smoothness measure (hand-run)', () => {
|
||||
test.use({
|
||||
locale: 'fr-FR',
|
||||
hasTouch: true,
|
||||
viewport: { width: 1180, height: 800 },
|
||||
})
|
||||
test.beforeEach(async ({ context }, info) => {
|
||||
test.skip(process.env.MEASURE_DRAG !== '1', 'run by hand: MEASURE_DRAG=1')
|
||||
test.skip(info.project.name !== 'chromium-desktop', 'one run, at 1 180 px')
|
||||
await routeToSandbox(context)
|
||||
})
|
||||
test.afterEach(async ({ context }) => {
|
||||
await dropLateReplays(context)
|
||||
})
|
||||
|
||||
test('vertex drag on the equine main view, touch with the loupe and mouse', async ({
|
||||
page,
|
||||
context,
|
||||
}, info) => {
|
||||
test.setTimeout(180_000)
|
||||
for (const figures of await measureDrag(page, context)) {
|
||||
const line = JSON.stringify(figures)
|
||||
console.log(`MEASURE ${line}`)
|
||||
info.annotations.push({ type: 'measure', description: line })
|
||||
}
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,420 @@
|
||||
import { fr } from '@/i18n/fr'
|
||||
import type { CDPSession, Page, TestInfo } from '@playwright/test'
|
||||
import { expect, test } from '../support/browser'
|
||||
import { dropLateReplays, routeToSandbox } from '../support/sandbox'
|
||||
import {
|
||||
clientOf,
|
||||
creationPanel,
|
||||
editorActor,
|
||||
historyButton,
|
||||
openEditor,
|
||||
pickAnnotation,
|
||||
pointOf,
|
||||
seedDraft,
|
||||
selectionTag,
|
||||
shapeWith,
|
||||
shownNumber,
|
||||
shownPoints,
|
||||
toolButton,
|
||||
} from '../support/editor'
|
||||
import { expectNoShift } from '../support/layout'
|
||||
|
||||
// V1-2.6 U2 Task 8: the editor by finger (A13, board 13) at 1 024, 1 180 and 1 280 px, with
|
||||
// CDP touch points: a finger drags what it holds (a vertex, the point) under the loupe and
|
||||
// nothing else (the two-finger hint, R-1, shown once, nothing moving), two fingers zoom and
|
||||
// pan, a second finger cancels a vertex drag (Review Focus 1), the move mode, a tap on the
|
||||
// selection (A1), the tracing closed within 22 px (R-11), the page scroll over the drawing
|
||||
// without a selection, and every handle reached within 44 px (R-9).
|
||||
|
||||
const dict = fr
|
||||
const isPhone = (info: TestInfo) => info.project.name === 'chromium-375'
|
||||
const WIDTHS = [1024, 1180, 1280]
|
||||
const HINT = dict['editor.annotations.message.two_fingers']
|
||||
|
||||
const POINT = 'Pt Alpha'
|
||||
const ZONE = 'Zone Beta'
|
||||
const SQUARE = [
|
||||
[300, 200],
|
||||
[600, 200],
|
||||
[600, 500],
|
||||
[300, 500],
|
||||
]
|
||||
// Away from every annotation and handle (drawing units of the 1000 × 800 fixture).
|
||||
const EMPTY = { x: 150, y: 150 }
|
||||
const INSIDE = { x: 450, y: 330 }
|
||||
|
||||
const zone = {
|
||||
...pointOf('zone-b', 'main', { cx: 0, cy: 0, r: 1 }, ZONE),
|
||||
kind: 'zone',
|
||||
geometry: { type: 'polygon', points: SQUARE },
|
||||
}
|
||||
|
||||
type XY = { x: number; y: number }
|
||||
|
||||
const touch = (
|
||||
cdp: CDPSession,
|
||||
type: 'touchStart' | 'touchMove' | 'touchEnd',
|
||||
points: XY[],
|
||||
) =>
|
||||
cdp.send('Input.dispatchTouchEvent', {
|
||||
type,
|
||||
touchPoints: points.map((p, id) => ({ x: p.x, y: p.y, id })),
|
||||
})
|
||||
|
||||
const between = (from: XY, to: XY, step: number, steps: number) => ({
|
||||
x: from.x + ((to.x - from.x) * step) / steps,
|
||||
y: from.y + ((to.y - from.y) * step) / steps,
|
||||
})
|
||||
|
||||
/** Fingers moved together from `from` to `to` in `steps` moves (no touchEnd). */
|
||||
async function move(cdp: CDPSession, from: XY[], to: XY[], steps = 6) {
|
||||
for (let step = 1; step <= steps; step++)
|
||||
await touch(
|
||||
cdp,
|
||||
'touchMove',
|
||||
from.map((f, i) => between(f, to[i], step, steps)),
|
||||
)
|
||||
}
|
||||
|
||||
async function tap(cdp: CDPSession, at: XY) {
|
||||
await touch(cdp, 'touchStart', [at])
|
||||
await touch(cdp, 'touchEnd', [])
|
||||
}
|
||||
|
||||
/** One finger pressed at `from`, dragged to `to`, released. */
|
||||
async function drag(cdp: CDPSession, from: XY, to: XY) {
|
||||
await touch(cdp, 'touchStart', [from])
|
||||
await move(cdp, [from], [to])
|
||||
await touch(cdp, 'touchEnd', [])
|
||||
}
|
||||
|
||||
/** Two fingers 60 px apart around `at`, spread to 240 px: the drawing zooms in. */
|
||||
async function pinchOut(cdp: CDPSession, at: XY) {
|
||||
const start = [
|
||||
{ x: at.x - 30, y: at.y },
|
||||
{ x: at.x + 30, y: at.y },
|
||||
]
|
||||
const end = [
|
||||
{ x: at.x - 120, y: at.y },
|
||||
{ x: at.x + 120, y: at.y },
|
||||
]
|
||||
await touch(cdp, 'touchStart', start)
|
||||
await move(cdp, start, end)
|
||||
await touch(cdp, 'touchEnd', [])
|
||||
}
|
||||
|
||||
const canvas = (page: Page) => page.getByTestId('annotation-canvas')
|
||||
const loupe = (page: Page) => page.getByTestId('loupe')
|
||||
const message = (page: Page) => page.getByTestId('gesture-message')
|
||||
const button = (page: Page, key: string) =>
|
||||
page.getByRole('button', { name: dict[key], exact: true })
|
||||
|
||||
/** The framing of the drawing layer: `translate(x, y) scale(s)`. */
|
||||
async function framing(page: Page) {
|
||||
const transform = await page
|
||||
.getByTestId('annotation-canvas-drawing')
|
||||
.evaluate((el) => (el.parentElement as HTMLElement).style.transform)
|
||||
const [x, y, scale] = (transform.match(/-?[\d.]+/g) ?? []).map(Number)
|
||||
return { x, y, scale }
|
||||
}
|
||||
|
||||
async function open(page: Page) {
|
||||
const actor = await editorActor('fr')
|
||||
const seed = await seedDraft(actor, {
|
||||
shape: shapeWith(
|
||||
pointOf('pt-a', 'main', { cx: 750, cy: 600, r: 30 }, POINT),
|
||||
zone,
|
||||
),
|
||||
})
|
||||
const saves: string[] = []
|
||||
page.on('request', (request) => {
|
||||
if (request.url().includes('save_sheet_draft')) saves.push(request.url())
|
||||
})
|
||||
await openEditor(page, dict, actor, seed.sheetId)
|
||||
await expect(toolButton(page, dict, 'point')).toBeEnabled()
|
||||
return { actor, saves }
|
||||
}
|
||||
|
||||
/** Selects from the overview, then brings the whole drawing into view. */
|
||||
async function select(page: Page, name: string) {
|
||||
await pickAnnotation(page, dict, name)
|
||||
await expect(selectionTag(page)).toContainText(name)
|
||||
await canvas(page).scrollIntoViewIfNeeded()
|
||||
}
|
||||
|
||||
/** R-9 on a finger: every hit circle at least 44 px, the « − » bubble 44 × 36 px. */
|
||||
async function expectFingerSizedHandles(page: Page) {
|
||||
const shapes = await page
|
||||
.locator('[data-testid="handle-layer"] [data-handle]')
|
||||
.evaluateAll((elements) =>
|
||||
elements.map((el) => {
|
||||
const box = el.getBoundingClientRect()
|
||||
return { tag: el.tagName, w: box.width, h: box.height }
|
||||
}),
|
||||
)
|
||||
expect(shapes.length).toBeGreaterThan(0)
|
||||
for (const shape of shapes) {
|
||||
if (shape.tag === 'circle') {
|
||||
expect(Math.min(shape.w, shape.h), 'hit circle').toBeGreaterThanOrEqual(
|
||||
43.5,
|
||||
)
|
||||
} else {
|
||||
expect(shape.w, '« − » width').toBeGreaterThanOrEqual(43.5)
|
||||
expect(shape.h, '« − » height').toBeGreaterThanOrEqual(35.5)
|
||||
}
|
||||
}
|
||||
return shapes
|
||||
}
|
||||
|
||||
/** The loupe while a finger moves: shown, round, inside the canvas box. */
|
||||
async function expectLoupeInBox(page: Page) {
|
||||
await expect(loupe(page)).toBeVisible()
|
||||
const disc = (await loupe(page).boundingBox())!
|
||||
const box = (await canvas(page).boundingBox())!
|
||||
expect(disc.width).toBeCloseTo(120, 0)
|
||||
expect(disc.x).toBeGreaterThanOrEqual(box.x - 1)
|
||||
expect(disc.y).toBeGreaterThanOrEqual(box.y - 1)
|
||||
expect(disc.x + disc.width).toBeLessThanOrEqual(box.x + box.width + 1)
|
||||
expect(disc.y + disc.height).toBeLessThanOrEqual(box.y + box.height + 1)
|
||||
await expect(loupe(page).locator('[data-anno-id]')).toHaveCount(0)
|
||||
}
|
||||
|
||||
/** One finger from `from` to `to`, the loupe checked halfway. */
|
||||
async function dragWithLoupe(page: Page, cdp: CDPSession, from: XY, to: XY) {
|
||||
await touch(cdp, 'touchStart', [from])
|
||||
await move(cdp, [from], [between(from, to, 1, 2)], 3)
|
||||
await expectLoupeInBox(page)
|
||||
await move(cdp, [between(from, to, 1, 2)], [to], 3)
|
||||
await touch(cdp, 'touchEnd', [])
|
||||
await expect(loupe(page)).toHaveCount(0)
|
||||
}
|
||||
|
||||
for (const width of WIDTHS) {
|
||||
test.describe(`the editor by finger at ${width} px (U2 Task 8)`, () => {
|
||||
test.use({
|
||||
locale: 'fr-FR',
|
||||
actionTimeout: 15_000,
|
||||
hasTouch: true,
|
||||
viewport: { width, height: 800 },
|
||||
})
|
||||
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 finger drags a vertex and the point under the loupe; handles answer within 44 px', async ({
|
||||
page,
|
||||
context,
|
||||
requests,
|
||||
}) => {
|
||||
const { actor } = await open(page)
|
||||
requests.forbid(actor.account.email, actor.account.password)
|
||||
const cdp = await context.newCDPSession(page)
|
||||
await select(page, ZONE)
|
||||
await expectFingerSizedHandles(page)
|
||||
const from = await clientOf(page, 600, 200)
|
||||
await dragWithLoupe(page, cdp, from, { x: from.x + 40, y: from.y + 30 })
|
||||
await expect(message(page)).toContainText(
|
||||
dict['editor.annotations.message.vertex_moved'],
|
||||
)
|
||||
const [, moved] = await shownPoints(page)
|
||||
expect(moved).not.toEqual(SQUARE[1])
|
||||
// The chosen vertex shows its « − » bubble: finger-sized too.
|
||||
await expect(
|
||||
page.getByRole('button', { name: /^Retirer le sommet/ }),
|
||||
).toHaveCount(1)
|
||||
await expectFingerSizedHandles(page)
|
||||
|
||||
await select(page, POINT)
|
||||
const centre = await clientOf(page, 750, 600)
|
||||
await dragWithLoupe(page, cdp, centre, {
|
||||
x: centre.x - 40,
|
||||
y: centre.y - 20,
|
||||
})
|
||||
await expect(message(page)).toContainText(
|
||||
dict['editor.annotations.message.moved.point'],
|
||||
)
|
||||
expect(await shownNumber(page, 'cx')).toBeLessThan(750)
|
||||
// Zoomed in, the handles keep their CSS px size.
|
||||
await pinchOut(cdp, await clientOf(page, EMPTY.x, EMPTY.y))
|
||||
expect((await framing(page)).scale).toBeGreaterThan(1)
|
||||
await select(page, ZONE)
|
||||
await expectFingerSizedHandles(page)
|
||||
})
|
||||
|
||||
test('a finger off the handles moves nothing and shows the hint once; no hint over a scroll', async ({
|
||||
page,
|
||||
context,
|
||||
requests,
|
||||
}) => {
|
||||
const { actor, saves } = await open(page)
|
||||
requests.forbid(actor.account.email, actor.account.password)
|
||||
const cdp = await context.newCDPSession(page)
|
||||
|
||||
// No selection at the fit: a finger scrolls the page over the drawing.
|
||||
await page.evaluate(() => window.scrollTo(0, 0))
|
||||
const room = await page.evaluate(
|
||||
() => document.documentElement.scrollHeight - window.innerHeight,
|
||||
)
|
||||
expect(room, 'the page can scroll').toBeGreaterThan(40)
|
||||
const box = (await canvas(page).boundingBox())!
|
||||
const low = {
|
||||
x: box.x + box.width / 2,
|
||||
y: Math.min(box.y + box.height, 790) - 20,
|
||||
}
|
||||
await drag(cdp, low, { x: low.x, y: low.y - 200 })
|
||||
await expect
|
||||
.poll(() => page.evaluate(() => window.scrollY))
|
||||
.toBeGreaterThan(0)
|
||||
await expect(message(page)).toHaveCount(0)
|
||||
|
||||
await select(page, ZONE)
|
||||
const empty = await clientOf(page, EMPTY.x, EMPTY.y)
|
||||
await expectNoShift(page, async () => {
|
||||
await drag(cdp, empty, { x: empty.x + 60, y: empty.y + 40 })
|
||||
await expect(message(page)).toHaveText(HINT)
|
||||
})
|
||||
expect(await shownPoints(page)).toEqual(SQUARE)
|
||||
expect((await framing(page)).scale).toBe(1)
|
||||
// The hint leaves after 4 s; the line is free again.
|
||||
await expect(message(page)).toHaveCount(0, { timeout: 6_000 })
|
||||
|
||||
// Two fingers worked: never again in this visit.
|
||||
await pinchOut(cdp, await clientOf(page, INSIDE.x, INSIDE.y))
|
||||
expect((await framing(page)).scale).toBeGreaterThan(1)
|
||||
const again = await clientOf(page, 320, 220)
|
||||
await drag(cdp, again, { x: again.x + 50, y: again.y })
|
||||
await page.waitForTimeout(300)
|
||||
await expect(message(page)).toHaveCount(0)
|
||||
expect(saves).toEqual([])
|
||||
})
|
||||
|
||||
test('two fingers zoom and pan; a second finger cancels a vertex drag and pinches (Review Focus 1)', async ({
|
||||
page,
|
||||
context,
|
||||
requests,
|
||||
}) => {
|
||||
const { actor, saves } = await open(page)
|
||||
requests.forbid(actor.account.email, actor.account.password)
|
||||
const cdp = await context.newCDPSession(page)
|
||||
await select(page, ZONE)
|
||||
const undo = historyButton(page, dict, 'undo')
|
||||
await expect(undo).toBeDisabled()
|
||||
|
||||
// Finger 1 drags vertex 2 under the loupe, then finger 2 lands.
|
||||
const vertex = await clientOf(page, 600, 200)
|
||||
const held = { x: vertex.x + 30, y: vertex.y + 30 }
|
||||
await touch(cdp, 'touchStart', [vertex])
|
||||
await move(cdp, [vertex], [held], 3)
|
||||
await expect(loupe(page)).toBeVisible()
|
||||
expect(await shownPoints(page)).not.toEqual(SQUARE)
|
||||
const other = await clientOf(page, EMPTY.x, EMPTY.y)
|
||||
await touch(cdp, 'touchStart', [held, other])
|
||||
await expect(loupe(page)).toHaveCount(0)
|
||||
expect(await shownPoints(page)).toEqual(SQUARE)
|
||||
// The pinch goes on: the drawing zooms, the shape stays where it was.
|
||||
const spread = { x: other.x - 80, y: other.y - 40 }
|
||||
await move(
|
||||
cdp,
|
||||
[held, other],
|
||||
[{ x: held.x + 40, y: held.y + 20 }, spread],
|
||||
)
|
||||
await touch(cdp, 'touchEnd', [])
|
||||
expect((await framing(page)).scale).toBeGreaterThan(1)
|
||||
expect(await shownPoints(page)).toEqual(SQUARE)
|
||||
await expect(page.getByRole('dialog')).toHaveCount(0)
|
||||
await expect(selectionTag(page)).toContainText(ZONE)
|
||||
await expect(undo).toBeDisabled()
|
||||
|
||||
// Two fingers zoom further, then pan together without scaling.
|
||||
await pinchOut(cdp, await clientOf(page, INSIDE.x, INSIDE.y))
|
||||
const zoomed = await framing(page)
|
||||
const centre = await clientOf(page, INSIDE.x, INSIDE.y)
|
||||
const pair = [
|
||||
{ x: centre.x - 60, y: centre.y },
|
||||
{ x: centre.x + 60, y: centre.y },
|
||||
]
|
||||
await touch(cdp, 'touchStart', pair)
|
||||
await move(
|
||||
cdp,
|
||||
pair,
|
||||
pair.map((p) => ({ x: p.x + 50, y: p.y + 30 })),
|
||||
)
|
||||
await touch(cdp, 'touchEnd', [])
|
||||
const panned = await framing(page)
|
||||
expect(panned.scale).toBeCloseTo(zoomed.scale, 2)
|
||||
expect(Math.abs(panned.x - zoomed.x - 50)).toBeLessThan(1.5)
|
||||
expect(Math.abs(panned.y - zoomed.y - 30)).toBeLessThan(1.5)
|
||||
expect(await shownPoints(page)).toEqual(SQUARE)
|
||||
await expect(undo).toBeDisabled()
|
||||
expect(saves).toEqual([])
|
||||
})
|
||||
|
||||
test('the move mode by a finger; a tap opens the selection or unchooses; a trace closes within 22 px', async ({
|
||||
page,
|
||||
context,
|
||||
requests,
|
||||
}) => {
|
||||
const { actor } = await open(page)
|
||||
requests.forbid(actor.account.email, actor.account.password)
|
||||
const cdp = await context.newCDPSession(page)
|
||||
await select(page, ZONE)
|
||||
|
||||
// « Déplacer la zone »: a finger anywhere moves it, « Valider la position » commits.
|
||||
await button(page, 'editor.annotations.move.zone').click()
|
||||
await canvas(page).scrollIntoViewIfNeeded()
|
||||
const empty = await clientOf(page, EMPTY.x, EMPTY.y)
|
||||
await drag(cdp, empty, { x: empty.x + 40, y: empty.y + 40 })
|
||||
const previewed = await shownPoints(page)
|
||||
expect(previewed).not.toEqual(SQUARE)
|
||||
await button(page, 'editor.annotations.move.confirm').click()
|
||||
await expect.poll(() => shownPoints(page)).toEqual(previewed)
|
||||
const dx = previewed[0][0] - SQUARE[0][0]
|
||||
const dy = previewed[0][1] - SQUARE[0][1]
|
||||
expect(dx).toBeGreaterThan(0)
|
||||
expect(previewed[2][0]).toBeCloseTo(SQUARE[2][0] + dx, 6)
|
||||
expect(previewed[2][1]).toBeCloseTo(SQUARE[2][1] + dy, 6)
|
||||
|
||||
// A tap on the selected zone opens its properties; the dialog stays.
|
||||
await canvas(page).scrollIntoViewIfNeeded()
|
||||
const inside = await clientOf(page, INSIDE.x + dx, INSIDE.y + dy)
|
||||
await tap(cdp, inside)
|
||||
const dialog = page.getByRole('dialog')
|
||||
await expect(dialog).toBeVisible()
|
||||
await page.waitForTimeout(450)
|
||||
await expect(dialog).toBeVisible()
|
||||
await page.keyboard.press('Escape')
|
||||
await expect(dialog).toHaveCount(0)
|
||||
|
||||
// A tap on a vertex chooses it; a tap inside then unchooses, no dialog.
|
||||
await canvas(page).scrollIntoViewIfNeeded()
|
||||
const corner = previewed[0]
|
||||
await tap(cdp, await clientOf(page, corner[0], corner[1]))
|
||||
const bubble = page.getByRole('button', { name: /^Retirer le sommet/ })
|
||||
await expect(bubble).toHaveCount(1)
|
||||
await tap(cdp, await clientOf(page, INSIDE.x + dx, INSIDE.y + dy))
|
||||
await expect(bubble).toHaveCount(0)
|
||||
await expect(dialog).toHaveCount(0)
|
||||
|
||||
// A new zone traced by finger closes on a tap 18 px from its first vertex (R-11).
|
||||
await button(page, 'editor.annotations.deselect').click()
|
||||
await toolButton(page, dict, 'zone').click()
|
||||
await canvas(page).scrollIntoViewIfNeeded()
|
||||
const first = await clientOf(page, 150, 600)
|
||||
// Quick taps, each within the absorber's 400 ms of the last: each one places.
|
||||
for (const [x, y] of [
|
||||
[150, 600],
|
||||
[300, 600],
|
||||
[300, 700],
|
||||
]) {
|
||||
await tap(cdp, await clientOf(page, x, y))
|
||||
}
|
||||
await expect(creationPanel(page)).toHaveCount(0)
|
||||
await tap(cdp, { x: first.x + 18, y: first.y })
|
||||
await expect(creationPanel(page)).toBeVisible()
|
||||
})
|
||||
})
|
||||
}
|
||||
@@ -1,5 +1,3 @@
|
||||
import { readFileSync } from 'node:fs'
|
||||
import { join } from 'node:path'
|
||||
import { fr } from '@/i18n/fr'
|
||||
import type { Page, TestInfo } from '@playwright/test'
|
||||
import { expect, expectAccessible, test } from '../support/browser'
|
||||
@@ -7,6 +5,8 @@ import { dropLateReplays, routeToSandbox } from '../support/sandbox'
|
||||
import {
|
||||
clientOf,
|
||||
editorActor,
|
||||
equineDrawing,
|
||||
equineShape,
|
||||
openEditor,
|
||||
pickAnnotation,
|
||||
seedDraft,
|
||||
@@ -23,47 +23,14 @@ import { expectNoShift } from '../support/layout'
|
||||
|
||||
const dict = fr
|
||||
const isPhone = (info: TestInfo) => info.project.name === 'chromium-375'
|
||||
const DRAFT = join(
|
||||
__dirname,
|
||||
'../../../../supabase/seed/anatomical-sheets/equine/draft',
|
||||
)
|
||||
const THORACIC = /Vertèbres thoraciques/
|
||||
// The side panel's content may change (U2 Task 6 moves it into a dialog).
|
||||
|
||||
interface Draft {
|
||||
vertebral_config: unknown
|
||||
references: unknown
|
||||
categories: unknown
|
||||
finding_zones: unknown
|
||||
views: { id: string; svg_asset_id: string | null }[]
|
||||
annotations: { view_id: string; kind: string }[]
|
||||
}
|
||||
|
||||
/** The equine draft's main view, its annotations and structures, on the seeded drawing. */
|
||||
function equineShape(document: Record<string, unknown>) {
|
||||
const draft = JSON.parse(
|
||||
readFileSync(join(DRAFT, 'document.json'), 'utf8'),
|
||||
) as Draft
|
||||
const [seeded] = document.views as Draft['views']
|
||||
const main = draft.views.find((view) => view.id === 'main')!
|
||||
Object.assign(document, {
|
||||
vertebral_config: draft.vertebral_config,
|
||||
references: draft.references,
|
||||
categories: draft.categories,
|
||||
finding_zones: draft.finding_zones,
|
||||
views: [{ ...main, svg_asset_id: seeded.svg_asset_id }],
|
||||
// The detail view is left out, so is the link that opens it.
|
||||
annotations: draft.annotations.filter(
|
||||
(a) => a.view_id === 'main' && a.kind !== 'detail_trigger',
|
||||
),
|
||||
})
|
||||
}
|
||||
|
||||
async function openThoracic(page: Page) {
|
||||
await page.setViewportSize({ width: 1280, height: 800 })
|
||||
const actor = await editorActor('fr')
|
||||
const seed = await seedDraft(actor, {
|
||||
drawing: readFileSync(join(DRAFT, 'assets/horse.svg'), 'utf8'),
|
||||
drawing: equineDrawing(),
|
||||
shape: equineShape,
|
||||
})
|
||||
await openEditor(page, dict, actor, seed.sheetId)
|
||||
|
||||
@@ -899,3 +899,42 @@ export const INKSCAPE_EXPORT = readFileSync(
|
||||
'../../../../crates/core/tests/fixtures/svg/exports/inkscape-1.4.3-inkscape-svg.svg',
|
||||
),
|
||||
)
|
||||
|
||||
/** The curated equine draft (document and drawing): a drawing and a document of real size. */
|
||||
const EQUINE_DRAFT = join(
|
||||
__dirname,
|
||||
'../../../../supabase/seed/anatomical-sheets/equine/draft',
|
||||
)
|
||||
|
||||
interface Draft {
|
||||
vertebral_config: unknown
|
||||
references: unknown
|
||||
categories: unknown
|
||||
finding_zones: unknown
|
||||
views: { id: string; svg_asset_id: string | null }[]
|
||||
annotations: { view_id: string; kind: string }[]
|
||||
}
|
||||
|
||||
/** The equine draft's main view, its annotations and structures, on the seeded drawing. */
|
||||
export function equineShape(document: Record<string, unknown>) {
|
||||
const draft = JSON.parse(
|
||||
readFileSync(join(EQUINE_DRAFT, 'document.json'), 'utf8'),
|
||||
) as Draft
|
||||
const [seeded] = document.views as Draft['views']
|
||||
const main = draft.views.find((view) => view.id === 'main')!
|
||||
Object.assign(document, {
|
||||
vertebral_config: draft.vertebral_config,
|
||||
references: draft.references,
|
||||
categories: draft.categories,
|
||||
finding_zones: draft.finding_zones,
|
||||
views: [{ ...main, svg_asset_id: seeded.svg_asset_id }],
|
||||
// The detail view is left out, so is the link that opens it.
|
||||
annotations: draft.annotations.filter(
|
||||
(a) => a.view_id === 'main' && a.kind !== 'detail_trigger',
|
||||
),
|
||||
})
|
||||
}
|
||||
|
||||
/** The equine main view's drawing, as a person would attach it. */
|
||||
export const equineDrawing = () =>
|
||||
readFileSync(join(EQUINE_DRAFT, 'assets/horse.svg'), 'utf8')
|
||||
@@ -0,0 +1,184 @@
|
||||
/**
|
||||
* The smoothness measure of U2 Task 8 (plan Task 8 Step 1), run by hand, never by a suite: a
|
||||
* timing assertion would flake on the shared sandbox. Chromium touch at 1 180 px, CPU × 4, a
|
||||
* 2 s drag of a vertex of « Vertèbres thoraciques » on the equine main view (the curated
|
||||
* draft's drawing and document, seeded per run as a new draft of its own: no existing sheet
|
||||
* or working copy is opened). It prints the median and the p95, in ms, from each
|
||||
* pointermove to the end of the next frame (after its style, layout and paint), loupe
|
||||
* included; the same drag with a mouse (no loupe) is the control.
|
||||
*
|
||||
* Run: MEASURE_DRAG=1 pnpm db:sandbox e2e-shell editor-measure-drag.spec.ts
|
||||
*/
|
||||
import type { BrowserContext, Page } from '@playwright/test'
|
||||
import { fr } from '@/i18n/fr'
|
||||
import { expect } from './browser'
|
||||
import {
|
||||
editorActor,
|
||||
equineDrawing,
|
||||
equineShape,
|
||||
openEditor,
|
||||
pickAnnotation,
|
||||
seedDraft,
|
||||
toolButton,
|
||||
} from './editor'
|
||||
|
||||
const DURATION_MS = 2_000
|
||||
const STEP_MS = 16
|
||||
const RADIUS_PX = 40
|
||||
const CPU_RATE = 4
|
||||
|
||||
export interface DragFigures {
|
||||
kind: 'touch' | 'mouse'
|
||||
samples: number
|
||||
/** Samples whose frame showed the loupe. */
|
||||
withLoupe: number
|
||||
/** From the event's own time stamp (input queueing included) to the frame's end. */
|
||||
fromEvent: { median: number; p95: number }
|
||||
/** From the first listener of the event to the frame's end: the frame's own work. */
|
||||
fromHandler: { median: number; p95: number }
|
||||
}
|
||||
|
||||
interface Sample {
|
||||
fromEvent: number
|
||||
fromHandler: number
|
||||
/** The loupe was on screen at the frame's end. */
|
||||
loupe: boolean
|
||||
}
|
||||
|
||||
/** A capture listener on the document: it runs before the application's own. */
|
||||
function startRecording(page: Page, kind: string) {
|
||||
return page.evaluate((pointerType) => {
|
||||
const scope = window as unknown as { __drag: Sample[] }
|
||||
scope.__drag = []
|
||||
const record = (event: PointerEvent) => {
|
||||
if (event.pointerType !== pointerType || event.buttons === 0) return
|
||||
const start = performance.now()
|
||||
requestAnimationFrame(() => {
|
||||
// The message runs after this frame's rendering: style, layout and paint.
|
||||
const channel = new MessageChannel()
|
||||
channel.port1.onmessage = () => {
|
||||
const end = performance.now()
|
||||
scope.__drag.push({
|
||||
fromEvent: end - event.timeStamp,
|
||||
fromHandler: end - start,
|
||||
loupe: document.querySelector('[data-testid="loupe"]') !== null,
|
||||
})
|
||||
}
|
||||
channel.port2.postMessage(0)
|
||||
})
|
||||
}
|
||||
document.addEventListener('pointermove', record, true)
|
||||
}, kind)
|
||||
}
|
||||
|
||||
const percentile = (sorted: number[], p: number) =>
|
||||
sorted[Math.min(sorted.length - 1, Math.floor((sorted.length - 1) * p))]
|
||||
|
||||
function summary(values: number[]) {
|
||||
const sorted = [...values].sort((a, b) => a - b)
|
||||
const round = (v: number) => Math.round(v * 10) / 10
|
||||
return {
|
||||
median: round(percentile(sorted, 0.5)),
|
||||
p95: round(percentile(sorted, 0.95)),
|
||||
}
|
||||
}
|
||||
|
||||
async function figures(page: Page, kind: DragFigures['kind']) {
|
||||
const samples = await page.evaluate(
|
||||
() => (window as unknown as { __drag: Sample[] }).__drag,
|
||||
)
|
||||
return {
|
||||
kind,
|
||||
samples: samples.length,
|
||||
withLoupe: samples.filter((s) => s.loupe).length,
|
||||
fromEvent: summary(samples.map((s) => s.fromEvent)),
|
||||
fromHandler: summary(samples.map((s) => s.fromHandler)),
|
||||
}
|
||||
}
|
||||
|
||||
/** The point of the circle the drag follows, `elapsed` ms after its start. */
|
||||
function pathAt(from: { x: number; y: number }, elapsed: number) {
|
||||
const angle = (2 * Math.PI * elapsed) / DURATION_MS
|
||||
return {
|
||||
x: from.x + RADIUS_PX * Math.sin(angle),
|
||||
y: from.y - RADIUS_PX * (1 - Math.cos(angle)),
|
||||
}
|
||||
}
|
||||
|
||||
type Mover = (at: { x: number; y: number }) => Promise<unknown>
|
||||
|
||||
/** Moves along the path for DURATION_MS, one move per STEP_MS at most. */
|
||||
async function follow(from: { x: number; y: number }, moveTo: Mover) {
|
||||
const start = Date.now()
|
||||
for (let elapsed = 0; elapsed < DURATION_MS; elapsed = Date.now() - start) {
|
||||
await moveTo(pathAt(from, elapsed))
|
||||
await new Promise((done) => setTimeout(done, STEP_MS))
|
||||
}
|
||||
}
|
||||
|
||||
async function vertexCentre(page: Page) {
|
||||
const box = (await page
|
||||
.getByRole('button', { name: 'Sommet 1', exact: true })
|
||||
.locator('[data-handle]')
|
||||
.boundingBox())!
|
||||
return { x: box.x + box.width / 2, y: box.y + box.height / 2 }
|
||||
}
|
||||
|
||||
async function touchDrag(page: Page, context: BrowserContext) {
|
||||
const cdp = await context.newCDPSession(page)
|
||||
const from = await vertexCentre(page)
|
||||
const send = (type: string, points: { x: number; y: number }[]) =>
|
||||
cdp.send('Input.dispatchTouchEvent', {
|
||||
type: type as 'touchStart',
|
||||
touchPoints: points.map((p) => ({ ...p, id: 0 })),
|
||||
})
|
||||
await send('touchStart', [from])
|
||||
await follow(from, (at) => send('touchMove', [at]))
|
||||
await send('touchEnd', [])
|
||||
}
|
||||
|
||||
async function mouseDrag(page: Page) {
|
||||
const from = await vertexCentre(page)
|
||||
await page.mouse.move(from.x, from.y)
|
||||
await page.mouse.down()
|
||||
await follow(from, (at) => page.mouse.move(at.x, at.y))
|
||||
await page.mouse.up()
|
||||
}
|
||||
|
||||
/** One measured drag of the same vertex, by `kind`, CPU × 4 while it runs. */
|
||||
async function measure(
|
||||
page: Page,
|
||||
context: BrowserContext,
|
||||
kind: DragFigures['kind'],
|
||||
): Promise<DragFigures> {
|
||||
const cdp = await context.newCDPSession(page)
|
||||
await page.getByTestId('annotation-canvas').scrollIntoViewIfNeeded()
|
||||
await startRecording(page, kind)
|
||||
await cdp.send('Emulation.setCPUThrottlingRate', { rate: CPU_RATE })
|
||||
try {
|
||||
if (kind === 'touch') await touchDrag(page, context)
|
||||
else await mouseDrag(page)
|
||||
} finally {
|
||||
await cdp.send('Emulation.setCPUThrottlingRate', { rate: 1 })
|
||||
}
|
||||
return figures(page, kind)
|
||||
}
|
||||
|
||||
/** Seeds its own equine-sized draft, opens it, selects the zone, measures touch then mouse. */
|
||||
export async function measureDrag(
|
||||
page: Page,
|
||||
context: BrowserContext,
|
||||
): Promise<DragFigures[]> {
|
||||
const actor = await editorActor('fr')
|
||||
const seed = await seedDraft(actor, {
|
||||
drawing: equineDrawing(),
|
||||
shape: equineShape,
|
||||
})
|
||||
await openEditor(page, fr, actor, seed.sheetId)
|
||||
await expect(toolButton(page, fr, 'point')).toBeEnabled()
|
||||
await pickAnnotation(page, fr, /Vertèbres thoraciques/)
|
||||
const touch = await measure(page, context, 'touch')
|
||||
// The drop committed the vertex; the mouse drags the same vertex from there.
|
||||
const mouse = await measure(page, context, 'mouse')
|
||||
return [touch, mouse]
|
||||
}
|
||||
Reference in new issue
Block a user