275 lines
12 KiB
JavaScript
275 lines
12 KiB
JavaScript
// R3 visual check (plan 2026-10-14 §3 O6): screenshots of the editor canvas in a real
|
|
// Chromium, then a pixel comparison of two captures (reference vs candidate).
|
|
//
|
|
// capture: node scripts/visual-canvas.mjs capture <base-url> <out-dir>
|
|
// compare: node scripts/visual-canvas.mjs compare <reference-dir> <candidate-dir>
|
|
// perf: node scripts/visual-canvas.mjs perf <base-url>
|
|
// (preview build; 4x CPU throttle: editor to first canvas, detail open, then 50
|
|
// detail open/close cycles with the JS heap and DOM node counts before and after)
|
|
// dom: node scripts/visual-canvas.mjs dom <base-url>
|
|
// (the live canvas trees of the main and head views, no state, against the R3 O1
|
|
// freeze apps/app/tests/fixtures/goldens/r3/canvas.<view>.json)
|
|
//
|
|
// Needs CHROME (an executable) and NODE_PATH pointing at a node_modules that holds
|
|
// playwright-core and pngjs, outside the repository (no project dependency). The base URL is
|
|
// a running dev server of the build to capture (the DEV origin, scripts/dev-env.sh).
|
|
// Each case opens the editor on a draft holding one observation of the demo report, so the
|
|
// canvas shows the states the editor shows when that observation is active.
|
|
import { mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs'
|
|
import { join, resolve } from 'node:path'
|
|
import { createRequire } from 'node:module'
|
|
|
|
const require = createRequire(import.meta.url)
|
|
const DEMO = resolve(import.meta.dirname, '../apps/app/tests/fixtures/report-v3.demo.json')
|
|
const VIEWPORTS = { desktop: { width: 1280, height: 800 }, phone: { width: 390, height: 844 } }
|
|
const SETTLE_MS = 600
|
|
// A differing pixel counts as anti-aliasing when its channels move by at most this much and it
|
|
// sits next to a contrast edge of the reference; anything else is a regression.
|
|
const AA_MAX_DELTA = 96
|
|
const EDGE_CONTRAST = 48
|
|
|
|
function cases() {
|
|
const demo = JSON.parse(readFileSync(DEMO, 'utf8'))
|
|
const one = (obs) => ({ ...demo, observations: obs ? [obs] : [] })
|
|
return [
|
|
{ name: 'none', report: one(null) },
|
|
...demo.observations.map((obs) => ({ name: obs.id, report: one(obs) })),
|
|
]
|
|
}
|
|
|
|
async function openEditor(page, base, report) {
|
|
await page.goto(`${base}/`)
|
|
await page.evaluate((draft) => {
|
|
sessionStorage.clear()
|
|
sessionStorage.setItem('osteo:disclaimer-shown', '1')
|
|
sessionStorage.setItem('osteo:draft', JSON.stringify(draft))
|
|
localStorage.setItem('osteo:locale', 'fr')
|
|
}, report)
|
|
await page.goto(`${base}/editor`)
|
|
await page.waitForSelector('.svg-canvas [data-anno-id="head-trigger"]')
|
|
await page.mouse.move(0, 0)
|
|
await page.waitForTimeout(SETTLE_MS)
|
|
}
|
|
|
|
async function shoot(locator, file) {
|
|
writeFileSync(file, await locator.screenshot({ animations: 'disabled' }))
|
|
}
|
|
|
|
async function capture(base, out) {
|
|
const { chromium } = require('playwright-core')
|
|
mkdirSync(out, { recursive: true })
|
|
const browser = await chromium.launch({ executablePath: process.env.CHROME })
|
|
const meta = { browser: browser.version(), base, at: new Date().toISOString() }
|
|
for (const [vp, size] of Object.entries(VIEWPORTS)) {
|
|
const page = await browser.newPage({ viewport: size, deviceScaleFactor: 1, locale: 'fr-FR' })
|
|
page.on('dialog', (d) => d.dismiss())
|
|
for (const c of cases()) {
|
|
await openEditor(page, base, c.report)
|
|
const main = page.locator('.svg-canvas').first()
|
|
await shoot(main, join(out, `${vp}.${c.name}.main.png`))
|
|
if (c.name === 'none') {
|
|
await page.locator('.svg-canvas [data-anno-id="hip"]').first().hover()
|
|
await page.waitForTimeout(SETTLE_MS)
|
|
await shoot(main, join(out, `${vp}.hover-hip.main.png`))
|
|
await page.mouse.move(0, 0)
|
|
}
|
|
await page.locator('.svg-canvas [data-anno-id="head-trigger"]').first().click({ force: true })
|
|
const head = page.locator('[role="dialog"] .svg-canvas')
|
|
await head.waitFor()
|
|
await page.waitForTimeout(SETTLE_MS)
|
|
await shoot(head, join(out, `${vp}.${c.name}.head.png`))
|
|
await page.keyboard.press('Escape')
|
|
}
|
|
await page.close()
|
|
}
|
|
await browser.close()
|
|
writeFileSync(join(out, 'meta.json'), `${JSON.stringify(meta, null, 2)}\n`)
|
|
console.log(`captured into ${out} (${meta.browser})`)
|
|
}
|
|
|
|
/** The live canvas as the R3 freeze writes trees (apps/app/tests/helpers/svgTree.ts). */
|
|
function liveTree(selector) {
|
|
const treeOf = (node) => {
|
|
if (node.nodeType === 3 || node.nodeType === 4) return { text: node.nodeValue ?? '' }
|
|
if (node.nodeType === 8) return { comment: node.nodeValue ?? '' }
|
|
if (node.nodeType === 7) return { pi: node.nodeName }
|
|
const attrs = {}
|
|
for (const name of Array.from(node.attributes, (a) => a.name).sort()) {
|
|
attrs[name] = node.getAttribute(name) ?? ''
|
|
}
|
|
return { ns: node.namespaceURI, name: node.localName, attrs, children: Array.from(node.childNodes, treeOf) }
|
|
}
|
|
return treeOf(document.querySelector(selector))
|
|
}
|
|
|
|
/**
|
|
* Owner decision 2026-10-15: an unnamed trigger carries the opened view's name per language;
|
|
* the freeze has the French name twice. Applied to the frozen tree before comparing
|
|
* (apps/app/tests/helpers/svgTree.ts withTriggerNamesPerLanguage).
|
|
*/
|
|
function declared(frozen) {
|
|
const doc = JSON.parse(readFileSync(resolve(import.meta.dirname,
|
|
'../supabase/seed/anatomical-sheets/equine/draft/document.json'), 'utf8'))
|
|
const views = doc.views.map((v) => ({ id: v.id, fr: v.name.fr, en: v.name.en }))
|
|
const visit = (n) => {
|
|
if (typeof n !== 'object' || n === null) return
|
|
const view = views.find((v) => v.id === n.attrs?.['data-anno-opens-view'])
|
|
if (view && n.attrs?.['data-anno-name-en'] === view.fr) n.attrs['data-anno-name-en'] = view.en
|
|
for (const v of views) if (n.text === `${v.fr} / ${v.fr}`) n.text = `${v.fr} / ${v.en}`
|
|
n.children?.forEach(visit)
|
|
}
|
|
visit(frozen)
|
|
return frozen
|
|
}
|
|
|
|
async function dom(base) {
|
|
const { chromium } = require('playwright-core')
|
|
const goldens = resolve(import.meta.dirname, '../apps/app/tests/fixtures/goldens/r3')
|
|
const browser = await chromium.launch({ executablePath: process.env.CHROME })
|
|
const page = await browser.newPage({ viewport: VIEWPORTS.desktop, locale: 'fr-FR' })
|
|
page.on('dialog', (d) => d.dismiss())
|
|
await openEditor(page, base, cases()[0].report)
|
|
const trees = { main: await page.evaluate(liveTree, '.svg-canvas svg') }
|
|
await page.locator('.svg-canvas [data-anno-id="head-trigger"]').first().click({ force: true })
|
|
await page.locator('[role="dialog"] .svg-canvas svg').waitFor()
|
|
trees.head = await page.evaluate(liveTree, '[role="dialog"] .svg-canvas svg')
|
|
await browser.close()
|
|
let failed = 0
|
|
for (const view of ['main', 'head']) {
|
|
const frozen = readFileSync(join(goldens, `canvas.${view}.json`), 'utf8')
|
|
const same = JSON.stringify(trees[view]) === JSON.stringify(declared(JSON.parse(frozen)))
|
|
if (!same) failed++
|
|
console.log(`${same ? 'equal ' : 'DIFFERENT'} ${view} canvas vs the R3 O1 freeze (${browser.version()})`)
|
|
}
|
|
process.exitCode = failed > 0 ? 1 : 0
|
|
}
|
|
|
|
async function counters(cdp) {
|
|
await cdp.send('HeapProfiler.collectGarbage')
|
|
const heap = await cdp.send('Runtime.getHeapUsage')
|
|
const domCounters = await cdp.send('Memory.getDOMCounters')
|
|
return { heapMiB: heap.usedSize / 1024 / 1024, nodes: domCounters.nodes }
|
|
}
|
|
|
|
async function timed(fn) {
|
|
const started = Date.now()
|
|
await fn()
|
|
return Date.now() - started
|
|
}
|
|
|
|
/** In the page: the browser's share of a canvas build (parse + import of the composed text). */
|
|
function browserBuildMs() {
|
|
const text = new XMLSerializer().serializeToString(document.querySelector('.svg-canvas svg'))
|
|
const runs = []
|
|
for (let i = 0; i < 10; i++) {
|
|
const started = performance.now()
|
|
const parsed = new DOMParser().parseFromString(text, 'image/svg+xml')
|
|
document.importNode(parsed.documentElement, true)
|
|
runs.push(performance.now() - started)
|
|
}
|
|
runs.sort((a, b) => a - b)
|
|
return +runs[5].toFixed(1)
|
|
}
|
|
|
|
async function perf(base) {
|
|
const { chromium } = require('playwright-core')
|
|
const browser = await chromium.launch({ executablePath: process.env.CHROME })
|
|
const page = await browser.newPage({ viewport: VIEWPORTS.desktop, locale: 'fr-FR' })
|
|
page.on('dialog', (d) => d.dismiss())
|
|
const cdp = await page.context().newCDPSession(page)
|
|
await cdp.send('Emulation.setCPUThrottlingRate', { rate: 4 })
|
|
const trigger = page.locator('.svg-canvas [data-anno-id="head-trigger"]').first()
|
|
const head = page.locator('[role="dialog"] .svg-canvas [data-layer]')
|
|
const report = cases()[1].report
|
|
await page.goto(`${base}/`)
|
|
await page.evaluate((draft) => {
|
|
sessionStorage.setItem('osteo:disclaimer-shown', '1')
|
|
sessionStorage.setItem('osteo:draft', JSON.stringify(draft))
|
|
}, report)
|
|
const editorMs = await timed(async () => {
|
|
await page.goto(`${base}/editor`)
|
|
await page.waitForSelector('.svg-canvas [data-layer]')
|
|
})
|
|
const openMs = await timed(async () => {
|
|
await trigger.click({ force: true })
|
|
await head.waitFor()
|
|
})
|
|
const parseMs = await page.evaluate(browserBuildMs)
|
|
await page.keyboard.press('Escape')
|
|
await head.waitFor({ state: 'detached' })
|
|
const before = await counters(cdp)
|
|
for (let i = 0; i < 50; i++) {
|
|
await trigger.click({ force: true })
|
|
await head.waitFor()
|
|
await page.keyboard.press('Escape')
|
|
await head.waitFor({ state: 'detached' })
|
|
}
|
|
const after = await counters(cdp)
|
|
console.log(JSON.stringify({ browser: browser.version(), cpuThrottle: 4, editorToCanvasMs: editorMs,
|
|
detailOpenMs: openMs, browserParseImportMs: parseMs, before, after,
|
|
heapGrowthMiB: +(after.heapMiB - before.heapMiB).toFixed(2), nodeGrowth: after.nodes - before.nodes }, null, 2))
|
|
await browser.close()
|
|
}
|
|
|
|
function pixel(png, x, y) {
|
|
const i = (png.width * y + x) << 2
|
|
return [png.data[i], png.data[i + 1], png.data[i + 2], png.data[i + 3]]
|
|
}
|
|
|
|
const delta = (a, b) => Math.max(...a.map((v, k) => Math.abs(v - b[k])))
|
|
|
|
function nearEdge(png, x, y) {
|
|
const here = pixel(png, x, y)
|
|
for (let dy = -1; dy <= 1; dy++) {
|
|
for (let dx = -1; dx <= 1; dx++) {
|
|
const nx = x + dx
|
|
const ny = y + dy
|
|
if (nx < 0 || ny < 0 || nx >= png.width || ny >= png.height) continue
|
|
if (delta(here, pixel(png, nx, ny)) >= EDGE_CONTRAST) return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
function comparePng(refFile, candFile) {
|
|
const { PNG } = require('pngjs')
|
|
const ref = PNG.sync.read(readFileSync(refFile))
|
|
const cand = PNG.sync.read(readFileSync(candFile))
|
|
if (ref.width !== cand.width || ref.height !== cand.height) {
|
|
return { verdict: 'regression', reason: `size ${ref.width}x${ref.height} vs ${cand.width}x${cand.height}` }
|
|
}
|
|
let diff = 0
|
|
let regressions = 0
|
|
let maxDelta = 0
|
|
for (let y = 0; y < ref.height; y++) {
|
|
for (let x = 0; x < ref.width; x++) {
|
|
const d = delta(pixel(ref, x, y), pixel(cand, x, y))
|
|
if (d === 0) continue
|
|
diff++
|
|
maxDelta = Math.max(maxDelta, d)
|
|
if (d > AA_MAX_DELTA || !nearEdge(ref, x, y)) regressions++
|
|
}
|
|
}
|
|
const verdict = diff === 0 ? 'identical' : regressions === 0 ? 'anti-aliasing' : 'regression'
|
|
return { verdict, diff, regressions, maxDelta, pixels: ref.width * ref.height }
|
|
}
|
|
|
|
function compare(refDir, candDir) {
|
|
const files = readdirSync(refDir).filter((f) => f.endsWith('.png')).sort()
|
|
const results = files.map((f) => ({ file: f, ...comparePng(join(refDir, f), join(candDir, f)) }))
|
|
for (const r of results) console.log(`${r.verdict.padEnd(13)} ${r.file} ${r.diff ?? ''} ${r.reason ?? ''}`)
|
|
const failed = results.filter((r) => r.verdict === 'regression').length
|
|
console.log(`${results.length} images, ${failed} regression(s)`)
|
|
process.exitCode = failed > 0 ? 1 : 0
|
|
}
|
|
|
|
const [mode, a, b] = process.argv.slice(2)
|
|
if (mode === 'capture' && a && b) await capture(a, b)
|
|
else if (mode === 'compare' && a && b) compare(a, b)
|
|
else if (mode === 'dom' && a) await dom(a)
|
|
else if (mode === 'perf' && a) await perf(a)
|
|
else {
|
|
console.error('usage: visual-canvas.mjs capture <base-url> <out-dir> | compare <ref-dir> <cand-dir> | dom <base-url> | perf <base-url>')
|
|
process.exitCode = 2
|
|
}
|