feat(app): application on the canonical sheet — report v3 store with v2 draft migration, bundled SheetProvider (SHEET_BUNDLE), annotation layer rendered from the document, zone interaction service, pickers and cards on the sheet index, PDF v3 export with v2 archive import; legacy registry, matchers, editors and assets removed
This commit is contained in:
1 parent
0a17e390cf
commit
ce2ec26112
114 files changed
+3560
-14637
No files matched your search
+6
-1
@@ -17,7 +17,12 @@ COPY packages/supabase/package.json packages/supabase/
|
||||
|
||||
RUN pnpm install --frozen-lockfile
|
||||
|
||||
# Copy source and build the private app only
|
||||
# Copy source and build the private app only.
|
||||
# SHEET_BUNDLE=draft embeds the reference equine DRAFT (medically unvalidated)
|
||||
# into the bundle for a preview deployment; the default image carries no sheet
|
||||
# (BDR-037, Step 5 D2): `docker build --build-arg SHEET_BUNDLE=draft .`
|
||||
ARG SHEET_BUNDLE=none
|
||||
ENV SHEET_BUNDLE=$SHEET_BUNDLE
|
||||
COPY . .
|
||||
RUN pnpm --filter @faunosteo/app build
|
||||
|
||||
|
||||
@@ -11,8 +11,7 @@
|
||||
"typecheck": "tsc -p tsconfig.json --noEmit",
|
||||
"test": "vitest",
|
||||
"test:run": "vitest run",
|
||||
"lint": "eslint . --max-warnings 0",
|
||||
"scaffold:species": "node scripts/scaffold-species.mjs"
|
||||
"lint": "eslint . --max-warnings 0"
|
||||
},
|
||||
"dependencies": {
|
||||
"@faunosteo/anatomy": "workspace:*",
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -1,238 +0,0 @@
|
||||
#!/usr/bin/env node
|
||||
/**
|
||||
* Scaffolds a new species: prompts for the few required values then
|
||||
* writes the boilerplate that the auto-discovery registry expects.
|
||||
*
|
||||
* Run via: pnpm scaffold:species
|
||||
* or: node scripts/scaffold-species.mjs
|
||||
*
|
||||
* The script never touches existing files — it refuses to write if any
|
||||
* of the targets already exist, so you can rerun it after fixing typos
|
||||
* without losing work. SVG assets are NOT created; drop them in
|
||||
* `public/species/<assetFolder>/` yourself after the script finishes.
|
||||
*/
|
||||
|
||||
import { existsSync } from 'node:fs'
|
||||
import { mkdir, writeFile } from 'node:fs/promises'
|
||||
import { dirname, resolve } from 'node:path'
|
||||
import { fileURLToPath } from 'node:url'
|
||||
import readline from 'node:readline/promises'
|
||||
import { stdin as input, stdout as output } from 'node:process'
|
||||
|
||||
const HERE = dirname(fileURLToPath(import.meta.url))
|
||||
const PROJECT_ROOT = resolve(HERE, '..')
|
||||
|
||||
const rl = readline.createInterface({ input, output })
|
||||
|
||||
async function ask(question, fallback) {
|
||||
const suffix = fallback === undefined ? '' : ` [${fallback}]`
|
||||
const raw = (await rl.question(`${question}${suffix}: `)).trim()
|
||||
return raw || (fallback ?? '')
|
||||
}
|
||||
|
||||
async function askRequired(question, validate) {
|
||||
while (true) {
|
||||
const v = (await rl.question(`${question}: `)).trim()
|
||||
if (!v) {
|
||||
console.log(' (required)')
|
||||
continue
|
||||
}
|
||||
if (validate) {
|
||||
const err = validate(v)
|
||||
if (err) {
|
||||
console.log(` ${err}`)
|
||||
continue
|
||||
}
|
||||
}
|
||||
return v
|
||||
}
|
||||
}
|
||||
|
||||
async function askPositiveInt(question, fallback) {
|
||||
while (true) {
|
||||
const v = await ask(question, String(fallback))
|
||||
const n = Number(v)
|
||||
if (Number.isInteger(n) && n > 0) return n
|
||||
console.log(' enter a positive integer')
|
||||
}
|
||||
}
|
||||
|
||||
function isKebab(s) {
|
||||
return /^[a-z][a-z0-9-]*$/.test(s)
|
||||
}
|
||||
|
||||
function capitalize(s) {
|
||||
return s.charAt(0).toUpperCase() + s.slice(1)
|
||||
}
|
||||
|
||||
function indexTs({ id, labelFr, labelEn, mainSvgPath, details, formulaConstName }) {
|
||||
const detailLines = details
|
||||
.map((d) => ` ${d.key}: '${d.path}',`)
|
||||
.join('\n')
|
||||
return `import type { SpeciesManifest } from '@/domain/species/types'
|
||||
import { ${formulaConstName} } from './vertebrae'
|
||||
|
||||
const ${id}: SpeciesManifest = {
|
||||
id: '${id}',
|
||||
labelFr: '${labelFr.replace(/'/g, "\\'")}',
|
||||
labelEn: '${labelEn.replace(/'/g, "\\'")}',
|
||||
mainSvg: '${mainSvgPath}',
|
||||
details: {
|
||||
${detailLines}
|
||||
},
|
||||
vertebralFormula: ${formulaConstName},
|
||||
findings: () => import('./pathologies'),
|
||||
}
|
||||
|
||||
// Default export is the convention picked up by the registry's
|
||||
// import.meta.glob() auto-discovery.
|
||||
export default ${id}
|
||||
`
|
||||
}
|
||||
|
||||
function vertebraeTs({ formulaConstName, labelFr, formula }) {
|
||||
return `import type { VertebralFormula } from '@/domain/species/types'
|
||||
|
||||
/** Vertebral formula for ${labelFr}. Adjust to species-specific anatomy. */
|
||||
export const ${formulaConstName}: VertebralFormula = {
|
||||
C: ${formula.C},
|
||||
T: ${formula.T},
|
||||
L: ${formula.L},
|
||||
S: ${formula.S},
|
||||
Cd: ${formula.Cd},
|
||||
}
|
||||
`
|
||||
}
|
||||
|
||||
function pathologiesTs() {
|
||||
return `import {
|
||||
SpeciesFindingsSchema,
|
||||
type SpeciesFindings,
|
||||
} from '@/domain/schema/findings'
|
||||
import data from './pathologies.json'
|
||||
|
||||
const FINDINGS: SpeciesFindings = SpeciesFindingsSchema.parse(data)
|
||||
|
||||
export default FINDINGS
|
||||
`
|
||||
}
|
||||
|
||||
function pathologiesJsonTemplate({ id, labelFr, labelEn }) {
|
||||
return JSON.stringify(
|
||||
{
|
||||
schema_version: '1.1',
|
||||
scope_disclaimer:
|
||||
"Les éléments listés correspondent au périmètre légal de l'ostéopathie animale : dysfonctions ostéopathiques palpées, observations cliniques et motifs de consultation. Aucun diagnostic médical n'est posé. Toute pathologie organique relève du vétérinaire.",
|
||||
species: {
|
||||
id,
|
||||
name_fr: labelFr,
|
||||
name_en: labelEn,
|
||||
},
|
||||
zones: {},
|
||||
},
|
||||
null,
|
||||
2,
|
||||
)
|
||||
}
|
||||
|
||||
async function collectDetails() {
|
||||
const details = []
|
||||
console.log('\nDetail popup SVGs (optional — leave key blank to stop).')
|
||||
console.log(' Each "key" must match a data-anno-opens-detail value on a hitbox in the main SVG.')
|
||||
for (;;) {
|
||||
const key = (await rl.question(' detail key (e.g. head, patte): ')).trim()
|
||||
if (!key) return details
|
||||
if (!isKebab(key)) {
|
||||
console.log(' → key must be kebab-case (lowercase, hyphen-separated). Try again.')
|
||||
continue
|
||||
}
|
||||
const path = await askRequired(
|
||||
` detail SVG path for "${key}" (e.g. /species/canine/Dog_head.svg)`,
|
||||
(v) => (v.startsWith('/species/') ? '' : ' path must start with /species/'),
|
||||
)
|
||||
details.push({ key, path })
|
||||
}
|
||||
}
|
||||
|
||||
async function main() {
|
||||
console.log('\nZoosteo — new species scaffold')
|
||||
console.log('-----------------------------------\n')
|
||||
|
||||
const id = await askRequired(
|
||||
'species id (kebab-case, e.g. canine, feline, bovine)',
|
||||
(v) => (isKebab(v) ? '' : 'must be kebab-case (lowercase letters / digits / hyphens; start with a letter)'),
|
||||
)
|
||||
const labelFr = await askRequired('display label (FR), e.g. "Chien"')
|
||||
const labelEn = await ask('display label (EN), e.g. "Dog"', capitalize(id))
|
||||
const assetFolder = await ask(
|
||||
'public asset folder under /species/',
|
||||
id,
|
||||
)
|
||||
const mainSvgFile = await askRequired(
|
||||
`main SVG filename in /public/species/${assetFolder}/ (e.g. Dog.svg)`,
|
||||
)
|
||||
const mainSvgPath = `/species/${assetFolder}/${mainSvgFile}`
|
||||
|
||||
const details = await collectDetails()
|
||||
|
||||
console.log('\nVertebral formula (counts per region):')
|
||||
const formula = {
|
||||
C: await askPositiveInt(' cervical (C)', 7),
|
||||
T: await askPositiveInt(' thoracic (T)', 13),
|
||||
L: await askPositiveInt(' lumbar (L)', 6),
|
||||
S: await askPositiveInt(' sacral (S)', 5),
|
||||
Cd: await askPositiveInt(' caudal (Cd)', 18),
|
||||
}
|
||||
|
||||
const formulaConstName = `${id.replace(/-/g, '_').toUpperCase()}_VERTEBRAL_FORMULA`
|
||||
const speciesDir = resolve(PROJECT_ROOT, 'src/domain/species', id)
|
||||
const targets = {
|
||||
'index.ts': indexTs({ id, labelFr, labelEn, mainSvgPath, details, formulaConstName }),
|
||||
'vertebrae.ts': vertebraeTs({ formulaConstName, labelFr, formula }),
|
||||
'pathologies.ts': pathologiesTs(),
|
||||
'pathologies.json': pathologiesJsonTemplate({ id, labelFr, labelEn }),
|
||||
}
|
||||
|
||||
// Refuse to clobber.
|
||||
for (const file of Object.keys(targets)) {
|
||||
const p = resolve(speciesDir, file)
|
||||
if (existsSync(p)) {
|
||||
console.error(`\n✖ ${p} already exists. Aborting to protect existing work.`)
|
||||
process.exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
await mkdir(speciesDir, { recursive: true })
|
||||
for (const [file, body] of Object.entries(targets)) {
|
||||
await writeFile(resolve(speciesDir, file), body)
|
||||
}
|
||||
|
||||
const publicDir = resolve(PROJECT_ROOT, 'public/species', assetFolder)
|
||||
await mkdir(publicDir, { recursive: true })
|
||||
|
||||
console.log(`\n✓ Created src/domain/species/${id}/`)
|
||||
for (const file of Object.keys(targets)) console.log(` - ${file}`)
|
||||
console.log(`✓ Ensured public/species/${assetFolder}/ exists`)
|
||||
|
||||
console.log('\nNext steps:')
|
||||
console.log(` 1. Drop your SVG assets into public/species/${assetFolder}/`)
|
||||
console.log(` - main: ${mainSvgFile}`)
|
||||
for (const d of details) {
|
||||
const file = d.path.split('/').pop()
|
||||
console.log(` - detail "${d.key}": ${file}`)
|
||||
}
|
||||
console.log(` 2. Author the findings tree in src/domain/species/${id}/pathologies.json`)
|
||||
console.log(` (schema documented in src/domain/schema/findings.ts).`)
|
||||
console.log(` 3. Adjust the vertebral counts in vertebrae.ts if needed.`)
|
||||
console.log(` 4. Run: pnpm typecheck && pnpm test:run && pnpm dev`)
|
||||
console.log(' The new species will appear automatically in the animal picker.\n')
|
||||
}
|
||||
|
||||
main()
|
||||
.catch((err) => {
|
||||
console.error('Scaffold failed:', err)
|
||||
process.exit(1)
|
||||
})
|
||||
.finally(() => {
|
||||
rl.close()
|
||||
})
|
||||
@@ -0,0 +1,97 @@
|
||||
import {
|
||||
createLayerElement,
|
||||
renderAnnotationLayer,
|
||||
viewBoxOf,
|
||||
} from '@faunosteo/anatomy/render'
|
||||
import type { SheetView } from '@faunosteo/domain'
|
||||
import type { SheetIndex } from '@/services/sheetIndex'
|
||||
|
||||
/**
|
||||
* Builds the inline SVG of one view: the sheet's drawing (sanitised asset
|
||||
* text) framed on the view's box, plus the annotation layer generated from
|
||||
* the document. The drawing is parsed once per asset and cloned per view.
|
||||
*/
|
||||
|
||||
const SVG_NS = 'http://www.w3.org/2000/svg'
|
||||
const FORBIDDEN_TAGS = ['script', 'foreignObject', 'iframe', 'object', 'embed']
|
||||
|
||||
export type ViewStates = ReadonlyMap<string, 'current'>
|
||||
|
||||
/** Drops scripts, embedded documents, event handlers and script URLs (LRN-025). */
|
||||
export function sanitizeSvg(root: Element): void {
|
||||
for (const tag of FORBIDDEN_TAGS) {
|
||||
for (const el of Array.from(root.getElementsByTagName(tag))) el.remove()
|
||||
}
|
||||
for (const el of Array.from(root.querySelectorAll('*'))) {
|
||||
for (const attr of Array.from(el.attributes)) {
|
||||
const name = attr.name.toLowerCase()
|
||||
const value = attr.value.trim().toLowerCase()
|
||||
if (name.startsWith('on') || value.startsWith('javascript:')) {
|
||||
el.removeAttribute(attr.name)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export function parseDrawing(svgText: string): SVGSVGElement {
|
||||
const doc = new DOMParser().parseFromString(svgText, 'image/svg+xml')
|
||||
if (doc.querySelector('parsererror')) throw new Error('invalid SVG asset')
|
||||
const root = doc.documentElement
|
||||
if (root.tagName.toLowerCase() !== 'svg')
|
||||
throw new Error('asset root is not <svg>')
|
||||
sanitizeSvg(root)
|
||||
return root as unknown as SVGSVGElement
|
||||
}
|
||||
|
||||
const parsed = new Map<string, SVGSVGElement>()
|
||||
|
||||
function drawingOf(index: SheetIndex, assetId: string): SVGSVGElement {
|
||||
const key = `${index.sheet.ref.documentSha256}:${assetId}`
|
||||
let root = parsed.get(key)
|
||||
if (!root) {
|
||||
const text = index.sheet.assets[assetId]
|
||||
if (text === undefined) throw new Error(`asset ${assetId} not bundled`)
|
||||
root = parseDrawing(text)
|
||||
parsed.set(key, root)
|
||||
}
|
||||
return root
|
||||
}
|
||||
|
||||
/** The asset a view draws: its own, else its parent's (a crop). */
|
||||
export function assetOfView(index: SheetIndex, view: SheetView): string {
|
||||
if (view.svg_asset_id) return view.svg_asset_id
|
||||
if (view.kind === 'detail') {
|
||||
const parent = index.view(view.parent_view_id)
|
||||
if (parent) return assetOfView(index, parent)
|
||||
}
|
||||
throw new Error(`view ${view.id} has no asset`)
|
||||
}
|
||||
|
||||
export function buildViewSvg(
|
||||
index: SheetIndex,
|
||||
viewId: string,
|
||||
states: ViewStates,
|
||||
): SVGSVGElement {
|
||||
const view = index.view(viewId)
|
||||
if (!view) throw new Error(`unknown view ${viewId}`)
|
||||
const source = drawingOf(index, assetOfView(index, view))
|
||||
const svg = document.createElementNS(SVG_NS, 'svg')
|
||||
for (const attr of Array.from(source.attributes)) {
|
||||
if (attr.name === 'width' || attr.name === 'height') continue
|
||||
svg.setAttribute(attr.name, attr.value)
|
||||
}
|
||||
svg.setAttribute(
|
||||
'viewBox',
|
||||
viewBoxOf(view) ?? source.getAttribute('viewBox') ?? '0 0 100 100',
|
||||
)
|
||||
for (const child of Array.from(source.childNodes)) {
|
||||
svg.appendChild(document.importNode(child, true))
|
||||
}
|
||||
const layer = renderAnnotationLayer({
|
||||
document: index.sheet.document,
|
||||
viewId,
|
||||
states,
|
||||
})
|
||||
svg.appendChild(createLayerElement(document, layer) as unknown as Node)
|
||||
return svg
|
||||
}
|
||||
@@ -1,19 +0,0 @@
|
||||
import type { Locale } from '@/i18n/types'
|
||||
import { pickLocaleLabel } from '@/i18n/pickLocaleLabel'
|
||||
import type { Bone } from './types'
|
||||
|
||||
/**
|
||||
* Resolves the user-facing label for an anatomical zone given the active
|
||||
* locale. Falls back to the opposite language when the requested one is
|
||||
* missing (some SVG hitboxes carry only `data-anno-name-fr`), then to the
|
||||
* provided fallback (typically the raw boneId) so the UI never renders
|
||||
* an empty label.
|
||||
*/
|
||||
export function boneLabel(
|
||||
bone: Bone | undefined,
|
||||
locale: Locale,
|
||||
fallback: string,
|
||||
): string {
|
||||
if (!bone) return fallback
|
||||
return pickLocaleLabel(bone.fr, bone.en, locale, fallback)
|
||||
}
|
||||
@@ -1,107 +0,0 @@
|
||||
import { SvgConventionError } from './types'
|
||||
import type { Bone, BoneCategory } from './types'
|
||||
|
||||
/**
|
||||
* Validates that an annotated SVG element carries the two attributes the
|
||||
* application needs to wire it up: a stable id (`data-anno-id`) and a
|
||||
* category bucket (`data-anno-category`). Labels (`data-anno-name-fr/en`)
|
||||
* and the popup trigger (`data-anno-opens-detail`) are optional and
|
||||
* checked only at use-site.
|
||||
*
|
||||
* The category value itself is opaque to the application — any non-empty
|
||||
* string is accepted. New SVGs are free to introduce new categories
|
||||
* without touching this parser.
|
||||
*/
|
||||
function validateBoneElement(el: Element): void {
|
||||
const boneId = el.getAttribute('data-anno-id') ?? ''
|
||||
if (!boneId) {
|
||||
throw new SvgConventionError(
|
||||
'Element with missing data-anno-id',
|
||||
boneId,
|
||||
'data-anno-id',
|
||||
)
|
||||
}
|
||||
const cat = el.getAttribute('data-anno-category') ?? ''
|
||||
if (!cat) {
|
||||
throw new SvgConventionError(
|
||||
`Element data-anno-id="${boneId}" missing attribute data-anno-category`,
|
||||
boneId,
|
||||
'data-anno-category',
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses an SVG document and returns a map of `data-anno-id` → Bone.
|
||||
*
|
||||
* Every element carrying `data-anno-id` is collected. Multiple elements
|
||||
* may share the same id (e.g. hitbox + visible layer); they all end up
|
||||
* grouped under the same Bone with all elements in `els`.
|
||||
*
|
||||
* Throws `SvgConventionError` only on the two required attributes
|
||||
* (`data-anno-id`, `data-anno-category`). Labels are optional.
|
||||
*/
|
||||
export function parseSvgBones(svgRoot: SVGSVGElement): Map<string, Bone> {
|
||||
const map = new Map<string, Bone>()
|
||||
const all = svgRoot.querySelectorAll<Element>('[data-anno-id]')
|
||||
all.forEach((el) => {
|
||||
validateBoneElement(el)
|
||||
const id = el.getAttribute('data-anno-id') as string
|
||||
const fr = el.getAttribute('data-anno-name-fr') ?? ''
|
||||
const en = el.getAttribute('data-anno-name-en') ?? ''
|
||||
const category = el.getAttribute('data-anno-category') as BoneCategory
|
||||
const opensDetail =
|
||||
el.getAttribute('data-anno-opens-detail') ?? undefined
|
||||
const special = el.getAttribute('data-anno-special') ?? undefined
|
||||
const lateral = (el.getAttribute('data-anno-lateral') ?? undefined) as
|
||||
| 'bilateral'
|
||||
| 'unpaired'
|
||||
| undefined
|
||||
|
||||
const existing = map.get(id)
|
||||
if (existing) {
|
||||
existing.els.push(el)
|
||||
if (opensDetail && !existing.opensDetail) {
|
||||
existing.opensDetail = opensDetail
|
||||
}
|
||||
if (special && !existing.special) {
|
||||
existing.special = special
|
||||
}
|
||||
if (lateral && !existing.lateral) {
|
||||
existing.lateral = lateral
|
||||
}
|
||||
if (!existing.fr && fr) existing.fr = fr
|
||||
if (!existing.en && en) existing.en = en
|
||||
} else {
|
||||
map.set(id, {
|
||||
id,
|
||||
fr,
|
||||
en,
|
||||
category,
|
||||
opensDetail,
|
||||
special,
|
||||
lateral,
|
||||
els: [el],
|
||||
})
|
||||
}
|
||||
})
|
||||
return map
|
||||
}
|
||||
|
||||
/**
|
||||
* Walks up from `event.target` to find the nearest element carrying
|
||||
* `data-anno-id`. Returns null when the click did not land on an
|
||||
* annotated element.
|
||||
*/
|
||||
export function getBoneIdFromEvent(event: Event): string | null {
|
||||
return getAnnotatedElement(event)?.getAttribute('data-anno-id') || null
|
||||
}
|
||||
|
||||
export function getAnnotatedElement(event: Event): Element | null {
|
||||
let node = event.target as Element | null
|
||||
while (node && node.nodeType === 1) {
|
||||
if (node.hasAttribute('data-anno-id')) return node
|
||||
node = node.parentElement
|
||||
}
|
||||
return null
|
||||
}
|
||||
@@ -1,17 +0,0 @@
|
||||
export async function loadSvg(publicPath: string): Promise<SVGSVGElement> {
|
||||
const resp = await fetch(publicPath)
|
||||
if (!resp.ok) {
|
||||
throw new Error(`Failed to load SVG ${publicPath}: HTTP ${resp.status}`)
|
||||
}
|
||||
const text = await resp.text()
|
||||
const doc = new DOMParser().parseFromString(text, 'image/svg+xml')
|
||||
const parseErr = doc.querySelector('parsererror')
|
||||
if (parseErr) {
|
||||
throw new Error(`Invalid SVG at ${publicPath}: ${parseErr.textContent}`)
|
||||
}
|
||||
const root = doc.documentElement
|
||||
if (root.tagName.toLowerCase() !== 'svg') {
|
||||
throw new Error(`Root element of ${publicPath} is not <svg>`)
|
||||
}
|
||||
return root as unknown as SVGSVGElement
|
||||
}
|
||||
@@ -1,55 +0,0 @@
|
||||
/**
|
||||
* `data-anno-category` is a free-form string supplied by the SVG.
|
||||
*
|
||||
* The application never branches on category values — it treats every
|
||||
* annotation the same way. Categories are kept around because they're
|
||||
* useful for grouping and future filtering, but no code path here may
|
||||
* rely on a closed set.
|
||||
*/
|
||||
export type BoneCategory = string
|
||||
|
||||
/**
|
||||
* Logical annotation as parsed from an SVG. All DOM elements sharing the
|
||||
* same `data-anno-id` are grouped into one Bone. `id` is the persisted
|
||||
* identifier surfaced in the report JSON contract
|
||||
* (`ObservationZone.boneId`); keep it stable across SVG renames.
|
||||
*/
|
||||
export interface Bone {
|
||||
id: string
|
||||
/** French label from data-anno-name-fr — may be empty for opens-detail-only triggers */
|
||||
fr: string
|
||||
/** English label from data-anno-name-en — may be empty */
|
||||
en: string
|
||||
/** Raw value from data-anno-category — opaque to the application */
|
||||
category: BoneCategory
|
||||
/** Detail popup id from data-anno-opens-detail, if present */
|
||||
opensDetail?: string
|
||||
/**
|
||||
* Free-form behavior hint from `data-anno-special`.
|
||||
*
|
||||
* Known values consumed by the application:
|
||||
* - `vertebral-precision`: clicking the zone opens VertebraPicker.
|
||||
*
|
||||
* Opaque to the parser; new values are accepted without code changes.
|
||||
*/
|
||||
special?: string
|
||||
/** Laterality hint from data-anno-lateral — bilateral or unpaired */
|
||||
lateral?: 'bilateral' | 'unpaired'
|
||||
/** All DOM elements carrying this annotation (used for colorization) */
|
||||
els: Element[]
|
||||
}
|
||||
|
||||
/** Visual state applied to SVG elements (active-observation highlight). */
|
||||
export type BoneState = 'current' | 'default'
|
||||
|
||||
/** Error thrown when SVG violates the convention. */
|
||||
export class SvgConventionError extends Error {
|
||||
constructor(
|
||||
message: string,
|
||||
public readonly boneId: string,
|
||||
public readonly missingAttribute: string,
|
||||
) {
|
||||
super(message)
|
||||
this.name = 'SvgConventionError'
|
||||
}
|
||||
}
|
||||
@@ -1,15 +1,12 @@
|
||||
import { BrowserRouter, Routes, Route, useLocation } from 'react-router-dom'
|
||||
import { BrowserRouter, Routes, Route } from 'react-router-dom'
|
||||
import { ConfigProvider } from './providers/ConfigProvider'
|
||||
import Footer from '@/components/brand/Footer'
|
||||
import HomeRoute from './routes/HomeRoute'
|
||||
import NewReportRoute from './routes/NewReportRoute'
|
||||
import EditorRoute from './routes/EditorRoute'
|
||||
import SvgEditorRoute from './routes/SvgEditorRoute'
|
||||
import EditorsRoute from './routes/EditorsRoute'
|
||||
import NotFoundRoute from './routes/NotFoundRoute'
|
||||
|
||||
function AppShell() {
|
||||
const hideFooter = useLocation().pathname === '/svg-editor'
|
||||
return (
|
||||
<div className="flex min-h-screen flex-col">
|
||||
<main className="flex-1 flex flex-col">
|
||||
@@ -17,12 +14,10 @@ function AppShell() {
|
||||
<Route path="/" element={<HomeRoute />} />
|
||||
<Route path="/new" element={<NewReportRoute />} />
|
||||
<Route path="/editor" element={<EditorRoute />} />
|
||||
<Route path="/svg-editor" element={<SvgEditorRoute />} />
|
||||
<Route path="/editors" element={<EditorsRoute />} />
|
||||
<Route path="*" element={<NotFoundRoute />} />
|
||||
</Routes>
|
||||
</main>
|
||||
{!hideFooter && <Footer />}
|
||||
<Footer />
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
@@ -1,12 +1,16 @@
|
||||
import { useEffect, useMemo, useState } from 'react'
|
||||
import { useCallback, useEffect, useMemo, useState } from 'react'
|
||||
import { useNavigate } from 'react-router-dom'
|
||||
import type {
|
||||
Animal,
|
||||
LateralSide,
|
||||
Owner,
|
||||
Practitioner,
|
||||
} from '@faunosteo/domain'
|
||||
import AnatomyCanvas from '@/components/canvas/AnatomyCanvas'
|
||||
import DetailModal from '@/components/canvas/DetailModal'
|
||||
import ObservationList from '@/components/observation/ObservationList'
|
||||
import VertebraPicker from '@/components/observation/VertebraPicker'
|
||||
import { regionFromLabel } from '@/lib/spineZones'
|
||||
import LateralityPicker from '@/components/observation/LateralityPicker'
|
||||
import type { LateralSide } from '@/domain/schema/observation'
|
||||
import ConclusionPanel from '@/components/report/ConclusionPanel'
|
||||
import ReportHeader from '@/components/report/ReportHeader'
|
||||
import PractitionerForm from '@/components/report/PractitionerForm'
|
||||
@@ -15,315 +19,155 @@ import Button from '@/components/ui/Button'
|
||||
import Dialog from '@/components/ui/Dialog'
|
||||
import { useReportStore } from '@/state/reportStore'
|
||||
import { writeCachedPractitioner } from '@/state/practitionerCache'
|
||||
import { getSpecies } from '@/domain/species/registry'
|
||||
import { loadSvg } from '@/anatomy/svgLoader'
|
||||
import { parseSvgBones } from '@/anatomy/svgConvention'
|
||||
import { collectSpineVertebrae, syncSpineZones } from '@/lib/spineZones'
|
||||
import type { Bone, BoneState } from '@/anatomy/types'
|
||||
import type { Observation, ObservationZone } from '@/domain/schema/observation'
|
||||
import type { Report } from '@/domain/schema/report'
|
||||
import type { SpeciesFindings } from '@/domain/schema/findings'
|
||||
import type { Practitioner } from '@/domain/schema/practitioner'
|
||||
import type { Animal, Owner } from '@/domain/schema/animal'
|
||||
import { useLocaleStore } from '@/state/localeStore'
|
||||
import { useSheet } from '@/sheets/useSheet'
|
||||
import { isObservable, pickLabel, type SheetIndex } from '@/services/sheetIndex'
|
||||
import {
|
||||
addSides,
|
||||
collectVertebrae,
|
||||
decideZoneClick,
|
||||
ensureZone,
|
||||
refOf,
|
||||
removeAllSides,
|
||||
removeZoneAt,
|
||||
sidesPresent,
|
||||
syncVertebrae,
|
||||
toggleZone,
|
||||
type ZoneRef,
|
||||
} from '@/services/zoneInteraction'
|
||||
import type { ViewStates } from '@/anatomy/drawing'
|
||||
import { exportReportToPdf } from '@/pdf/export'
|
||||
import { useT } from '@/i18n/useT'
|
||||
import { useLocaleStore } from '@/state/localeStore'
|
||||
import { boneLabel } from '@/anatomy/labels'
|
||||
import { DEFAULT_SPECIES_ID } from './NewReportRoute'
|
||||
|
||||
const DISCLAIMER_FLAG = 'osteo:disclaimer-shown'
|
||||
|
||||
/** Merges newly parsed bones into the accumulated map without overwriting. */
|
||||
function mergeBones(prev: Map<string, Bone>, parsed: Map<string, Bone>) {
|
||||
const merged = new Map(prev)
|
||||
parsed.forEach((b, id) => {
|
||||
if (!merged.has(id)) merged.set(id, b)
|
||||
})
|
||||
return merged
|
||||
interface Identity {
|
||||
practitioner: Practitioner
|
||||
animal: Animal
|
||||
owner: Owner
|
||||
}
|
||||
|
||||
/** Editor on the reference sheet: wires the canvas, the pickers and the store. */
|
||||
export default function EditorRoute() {
|
||||
const navigate = useNavigate()
|
||||
const t = useT()
|
||||
const locale = useLocaleStore((s) => s.locale)
|
||||
const report = useReportStore((s) => s.report)
|
||||
const activeIndex = useReportStore((s) => s.activeObservationIndex)
|
||||
const addObservation = useReportStore((s) => s.addObservation)
|
||||
const updateObservation = useReportStore((s) => s.updateObservation)
|
||||
const removeObservation = useReportStore((s) => s.removeObservation)
|
||||
const moveObservationUp = useReportStore((s) => s.moveObservationUp)
|
||||
const moveObservationDown = useReportStore((s) => s.moveObservationDown)
|
||||
const setActiveObservation = useReportStore((s) => s.setActiveObservation)
|
||||
const setConclusion = useReportStore((s) => s.setConclusion)
|
||||
const setRecommendations = useReportStore((s) => s.setRecommendations)
|
||||
const setNextAppointment = useReportStore((s) => s.setNextAppointment)
|
||||
const setPractitioner = useReportStore((s) => s.setPractitioner)
|
||||
const setAnimal = useReportStore((s) => s.setAnimal)
|
||||
const setOwner = useReportStore((s) => s.setOwner)
|
||||
const store = useReportStore()
|
||||
const { report, activeObservationIndex: activeIndex } = store
|
||||
// Without a report yet (draft restore), the default species' sheet carries the migration map.
|
||||
const sheet = useSheet(report?.animal.speciesId ?? DEFAULT_SPECIES_ID)
|
||||
|
||||
const [bones, setBones] = useState<Map<string, Bone>>(new Map())
|
||||
const [detailBones, setDetailBones] = useState<Map<string, Bone>>(new Map())
|
||||
const [findings, setFindings] = useState<SpeciesFindings | null>(null)
|
||||
const [disclaimer, setDisclaimer] = useState<string | null>(null)
|
||||
const [detail, setDetail] = useState<{
|
||||
id: string
|
||||
src: string
|
||||
title: string
|
||||
} | null>(null)
|
||||
const [detailViewId, setDetailViewId] = useState<string | null>(null)
|
||||
const [vertebraTarget, setVertebraTarget] = useState<number | null>(null)
|
||||
const [lateralTarget, setLateralTarget] = useState<{
|
||||
boneId: string
|
||||
detailSourceId?: string
|
||||
} | null>(null)
|
||||
const [lateralTarget, setLateralTarget] = useState<ZoneRef | null>(null)
|
||||
const [disclaimer, setDisclaimer] = useState<string | null>(null)
|
||||
const [exporting, setExporting] = useState(false)
|
||||
const [editOpen, setEditOpen] = useState(false)
|
||||
const [editDraft, setEditDraft] = useState<{
|
||||
practitioner: Practitioner
|
||||
animal: Animal
|
||||
owner: Owner
|
||||
} | null>(null)
|
||||
|
||||
function openEditInfos() {
|
||||
if (!report) return
|
||||
setEditDraft({
|
||||
practitioner: report.practitioner,
|
||||
animal: report.animal,
|
||||
owner: report.owner,
|
||||
})
|
||||
setEditOpen(true)
|
||||
}
|
||||
|
||||
function closeEditInfos() {
|
||||
setEditOpen(false)
|
||||
setEditDraft(null)
|
||||
}
|
||||
|
||||
function saveEditInfos() {
|
||||
if (!editDraft) return closeEditInfos()
|
||||
const name = editDraft.practitioner.name.trim()
|
||||
const animalName = editDraft.animal.name.trim()
|
||||
const ownerName = editDraft.owner.name.trim()
|
||||
if (!name || !animalName || !ownerName) return
|
||||
setPractitioner(editDraft.practitioner)
|
||||
setAnimal(editDraft.animal)
|
||||
setOwner(editDraft.owner)
|
||||
writeCachedPractitioner(editDraft.practitioner)
|
||||
closeEditInfos()
|
||||
}
|
||||
|
||||
function acknowledgeDisclaimer() {
|
||||
if (typeof sessionStorage !== 'undefined') {
|
||||
sessionStorage.setItem(DISCLAIMER_FLAG, '1')
|
||||
}
|
||||
setDisclaimer(null)
|
||||
}
|
||||
|
||||
useEffect(() => {
|
||||
if (!report) navigate('/')
|
||||
}, [report, navigate])
|
||||
const [editDraft, setEditDraft] = useState<Identity | null>(null)
|
||||
|
||||
useEffect(() => {
|
||||
window.scrollTo({ top: 0, left: 0, behavior: 'auto' })
|
||||
}, [])
|
||||
|
||||
const species = useMemo(
|
||||
() => (report ? getSpecies(report.animal.speciesId) : undefined),
|
||||
[report],
|
||||
)
|
||||
// No report in memory: restore the per-tab draft once the sheet is known.
|
||||
useEffect(() => {
|
||||
if (report) return
|
||||
if (sheet.status === 'ready')
|
||||
store.restoreDraft(sheet.index.sheet.migrationMap)
|
||||
if (sheet.status !== 'loading' && !useReportStore.getState().report)
|
||||
navigate('/')
|
||||
}, [report, sheet, store, navigate])
|
||||
|
||||
useEffect(() => {
|
||||
if (!species) return
|
||||
loadSvg(species.mainSvg).then((root) => setBones(parseSvgBones(root)))
|
||||
species.findings().then((m) => setFindings(m.default))
|
||||
|
||||
// Eagerly preload every detail SVG so observation zones imported
|
||||
// from a PDF (which can carry detail-popup boneIds without the user
|
||||
// ever re-opening the popup) resolve their labels and findings
|
||||
// pickers immediately on mount. Each fetch is independent — a 404
|
||||
// on one detail asset must not prevent the others from loading.
|
||||
Object.values(species.details).forEach((path) => {
|
||||
loadSvg(path)
|
||||
.then((root) => {
|
||||
const parsed = parseSvgBones(root)
|
||||
setDetailBones((prev) => mergeBones(prev, parsed))
|
||||
})
|
||||
.catch((err) => {
|
||||
console.warn(`EditorRoute: failed to preload detail SVG ${path}`, err)
|
||||
})
|
||||
})
|
||||
}, [species])
|
||||
|
||||
useEffect(() => {
|
||||
if (!findings) return
|
||||
if (typeof sessionStorage === 'undefined') return
|
||||
if (sheet.status !== 'ready' || typeof sessionStorage === 'undefined')
|
||||
return
|
||||
if (sessionStorage.getItem(DISCLAIMER_FLAG)) return
|
||||
setDisclaimer(findings.scope_disclaimer)
|
||||
}, [findings])
|
||||
|
||||
useEffect(() => {
|
||||
if (!detail) return
|
||||
let cancelled = false
|
||||
loadSvg(detail.src).then((root) => {
|
||||
if (cancelled) return
|
||||
const parsed = parseSvgBones(root)
|
||||
setDetailBones((prev) => mergeBones(prev, parsed))
|
||||
})
|
||||
return () => {
|
||||
cancelled = true
|
||||
}
|
||||
}, [detail])
|
||||
|
||||
const allBones = useMemo(() => {
|
||||
const m = new Map(bones)
|
||||
detailBones.forEach((b, id) => {
|
||||
if (!m.has(id)) m.set(id, b)
|
||||
})
|
||||
return m
|
||||
}, [bones, detailBones])
|
||||
const text = sheet.index.sheet.document.scope_disclaimer
|
||||
setDisclaimer(
|
||||
pickLabel({ fr: text.fr ?? '', en: text.en ?? '' }, locale) || null,
|
||||
)
|
||||
}, [sheet, locale])
|
||||
|
||||
const activeObs =
|
||||
activeIndex >= 0 ? report?.observations[activeIndex] : undefined
|
||||
|
||||
const boneStates = useMemo<Map<string, BoneState>>(() => {
|
||||
const map = new Map<string, BoneState>()
|
||||
if (!report || activeIndex < 0) return map
|
||||
const active = report.observations[activeIndex]
|
||||
if (!active) return map
|
||||
active.zones.forEach((z) => {
|
||||
map.set(z.boneId, 'current')
|
||||
})
|
||||
const states = useMemo<ViewStates>(() => {
|
||||
const map = new Map<string, 'current'>()
|
||||
activeObs?.zones.forEach((z) => map.set(z.annotationId, 'current'))
|
||||
return map
|
||||
}, [report, activeIndex])
|
||||
}, [activeObs])
|
||||
|
||||
function onToggleCard(index: number) {
|
||||
setActiveObservation(activeIndex === index ? -1 : index)
|
||||
}
|
||||
|
||||
/** Opens the detail-popup modal for a bone that carries data-anno-opens-detail. */
|
||||
function handleDetailOpen(bone: Bone, detailId: string, detailSrc: string) {
|
||||
setDetail({
|
||||
id: detailId,
|
||||
src: detailSrc,
|
||||
title: boneLabel(bone, locale, detailId),
|
||||
})
|
||||
}
|
||||
|
||||
/**
|
||||
* No expanded observation — auto-expand the most recent one (or the
|
||||
* first if no rows yet) so the click lands somewhere. Defers the actual
|
||||
* zone add to the next render where activeObs is set.
|
||||
*/
|
||||
function activateFallbackObservation(report: Report) {
|
||||
const fallbackIndex =
|
||||
report.observations.length > 0 ? report.observations.length - 1 : -1
|
||||
if (fallbackIndex < 0) return
|
||||
setActiveObservation(fallbackIndex)
|
||||
}
|
||||
|
||||
/**
|
||||
* Spine-zone behavior: always open VertebraPicker on click. Adds the
|
||||
* zone if missing; never toggles it off here (use the ✕ button).
|
||||
*/
|
||||
function handleSpineZone(
|
||||
activeObs: Observation,
|
||||
boneId: string,
|
||||
detailSourceId: string | undefined,
|
||||
existingIndex: number,
|
||||
) {
|
||||
let targetIndex = existingIndex
|
||||
if (existingIndex < 0) {
|
||||
const newZone: ObservationZone = {
|
||||
boneId,
|
||||
...(detailSourceId ? { detailSourceId } : {}),
|
||||
const onZoneClick = useCallback(
|
||||
(annotationId: string) => {
|
||||
// Fresh state: two clicks may land before React re-renders the handler.
|
||||
const { report, activeObservationIndex: activeIndex } =
|
||||
useReportStore.getState()
|
||||
if (sheet.status !== 'ready' || !report) return
|
||||
const activeObs =
|
||||
activeIndex >= 0 ? report.observations[activeIndex] : undefined
|
||||
const index = sheet.index
|
||||
const annotation = index.annotation(annotationId)
|
||||
const decision = decideZoneClick(annotation, activeObs)
|
||||
if (!annotation) return
|
||||
switch (decision.kind) {
|
||||
case 'ignore':
|
||||
return
|
||||
case 'open_view':
|
||||
return setDetailViewId(decision.viewId)
|
||||
case 'activate_fallback':
|
||||
return store.setActiveObservation(report.observations.length - 1)
|
||||
case 'open_vertebra_picker': {
|
||||
const { observation, index: zoneIndex } = ensureZone(
|
||||
activeObs!,
|
||||
annotation,
|
||||
)
|
||||
store.updateObservation(activeIndex, observation)
|
||||
return setVertebraTarget(zoneIndex)
|
||||
}
|
||||
case 'open_laterality_picker':
|
||||
return setLateralTarget(refOf(annotation))
|
||||
case 'remove_both_sides':
|
||||
return store.updateObservation(
|
||||
activeIndex,
|
||||
removeAllSides(activeObs!, refOf(annotation)),
|
||||
)
|
||||
case 'toggle':
|
||||
return store.updateObservation(
|
||||
activeIndex,
|
||||
toggleZone(activeObs!, annotation),
|
||||
)
|
||||
}
|
||||
const nextZones = [...activeObs.zones, newZone]
|
||||
targetIndex = nextZones.length - 1
|
||||
updateObservation(activeIndex, { ...activeObs, zones: nextZones })
|
||||
}
|
||||
setVertebraTarget(targetIndex)
|
||||
},
|
||||
[sheet, store],
|
||||
)
|
||||
|
||||
function acknowledgeDisclaimer() {
|
||||
sessionStorage?.setItem(DISCLAIMER_FLAG, '1')
|
||||
setDisclaimer(null)
|
||||
}
|
||||
|
||||
/** Bilateral zone: adding a side, or clearing both once left+right are set. */
|
||||
function handleBilateralZone(
|
||||
activeObs: Observation,
|
||||
boneId: string,
|
||||
detailSourceId: string | undefined,
|
||||
) {
|
||||
const sidesPresent = activeObs.zones
|
||||
.filter(
|
||||
(z) => z.boneId === boneId && z.detailSourceId === detailSourceId,
|
||||
)
|
||||
.map((z) => z.side)
|
||||
.filter(Boolean) as LateralSide[]
|
||||
|
||||
if (sidesPresent.includes('left') && sidesPresent.includes('right')) {
|
||||
const nextZones = activeObs.zones.filter(
|
||||
(z) => !(z.boneId === boneId && z.detailSourceId === detailSourceId),
|
||||
)
|
||||
updateObservation(activeIndex, { ...activeObs, zones: nextZones })
|
||||
function saveEditInfos() {
|
||||
if (!editDraft) return
|
||||
if (
|
||||
![
|
||||
editDraft.practitioner.name,
|
||||
editDraft.animal.name,
|
||||
editDraft.owner.name,
|
||||
].every((v) => v.trim())
|
||||
)
|
||||
return
|
||||
}
|
||||
|
||||
setLateralTarget({
|
||||
boneId,
|
||||
...(detailSourceId ? { detailSourceId } : {}),
|
||||
})
|
||||
store.setPractitioner(editDraft.practitioner)
|
||||
store.setAnimal(editDraft.animal)
|
||||
store.setOwner(editDraft.owner)
|
||||
writeCachedPractitioner(editDraft.practitioner)
|
||||
setEditDraft(null)
|
||||
}
|
||||
|
||||
/** Plain zone: toggles it on the active observation. */
|
||||
function toggleZone(
|
||||
activeObs: Observation,
|
||||
boneId: string,
|
||||
detailSourceId: string | undefined,
|
||||
existingIndex: number,
|
||||
) {
|
||||
const newZone: ObservationZone = {
|
||||
boneId,
|
||||
...(detailSourceId ? { detailSourceId } : {}),
|
||||
}
|
||||
const nextZones =
|
||||
existingIndex >= 0
|
||||
? activeObs.zones.filter((_, k) => k !== existingIndex)
|
||||
: [...activeObs.zones, newZone]
|
||||
updateObservation(activeIndex, { ...activeObs, zones: nextZones })
|
||||
}
|
||||
|
||||
function onZoneClick(boneId: string, detailSourceId?: string) {
|
||||
if (!report) return
|
||||
const bone = bones.get(boneId) ?? detailBones.get(boneId)
|
||||
if (!bone) return
|
||||
|
||||
if (bone.opensDetail && species?.details[bone.opensDetail]) {
|
||||
handleDetailOpen(bone, bone.opensDetail, species.details[bone.opensDetail])
|
||||
return
|
||||
}
|
||||
|
||||
if (!activeObs || activeIndex < 0) {
|
||||
activateFallbackObservation(report)
|
||||
return
|
||||
}
|
||||
|
||||
const matches = (z: ObservationZone) =>
|
||||
z.boneId === boneId && z.detailSourceId === detailSourceId
|
||||
const existingIndex = activeObs.zones.findIndex(matches)
|
||||
|
||||
if (bone.special === 'vertebral-precision') {
|
||||
handleSpineZone(activeObs, boneId, detailSourceId, existingIndex)
|
||||
return
|
||||
}
|
||||
|
||||
if (bone.lateral === 'bilateral') {
|
||||
handleBilateralZone(activeObs, boneId, detailSourceId)
|
||||
return
|
||||
}
|
||||
|
||||
toggleZone(activeObs, boneId, detailSourceId, existingIndex)
|
||||
}
|
||||
|
||||
async function onExport() {
|
||||
async function onExport(index: SheetIndex) {
|
||||
if (!report) return
|
||||
setExporting(true)
|
||||
try {
|
||||
const bytes = await exportReportToPdf(report, { locale })
|
||||
const bytes = await exportReportToPdf(report, index, { locale })
|
||||
const blob = new Blob([bytes as BlobPart], { type: 'application/pdf' })
|
||||
const url = URL.createObjectURL(blob)
|
||||
const a = document.createElement('a')
|
||||
@@ -339,73 +183,109 @@ export default function EditorRoute() {
|
||||
}
|
||||
}
|
||||
|
||||
if (!report || !species) return null
|
||||
if (!report) return null
|
||||
if (sheet.status === 'loading') {
|
||||
return (
|
||||
<p className="p-6 text-sm text-[var(--color-ink-muted)]">
|
||||
{t('sheet.loading')}
|
||||
</p>
|
||||
)
|
||||
}
|
||||
if (sheet.status === 'none') return null
|
||||
const index = sheet.index
|
||||
const vertebraZone =
|
||||
vertebraTarget !== null ? activeObs?.zones[vertebraTarget] : undefined
|
||||
const vertebraAnnotation =
|
||||
vertebraZone && index.annotation(vertebraZone.annotationId)
|
||||
const lateralAnnotation =
|
||||
lateralTarget && index.annotation(lateralTarget.annotationId)
|
||||
const detailView = detailViewId ? index.view(detailViewId) : undefined
|
||||
|
||||
return (
|
||||
<main className="min-h-screen flex flex-col">
|
||||
<ReportHeader report={report} onEditInfos={openEditInfos} />
|
||||
<ReportHeader
|
||||
report={report}
|
||||
onEditInfos={() =>
|
||||
setEditDraft({
|
||||
practitioner: report.practitioner,
|
||||
animal: report.animal,
|
||||
owner: report.owner,
|
||||
})
|
||||
}
|
||||
/>
|
||||
<div className="flex-1 grid grid-cols-1 lg:grid-cols-[2fr_3fr] gap-4 sm:gap-6 p-4 sm:p-6">
|
||||
<section className="border border-[var(--color-border)] rounded-2xl bg-[var(--color-surface)] overflow-hidden max-h-[55vh] lg:max-h-none">
|
||||
<section className="border border-[var(--color-border)] rounded-2xl bg-[var(--color-surface)] overflow-hidden max-h-[55vh] lg:max-h-none flex flex-col">
|
||||
<AnatomyCanvas
|
||||
src={species.mainSvg}
|
||||
boneStates={boneStates}
|
||||
onZoneClick={(id) => onZoneClick(id)}
|
||||
index={index}
|
||||
viewId={index.mainView.id}
|
||||
states={states}
|
||||
onZoneClick={onZoneClick}
|
||||
className="flex-1"
|
||||
/>
|
||||
<p
|
||||
className="px-3 py-1.5 text-xs text-[var(--color-ink-muted)] border-t border-[var(--color-border)]"
|
||||
data-testid="sheet-status"
|
||||
>
|
||||
{t(
|
||||
index.sheet.status === 'draft'
|
||||
? 'sheet.status.draft'
|
||||
: 'sheet.status.published',
|
||||
)}
|
||||
</p>
|
||||
</section>
|
||||
<section className="space-y-4 sm:space-y-6">
|
||||
<ObservationList
|
||||
observations={report.observations}
|
||||
activeIndex={activeIndex}
|
||||
onToggle={onToggleCard}
|
||||
onAdd={addObservation}
|
||||
onDelete={removeObservation}
|
||||
onMoveUp={moveObservationUp}
|
||||
onMoveDown={moveObservationDown}
|
||||
bones={allBones}
|
||||
findings={findings}
|
||||
onChange={(i, next: Observation) => updateObservation(i, next)}
|
||||
onToggle={(i) =>
|
||||
store.setActiveObservation(activeIndex === i ? -1 : i)
|
||||
}
|
||||
onAdd={store.addObservation}
|
||||
onDelete={store.removeObservation}
|
||||
onMoveUp={store.moveObservationUp}
|
||||
onMoveDown={store.moveObservationDown}
|
||||
sheet={index}
|
||||
onChange={store.updateObservation}
|
||||
onOpenVertebraPicker={(_i, zoneIndex) =>
|
||||
setVertebraTarget(zoneIndex)
|
||||
}
|
||||
onRemoveZone={(i, zoneIndex) => {
|
||||
const obs = report.observations[i]
|
||||
if (!obs) return
|
||||
const zones = obs.zones.filter((_, k) => k !== zoneIndex)
|
||||
updateObservation(i, { ...obs, zones })
|
||||
if (obs) store.updateObservation(i, removeZoneAt(obs, zoneIndex))
|
||||
}}
|
||||
/>
|
||||
<ConclusionPanel
|
||||
conclusion={report.conclusion}
|
||||
recommendations={report.recommendations}
|
||||
nextAppointment={report.nextAppointment}
|
||||
onChangeConclusion={setConclusion}
|
||||
onChangeRecommendations={setRecommendations}
|
||||
onChangeNextAppointment={setNextAppointment}
|
||||
onChangeConclusion={store.setConclusion}
|
||||
onChangeRecommendations={store.setRecommendations}
|
||||
onChangeNextAppointment={store.setNextAppointment}
|
||||
/>
|
||||
<div className="flex justify-end">
|
||||
<Button onClick={onExport} disabled={exporting}>
|
||||
<Button onClick={() => onExport(index)} disabled={exporting}>
|
||||
{exporting ? t('editor.exporting') : t('editor.export')}
|
||||
</Button>
|
||||
</div>
|
||||
</section>
|
||||
</div>
|
||||
|
||||
{detail && (
|
||||
{detailView && (
|
||||
<DetailModal
|
||||
open
|
||||
onClose={() => setDetail(null)}
|
||||
detailSrc={detail.src}
|
||||
detailId={detail.id}
|
||||
title={`${t('editor.detail_title_prefix')}${detail.title}`}
|
||||
boneStates={boneStates}
|
||||
onZoneClick={(id, did) => onZoneClick(id, did)}
|
||||
onClose={() => setDetailViewId(null)}
|
||||
index={index}
|
||||
viewId={detailView.id}
|
||||
title={pickLabel(detailView.name, locale)}
|
||||
states={states}
|
||||
onZoneClick={onZoneClick}
|
||||
/>
|
||||
)}
|
||||
|
||||
{editDraft && (
|
||||
<Dialog
|
||||
open={editOpen}
|
||||
onClose={closeEditInfos}
|
||||
open
|
||||
onClose={() => setEditDraft(null)}
|
||||
title={t('editor.edit_dialog_title')}
|
||||
size="lg"
|
||||
>
|
||||
@@ -419,6 +299,9 @@ export default function EditorRoute() {
|
||||
<AnimalForm
|
||||
animal={editDraft.animal}
|
||||
owner={editDraft.owner}
|
||||
species={[
|
||||
{ id: index.sheet.speciesId, name: index.sheet.document.name },
|
||||
]}
|
||||
onChangeAnimal={(next) =>
|
||||
setEditDraft((d) => (d ? { ...d, animal: next } : d))
|
||||
}
|
||||
@@ -427,15 +310,17 @@ export default function EditorRoute() {
|
||||
}
|
||||
/>
|
||||
<div className="flex gap-3 justify-end pt-2 border-t border-[var(--color-border)]">
|
||||
<Button variant="ghost" onClick={closeEditInfos}>
|
||||
<Button variant="ghost" onClick={() => setEditDraft(null)}>
|
||||
{t('common.cancel')}
|
||||
</Button>
|
||||
<Button
|
||||
onClick={saveEditInfos}
|
||||
disabled={
|
||||
!editDraft.practitioner.name.trim() ||
|
||||
!editDraft.animal.name.trim() ||
|
||||
!editDraft.owner.name.trim()
|
||||
![
|
||||
editDraft.practitioner.name,
|
||||
editDraft.animal.name,
|
||||
editDraft.owner.name,
|
||||
].every((v) => v.trim())
|
||||
}
|
||||
>
|
||||
{t('common.save')}
|
||||
@@ -455,7 +340,9 @@ export default function EditorRoute() {
|
||||
<div className="space-y-4">
|
||||
<p className="text-sm text-[var(--color-ink)]">{disclaimer}</p>
|
||||
<div className="flex justify-end">
|
||||
<Button onClick={acknowledgeDisclaimer}>{t('common.understood')}</Button>
|
||||
<Button onClick={acknowledgeDisclaimer}>
|
||||
{t('common.understood')}
|
||||
</Button>
|
||||
</div>
|
||||
</div>
|
||||
</Dialog>
|
||||
@@ -463,86 +350,45 @@ export default function EditorRoute() {
|
||||
|
||||
{vertebraTarget !== null &&
|
||||
activeObs &&
|
||||
activeObs.zones[vertebraTarget] && (
|
||||
vertebraZone &&
|
||||
isObservable(vertebraAnnotation) && (
|
||||
<VertebraPicker
|
||||
open
|
||||
onClose={() => setVertebraTarget(null)}
|
||||
onConfirm={(vertebrae) => {
|
||||
const fresh =
|
||||
useReportStore.getState().report?.observations[activeIndex]
|
||||
if (!fresh?.zones[vertebraTarget]) {
|
||||
setVertebraTarget(null)
|
||||
return
|
||||
if (fresh) {
|
||||
store.updateObservation(
|
||||
activeIndex,
|
||||
syncVertebrae(fresh, vertebrae, index, vertebraZone.viewId),
|
||||
)
|
||||
}
|
||||
// Picker edits every region at once: reconcile all spine zones —
|
||||
// spawn newly picked regions, prune emptied ones, keep the rest.
|
||||
const next = syncSpineZones(fresh.zones, vertebrae, bones)
|
||||
updateObservation(activeIndex, { ...fresh, zones: next })
|
||||
setVertebraTarget(null)
|
||||
}}
|
||||
initial={collectSpineVertebrae(
|
||||
activeObs.zones,
|
||||
bones,
|
||||
activeObs.zones[vertebraTarget].boneId,
|
||||
)}
|
||||
formula={species.vertebralFormula}
|
||||
title={`${t('vertebra.title_prefix')}${boneLabel(
|
||||
bones.get(activeObs.zones[vertebraTarget].boneId),
|
||||
locale,
|
||||
'',
|
||||
)}`}
|
||||
initialRegion={(() => {
|
||||
const b = bones.get(activeObs.zones[vertebraTarget].boneId)
|
||||
return regionFromLabel(b?.fr ?? '') ?? regionFromLabel(b?.en ?? '')
|
||||
})()}
|
||||
initial={collectVertebrae(activeObs, index, vertebraTarget)}
|
||||
regions={index.regions()}
|
||||
title={`${t('vertebra.title_prefix')}${pickLabel(vertebraAnnotation.name, locale)}`}
|
||||
initialRegion={
|
||||
vertebraAnnotation.vertebral_region_code ?? undefined
|
||||
}
|
||||
/>
|
||||
)}
|
||||
|
||||
{lateralTarget && activeObs && (
|
||||
{lateralTarget && activeObs && lateralAnnotation && (
|
||||
<LateralityPicker
|
||||
open
|
||||
onClose={() => setLateralTarget(null)}
|
||||
title={boneLabel(
|
||||
allBones.get(lateralTarget.boneId),
|
||||
locale,
|
||||
lateralTarget.boneId,
|
||||
)}
|
||||
existingSides={
|
||||
activeObs.zones
|
||||
.filter(
|
||||
(z) =>
|
||||
z.boneId === lateralTarget.boneId &&
|
||||
z.detailSourceId === lateralTarget.detailSourceId &&
|
||||
z.side,
|
||||
)
|
||||
.map((z) => z.side!) as LateralSide[]
|
||||
}
|
||||
onSelect={(sides) => {
|
||||
title={pickLabel(index.name(lateralAnnotation), locale)}
|
||||
existingSides={sidesPresent(activeObs, lateralTarget)}
|
||||
onSelect={(sides: LateralSide[]) => {
|
||||
const fresh =
|
||||
useReportStore.getState().report?.observations[activeIndex]
|
||||
if (!fresh) {
|
||||
setLateralTarget(null)
|
||||
return
|
||||
}
|
||||
const newSideZones = sides
|
||||
.filter(
|
||||
(side) =>
|
||||
!fresh.zones.some(
|
||||
(z) =>
|
||||
z.boneId === lateralTarget.boneId &&
|
||||
z.detailSourceId === lateralTarget.detailSourceId &&
|
||||
z.side === side,
|
||||
),
|
||||
if (fresh)
|
||||
store.updateObservation(
|
||||
activeIndex,
|
||||
addSides(fresh, lateralAnnotation, sides),
|
||||
)
|
||||
.map((side) => ({
|
||||
boneId: lateralTarget.boneId,
|
||||
...(lateralTarget.detailSourceId
|
||||
? { detailSourceId: lateralTarget.detailSourceId }
|
||||
: {}),
|
||||
side,
|
||||
}))
|
||||
const nextZones = [...fresh.zones, ...newSideZones]
|
||||
updateObservation(activeIndex, { ...fresh, zones: nextZones })
|
||||
setLateralTarget(null)
|
||||
}}
|
||||
/>
|
||||
|
||||
@@ -1,42 +0,0 @@
|
||||
import { Link } from 'react-router-dom'
|
||||
import AppHeader from '@/components/brand/AppHeader'
|
||||
import Card from '@/components/ui/Card'
|
||||
import { useT } from '@/i18n/useT'
|
||||
|
||||
export default function EditorsRoute() {
|
||||
const t = useT()
|
||||
|
||||
return (
|
||||
<main className="flex-1 flex flex-col">
|
||||
<AppHeader />
|
||||
<section className="flex-1 grid place-items-center px-4 sm:px-6">
|
||||
<div className="grid gap-4 md:grid-cols-2 max-w-3xl w-full">
|
||||
<Card className="p-4 sm:p-6 space-y-3 sm:space-y-4">
|
||||
<h2 className="font-serif text-xl sm:text-2xl">{t('editors.svg.title')}</h2>
|
||||
<p className="text-sm text-[var(--color-ink-muted)]">
|
||||
{t('editors.svg.description')}
|
||||
</p>
|
||||
<Link
|
||||
to="/svg-editor"
|
||||
className="inline-block rounded-lg bg-[var(--color-accent)] px-5 py-2 text-sm font-medium text-white hover:bg-[var(--color-accent-strong)] transition-colors"
|
||||
>
|
||||
{t('editors.svg.cta')}
|
||||
</Link>
|
||||
</Card>
|
||||
<Card className="p-4 sm:p-6 space-y-3 sm:space-y-4">
|
||||
<h2 className="font-serif text-xl sm:text-2xl">{t('editors.pathology.title')}</h2>
|
||||
<p className="text-sm text-[var(--color-ink-muted)]">
|
||||
{t('editors.pathology.description')}
|
||||
</p>
|
||||
<a
|
||||
href="/pathology-editor.html"
|
||||
className="inline-block rounded-lg bg-[var(--color-accent)] px-5 py-2 text-sm font-medium text-white hover:bg-[var(--color-accent-strong)] transition-colors"
|
||||
>
|
||||
{t('editors.pathology.cta')}
|
||||
</a>
|
||||
</Card>
|
||||
</div>
|
||||
</section>
|
||||
</main>
|
||||
)
|
||||
}
|
||||
@@ -5,25 +5,42 @@ import Button from '@/components/ui/Button'
|
||||
import Card from '@/components/ui/Card'
|
||||
import { importReportFromPdf, ImportError } from '@/pdf/import'
|
||||
import { useReportStore } from '@/state/reportStore'
|
||||
import { useSheet } from '@/sheets/useSheet'
|
||||
import { DEFAULT_SPECIES_ID } from './NewReportRoute'
|
||||
import { useT } from '@/i18n/useT'
|
||||
|
||||
export default function HomeRoute() {
|
||||
const navigate = useNavigate()
|
||||
const fileRef = useRef<HTMLInputElement | null>(null)
|
||||
const hydrate = useReportStore((s) => s.hydrateReport)
|
||||
const sheet = useSheet(DEFAULT_SPECIES_ID)
|
||||
const [error, setError] = useState<string | null>(null)
|
||||
const [busy, setBusy] = useState(false)
|
||||
const t = useT()
|
||||
|
||||
async function onPickFile(e: React.ChangeEvent<HTMLInputElement>) {
|
||||
const file = e.target.files?.[0]
|
||||
if (!file) return
|
||||
if (!file || sheet.status !== 'ready') return
|
||||
setBusy(true)
|
||||
setError(null)
|
||||
try {
|
||||
const bytes = new Uint8Array(await file.arrayBuffer())
|
||||
const report = await importReportFromPdf(bytes)
|
||||
hydrate(report)
|
||||
const outcome = await importReportFromPdf(
|
||||
bytes,
|
||||
sheet.index.sheet.migrationMap,
|
||||
)
|
||||
if (
|
||||
outcome.migrated &&
|
||||
outcome.unresolvedFindings + outcome.unresolvedZones > 0
|
||||
) {
|
||||
window.alert(
|
||||
t('home.import.migrated').replace(
|
||||
'{count}',
|
||||
String(outcome.unresolvedFindings + outcome.unresolvedZones),
|
||||
),
|
||||
)
|
||||
}
|
||||
hydrate(outcome.report)
|
||||
navigate('/editor')
|
||||
} catch (err) {
|
||||
if (err instanceof ImportError) {
|
||||
@@ -48,21 +65,58 @@ export default function HomeRoute() {
|
||||
}
|
||||
}
|
||||
|
||||
const noSheet = sheet.status === 'none'
|
||||
|
||||
return (
|
||||
<main className="flex-1 flex flex-col">
|
||||
<AppHeader />
|
||||
<section className="flex-1 grid place-items-center px-4 sm:px-6">
|
||||
<div className="grid gap-4 md:grid-cols-2 max-w-3xl w-full">
|
||||
{noSheet && (
|
||||
<Card className="p-4 sm:p-6 space-y-2 md:col-span-2">
|
||||
<h2 className="font-serif text-xl sm:text-2xl">
|
||||
{t('home.no_sheet.title')}
|
||||
</h2>
|
||||
<p className="text-sm text-red-700">
|
||||
{t('home.no_sheet.description')}
|
||||
</p>
|
||||
</Card>
|
||||
)}
|
||||
<Card className="p-4 sm:p-6 space-y-3 sm:space-y-4">
|
||||
<h2 className="font-serif text-xl sm:text-2xl">{t('home.new_report.title')}</h2>
|
||||
<p className="text-sm text-[var(--color-ink-muted)]">{t('home.new_report.description')}</p>
|
||||
<Button onClick={() => navigate('/new')} size="lg">{t('home.new_report.cta')}</Button>
|
||||
<h2 className="font-serif text-xl sm:text-2xl">
|
||||
{t('home.new_report.title')}
|
||||
</h2>
|
||||
<p className="text-sm text-[var(--color-ink-muted)]">
|
||||
{t('home.new_report.description')}
|
||||
</p>
|
||||
<Button
|
||||
onClick={() => navigate('/new')}
|
||||
size="lg"
|
||||
disabled={noSheet}
|
||||
>
|
||||
{t('home.new_report.cta')}
|
||||
</Button>
|
||||
</Card>
|
||||
<Card className="p-4 sm:p-6 space-y-3 sm:space-y-4">
|
||||
<h2 className="font-serif text-xl sm:text-2xl">{t('home.import.title')}</h2>
|
||||
<p className="text-sm text-[var(--color-ink-muted)]">{t('home.import.description')}</p>
|
||||
<input ref={fileRef} type="file" accept="application/pdf,.pdf" className="hidden" onChange={onPickFile} />
|
||||
<Button variant="secondary" size="lg" onClick={() => fileRef.current?.click()} disabled={busy}>
|
||||
<h2 className="font-serif text-xl sm:text-2xl">
|
||||
{t('home.import.title')}
|
||||
</h2>
|
||||
<p className="text-sm text-[var(--color-ink-muted)]">
|
||||
{t('home.import.description')}
|
||||
</p>
|
||||
<input
|
||||
ref={fileRef}
|
||||
type="file"
|
||||
accept="application/pdf,.pdf"
|
||||
className="hidden"
|
||||
onChange={onPickFile}
|
||||
/>
|
||||
<Button
|
||||
variant="secondary"
|
||||
size="lg"
|
||||
onClick={() => fileRef.current?.click()}
|
||||
disabled={busy || sheet.status !== 'ready'}
|
||||
>
|
||||
{busy ? t('home.import.loading') : t('home.import.cta')}
|
||||
</Button>
|
||||
{error && <p className="text-sm text-red-700">{error}</p>}
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
import { useEffect, useState } from 'react'
|
||||
import { useNavigate } from 'react-router-dom'
|
||||
import type { Animal, Owner, Practitioner } from '@faunosteo/domain'
|
||||
import PractitionerForm from '@/components/report/PractitionerForm'
|
||||
import AnimalForm from '@/components/report/AnimalForm'
|
||||
import AppHeader from '@/components/brand/AppHeader'
|
||||
@@ -7,18 +8,29 @@ import Button from '@/components/ui/Button'
|
||||
import Input from '@/components/ui/Input'
|
||||
import Label from '@/components/ui/Label'
|
||||
import { todayIso } from '@/lib/dates'
|
||||
import { readCachedPractitioner, writeCachedPractitioner } from '@/state/practitionerCache'
|
||||
import {
|
||||
readCachedPractitioner,
|
||||
writeCachedPractitioner,
|
||||
} from '@/state/practitionerCache'
|
||||
import { useReportStore } from '@/state/reportStore'
|
||||
import { useSheet } from '@/sheets/useSheet'
|
||||
import { useT } from '@/i18n/useT'
|
||||
|
||||
/** The one species this build ships a sheet for. */
|
||||
export const DEFAULT_SPECIES_ID = 'equine'
|
||||
|
||||
export default function NewReportRoute() {
|
||||
const navigate = useNavigate()
|
||||
const initReport = useReportStore((s) => s.initReport)
|
||||
const t = useT()
|
||||
const sheet = useSheet(DEFAULT_SPECIES_ID)
|
||||
|
||||
const [practitioner, setPractitioner] = useState({ name: '' })
|
||||
const [animal, setAnimal] = useState({ speciesId: 'equine', name: '' })
|
||||
const [owner, setOwner] = useState({ name: '' })
|
||||
const [practitioner, setPractitioner] = useState<Practitioner>({ name: '' })
|
||||
const [animal, setAnimal] = useState<Animal>({
|
||||
speciesId: DEFAULT_SPECIES_ID,
|
||||
name: '',
|
||||
})
|
||||
const [owner, setOwner] = useState<Owner>({ name: '' })
|
||||
const [date, setDate] = useState(todayIso())
|
||||
|
||||
useEffect(() => {
|
||||
@@ -26,20 +38,27 @@ export default function NewReportRoute() {
|
||||
if (cached) setPractitioner(cached)
|
||||
}, [])
|
||||
|
||||
const canSubmit = practitioner.name.trim() && animal.name.trim() && owner.name.trim()
|
||||
const canSubmit =
|
||||
practitioner.name.trim() &&
|
||||
animal.name.trim() &&
|
||||
owner.name.trim() &&
|
||||
sheet.status === 'ready'
|
||||
|
||||
function submit() {
|
||||
if (!canSubmit) return
|
||||
if (!canSubmit || sheet.status !== 'ready') return
|
||||
writeCachedPractitioner(practitioner)
|
||||
initReport({
|
||||
date,
|
||||
practitioner,
|
||||
animal,
|
||||
owner,
|
||||
observations: [],
|
||||
conclusion: '',
|
||||
recommendations: '',
|
||||
})
|
||||
initReport(
|
||||
{
|
||||
date,
|
||||
practitioner,
|
||||
animal,
|
||||
owner,
|
||||
observations: [],
|
||||
conclusion: '',
|
||||
recommendations: '',
|
||||
},
|
||||
sheet.index.sheet.ref,
|
||||
)
|
||||
navigate('/editor')
|
||||
}
|
||||
|
||||
@@ -47,16 +66,52 @@ export default function NewReportRoute() {
|
||||
<main className="min-h-screen">
|
||||
<AppHeader />
|
||||
<div className="max-w-3xl mx-auto px-4 sm:px-6 py-6 sm:py-8 space-y-6 sm:space-y-8">
|
||||
<h1 className="font-serif text-2xl sm:text-3xl">{t('new_report.title')}</h1>
|
||||
<h1 className="font-serif text-2xl sm:text-3xl">
|
||||
{t('new_report.title')}
|
||||
</h1>
|
||||
{sheet.status === 'none' && (
|
||||
<p className="text-sm text-red-700">
|
||||
{t('home.no_sheet.description')}
|
||||
</p>
|
||||
)}
|
||||
<div>
|
||||
<Label htmlFor="date">{t('new_report.date_label')}</Label>
|
||||
<Input id="date" type="date" value={date} onChange={(e) => setDate(e.target.value)} />
|
||||
<Input
|
||||
id="date"
|
||||
type="date"
|
||||
value={date}
|
||||
onChange={(e) => setDate(e.target.value)}
|
||||
/>
|
||||
</div>
|
||||
<PractitionerForm value={practitioner} onChange={setPractitioner} />
|
||||
<AnimalForm animal={animal} owner={owner} onChangeAnimal={setAnimal} onChangeOwner={setOwner} />
|
||||
<AnimalForm
|
||||
animal={animal}
|
||||
owner={owner}
|
||||
species={
|
||||
sheet.status === 'ready'
|
||||
? [
|
||||
{
|
||||
id: sheet.index.sheet.speciesId,
|
||||
name: sheet.index.sheet.document.name,
|
||||
},
|
||||
]
|
||||
: [
|
||||
{
|
||||
id: DEFAULT_SPECIES_ID,
|
||||
name: { fr: 'Cheval', en: 'Horse' },
|
||||
},
|
||||
]
|
||||
}
|
||||
onChangeAnimal={setAnimal}
|
||||
onChangeOwner={setOwner}
|
||||
/>
|
||||
<div className="flex gap-3 justify-end">
|
||||
<Button variant="ghost" onClick={() => navigate('/')}>{t('common.cancel')}</Button>
|
||||
<Button disabled={!canSubmit} onClick={submit}>{t('new_report.submit')}</Button>
|
||||
<Button variant="ghost" onClick={() => navigate('/')}>
|
||||
{t('common.cancel')}
|
||||
</Button>
|
||||
<Button disabled={!canSubmit} onClick={submit}>
|
||||
{t('new_report.submit')}
|
||||
</Button>
|
||||
</div>
|
||||
</div>
|
||||
</main>
|
||||
|
||||
@@ -9,8 +9,12 @@ export default function NotFoundRoute() {
|
||||
<main className="min-h-screen grid place-items-center">
|
||||
<div className="text-center space-y-4">
|
||||
<h1 className="font-serif text-4xl">{t('not_found.title')}</h1>
|
||||
<p className="text-[var(--color-ink-muted)]">{t('not_found.description')}</p>
|
||||
<Button onClick={() => navigate('/')}>{t('common.back_to_home')}</Button>
|
||||
<p className="text-[var(--color-ink-muted)]">
|
||||
{t('not_found.description')}
|
||||
</p>
|
||||
<Button onClick={() => navigate('/')}>
|
||||
{t('common.back_to_home')}
|
||||
</Button>
|
||||
</div>
|
||||
</main>
|
||||
)
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -1,4 +1,3 @@
|
||||
import { Link } from 'react-router-dom'
|
||||
import { useConfig } from '@/app/providers/ConfigProvider'
|
||||
import { useT } from '@/i18n/useT'
|
||||
|
||||
@@ -9,14 +8,7 @@ export default function Footer() {
|
||||
return (
|
||||
<footer className="mt-8 sm:mt-12 border-t border-neutral-200 bg-neutral-50 py-4 sm:py-6 text-center text-xs sm:text-sm text-neutral-600">
|
||||
<p className="mb-3">
|
||||
© {year} {cfg.footerName}. {t('footer.all_rights_reserved')}{' '}
|
||||
<span className="text-neutral-300">·</span>{' '}
|
||||
<Link
|
||||
to="/editors"
|
||||
className="text-[var(--color-accent)] hover:text-[var(--color-accent-strong)] transition-colors"
|
||||
>
|
||||
{t('footer.editors')}
|
||||
</Link>
|
||||
© {year} {cfg.footerName}. {t('footer.all_rights_reserved')}
|
||||
</p>
|
||||
<div className="flex flex-wrap items-center justify-center gap-2 sm:gap-4">
|
||||
<span className="flex items-center gap-2">
|
||||
|
||||
@@ -1,77 +1,83 @@
|
||||
import { useCallback, useEffect, useRef, useState } from 'react'
|
||||
import { loadSvg } from '@/anatomy/svgLoader'
|
||||
import {
|
||||
getBoneIdFromEvent,
|
||||
getAnnotatedElement,
|
||||
} from '@/anatomy/svgConvention'
|
||||
import type { BoneState } from '@/anatomy/types'
|
||||
import { useCallback, useEffect, useRef } from 'react'
|
||||
import { buildViewSvg, type ViewStates } from '@/anatomy/drawing'
|
||||
import type { SheetIndex } from '@/services/sheetIndex'
|
||||
import { useLocaleStore } from '@/state/localeStore'
|
||||
import { pickLocaleLabel } from '@/i18n/pickLocaleLabel'
|
||||
|
||||
export interface AnatomyCanvasProps {
|
||||
src: string
|
||||
boneStates: Map<string, BoneState>
|
||||
onZoneClick: (boneId: string) => void
|
||||
index: SheetIndex
|
||||
viewId: string
|
||||
states: ViewStates
|
||||
onZoneClick: (annotationId: string, viewId: string) => void
|
||||
className?: string
|
||||
}
|
||||
|
||||
const ANNOTATED = '[data-anno-id]'
|
||||
|
||||
function annotatedTarget(event: Event): Element | null {
|
||||
const target = event.target
|
||||
return target instanceof Element ? target.closest(ANNOTATED) : null
|
||||
}
|
||||
|
||||
/**
|
||||
* One view of the sheet: the drawing plus the annotation layer generated
|
||||
* from the document, rebuilt when the view changes and restyled in place
|
||||
* when the selection changes. Clicks are delegated on `data-anno-id`.
|
||||
*/
|
||||
export default function AnatomyCanvas({
|
||||
src,
|
||||
boneStates,
|
||||
index,
|
||||
viewId,
|
||||
states,
|
||||
onZoneClick,
|
||||
className = '',
|
||||
}: AnatomyCanvasProps) {
|
||||
const wrapperRef = useRef<HTMLDivElement | null>(null)
|
||||
const svgRef = useRef<HTMLDivElement | null>(null)
|
||||
const tooltipRef = useRef<HTMLDivElement | null>(null)
|
||||
const [loadedSrc, setLoadedSrc] = useState<string | null>(null)
|
||||
const locale = useLocaleStore((s) => s.locale)
|
||||
|
||||
useEffect(() => {
|
||||
let cancelled = false
|
||||
const c = svgRef.current
|
||||
if (!c) return
|
||||
c.replaceChildren()
|
||||
setLoadedSrc(null)
|
||||
loadSvg(src).then((root) => {
|
||||
if (cancelled || !c) return
|
||||
c.appendChild(root)
|
||||
setLoadedSrc(src)
|
||||
})
|
||||
return () => { cancelled = true }
|
||||
}, [src])
|
||||
const host = svgRef.current
|
||||
if (!host) return
|
||||
host.replaceChildren(buildViewSvg(index, viewId, states))
|
||||
// States are applied by the effect below; the build only needs the view.
|
||||
// eslint-disable-next-line react-hooks/exhaustive-deps
|
||||
}, [index, viewId])
|
||||
|
||||
useEffect(() => {
|
||||
const c = svgRef.current
|
||||
if (!c) return
|
||||
const onClick = (e: Event) => {
|
||||
const id = getBoneIdFromEvent(e)
|
||||
if (id) onZoneClick(id)
|
||||
}
|
||||
c.addEventListener('click', onClick)
|
||||
return () => c.removeEventListener('click', onClick)
|
||||
}, [onZoneClick])
|
||||
|
||||
useEffect(() => {
|
||||
const c = svgRef.current
|
||||
if (!c || loadedSrc !== src) return
|
||||
const all = c.querySelectorAll<Element>('[data-anno-id]')
|
||||
all.forEach((el) => {
|
||||
const id = el.getAttribute('data-anno-id') as string
|
||||
const state = boneStates.get(id)
|
||||
if (state && state !== 'default') el.setAttribute('data-state', state)
|
||||
const host = svgRef.current
|
||||
if (!host) return
|
||||
host.querySelectorAll<Element>(ANNOTATED).forEach((el) => {
|
||||
const state = states.get(el.getAttribute('data-anno-id') ?? '')
|
||||
if (state) el.setAttribute('data-state', state)
|
||||
else el.removeAttribute('data-state')
|
||||
})
|
||||
}, [boneStates, loadedSrc, src])
|
||||
}, [states, index, viewId])
|
||||
|
||||
useEffect(() => {
|
||||
const host = svgRef.current
|
||||
if (!host) return
|
||||
const onClick = (e: Event) => {
|
||||
const id = annotatedTarget(e)?.getAttribute('data-anno-id')
|
||||
if (id) onZoneClick(id, viewId)
|
||||
}
|
||||
host.addEventListener('click', onClick)
|
||||
return () => host.removeEventListener('click', onClick)
|
||||
}, [onZoneClick, viewId])
|
||||
|
||||
const showTooltip = useCallback(
|
||||
(el: Element, x: number, y: number) => {
|
||||
const tip = tooltipRef.current
|
||||
if (!tip) return
|
||||
const fr = el.getAttribute('data-anno-name-fr') ?? ''
|
||||
const en = el.getAttribute('data-anno-name-en') ?? ''
|
||||
const label = pickLocaleLabel(fr, en, locale)
|
||||
if (!label) { tip.style.opacity = '0'; return }
|
||||
const label = pickLocaleLabel(
|
||||
el.getAttribute('data-anno-name-fr') ?? '',
|
||||
el.getAttribute('data-anno-name-en') ?? '',
|
||||
locale,
|
||||
)
|
||||
if (!label) {
|
||||
tip.style.opacity = '0'
|
||||
return
|
||||
}
|
||||
tip.textContent = label
|
||||
tip.style.opacity = '1'
|
||||
tip.style.left = `${x + 12}px`
|
||||
@@ -80,46 +86,40 @@ export default function AnatomyCanvas({
|
||||
[locale],
|
||||
)
|
||||
|
||||
const hideTooltip = useCallback(() => {
|
||||
const tip = tooltipRef.current
|
||||
if (tip) tip.style.opacity = '0'
|
||||
}, [])
|
||||
|
||||
useEffect(() => {
|
||||
const c = svgRef.current
|
||||
if (!c || loadedSrc !== src) return
|
||||
const host = svgRef.current
|
||||
if (!host) return
|
||||
const hide = () => {
|
||||
if (tooltipRef.current) tooltipRef.current.style.opacity = '0'
|
||||
}
|
||||
const onMove = (e: MouseEvent) => {
|
||||
const el = getAnnotatedElement(e)
|
||||
if (el && !el.hasAttribute('data-anno-opens-detail')) {
|
||||
const w = wrapperRef.current
|
||||
if (!w) return
|
||||
const rect = w.getBoundingClientRect()
|
||||
showTooltip(el, e.clientX - rect.left, e.clientY - rect.top)
|
||||
} else {
|
||||
hideTooltip()
|
||||
}
|
||||
const el = annotatedTarget(e)
|
||||
const wrapper = wrapperRef.current
|
||||
if (!el || !wrapper || el.hasAttribute('data-anno-opens-view'))
|
||||
return hide()
|
||||
const rect = wrapper.getBoundingClientRect()
|
||||
showTooltip(el, e.clientX - rect.left, e.clientY - rect.top)
|
||||
}
|
||||
const onLeave = () => hideTooltip()
|
||||
c.addEventListener('mousemove', onMove)
|
||||
c.addEventListener('mouseleave', onLeave)
|
||||
host.addEventListener('mousemove', onMove)
|
||||
host.addEventListener('mouseleave', hide)
|
||||
return () => {
|
||||
c.removeEventListener('mousemove', onMove)
|
||||
c.removeEventListener('mouseleave', onLeave)
|
||||
host.removeEventListener('mousemove', onMove)
|
||||
host.removeEventListener('mouseleave', hide)
|
||||
}
|
||||
}, [loadedSrc, src, showTooltip, hideTooltip])
|
||||
}, [showTooltip])
|
||||
|
||||
return (
|
||||
<div
|
||||
data-testid="anatomy-canvas"
|
||||
data-view-id={viewId}
|
||||
ref={wrapperRef}
|
||||
className={`svg-canvas relative w-full h-full ${className}`}
|
||||
>
|
||||
<div ref={svgRef} className="w-full h-full [&>svg]:max-w-full [&>svg]:max-h-full [&>svg]:mx-auto" />
|
||||
<div
|
||||
ref={tooltipRef}
|
||||
className="zone-tooltip"
|
||||
style={{ opacity: 0 }}
|
||||
ref={svgRef}
|
||||
className="w-full h-full [&>svg]:max-w-full [&>svg]:max-h-full [&>svg]:mx-auto"
|
||||
/>
|
||||
<div ref={tooltipRef} className="zone-tooltip" style={{ opacity: 0 }} />
|
||||
</div>
|
||||
)
|
||||
}
|
||||
@@ -1,25 +1,27 @@
|
||||
import Dialog from '@/components/ui/Dialog'
|
||||
import AnatomyCanvas from './AnatomyCanvas'
|
||||
import type { BoneState } from '@/anatomy/types'
|
||||
import type { ViewStates } from '@/anatomy/drawing'
|
||||
import type { SheetIndex } from '@/services/sheetIndex'
|
||||
import { useT } from '@/i18n/useT'
|
||||
|
||||
export interface DetailModalProps {
|
||||
open: boolean
|
||||
onClose: () => void
|
||||
detailSrc: string
|
||||
detailId: string
|
||||
index: SheetIndex
|
||||
viewId: string
|
||||
title: string
|
||||
boneStates: Map<string, BoneState>
|
||||
onZoneClick: (boneId: string, detailId: string) => void
|
||||
states: ViewStates
|
||||
onZoneClick: (annotationId: string, viewId: string) => void
|
||||
}
|
||||
|
||||
/** A detail view of the sheet (a crop or its own drawing) in a dialog. */
|
||||
export default function DetailModal({
|
||||
open,
|
||||
onClose,
|
||||
detailSrc,
|
||||
detailId,
|
||||
index,
|
||||
viewId,
|
||||
title,
|
||||
boneStates,
|
||||
states,
|
||||
onZoneClick,
|
||||
}: DetailModalProps) {
|
||||
const t = useT()
|
||||
@@ -27,9 +29,10 @@ export default function DetailModal({
|
||||
<Dialog open={open} onClose={onClose} title={title} size="xl">
|
||||
<div className="aspect-[4/3] w-full">
|
||||
<AnatomyCanvas
|
||||
src={detailSrc}
|
||||
boneStates={boneStates}
|
||||
onZoneClick={(id) => onZoneClick(id, detailId)}
|
||||
index={index}
|
||||
viewId={viewId}
|
||||
states={states}
|
||||
onZoneClick={onZoneClick}
|
||||
/>
|
||||
</div>
|
||||
<p className="mt-4 text-sm text-[var(--color-ink-muted)]">
|
||||
|
||||
@@ -1,75 +1,84 @@
|
||||
import { useMemo, useState } from 'react'
|
||||
import { motion } from 'motion/react'
|
||||
import type {
|
||||
Finding,
|
||||
FindingCategory,
|
||||
FindingNode,
|
||||
ZoneFindings,
|
||||
} from '@/domain/schema/findings'
|
||||
import type { Finding, LateralSide } from '@/domain/schema/observation'
|
||||
FindingZone,
|
||||
LateralSide,
|
||||
LocalizedOptionalText,
|
||||
} from '@faunosteo/domain'
|
||||
import Button from '@/components/ui/Button'
|
||||
import { pickLabel } from '@/services/sheetIndex'
|
||||
import { useT } from '@/i18n/useT'
|
||||
import { useLocaleStore } from '@/state/localeStore'
|
||||
import type { Locale } from '@/i18n/types'
|
||||
|
||||
const levelVariants = {
|
||||
enter: (dir: 1 | -1) => ({ opacity: 0, x: dir * 32 }),
|
||||
center: { opacity: 1, x: 0 },
|
||||
}
|
||||
|
||||
type TreeNode = FindingCategory | FindingNode
|
||||
|
||||
export interface FindingsTreePickerProps {
|
||||
zoneId: string
|
||||
tree: ZoneFindings
|
||||
zone: FindingZone
|
||||
side?: LateralSide
|
||||
selected: Finding[]
|
||||
onChange: (next: Finding[]) => void
|
||||
}
|
||||
|
||||
function isLeaf(node: FindingNode): boolean {
|
||||
return !node.children || node.children.length === 0
|
||||
function isLeaf(node: TreeNode): boolean {
|
||||
return node.children.length === 0
|
||||
}
|
||||
|
||||
function samePath(a: string[], b: string[]): boolean {
|
||||
if (a.length !== b.length) return false
|
||||
for (let i = 0; i < a.length; i += 1) {
|
||||
if (a[i] !== b[i]) return false
|
||||
}
|
||||
return true
|
||||
function samePath(a: readonly string[], b: readonly string[]): boolean {
|
||||
return a.length === b.length && a.every((seg, i) => seg === b[i])
|
||||
}
|
||||
|
||||
function pathStartsWith(full: string[], prefix: string[]): boolean {
|
||||
if (full.length < prefix.length) return false
|
||||
for (let i = 0; i < prefix.length; i += 1) {
|
||||
if (full[i] !== prefix[i]) return false
|
||||
}
|
||||
return true
|
||||
function pathStartsWith(
|
||||
full: readonly string[],
|
||||
prefix: readonly string[],
|
||||
): boolean {
|
||||
return (
|
||||
full.length >= prefix.length && prefix.every((seg, i) => full[i] === seg)
|
||||
)
|
||||
}
|
||||
|
||||
function findNode(
|
||||
categories: FindingNode[],
|
||||
path: string[],
|
||||
): FindingNode | undefined {
|
||||
let nodes: FindingNode[] = categories
|
||||
let node: FindingNode | undefined
|
||||
categories: readonly FindingCategory[],
|
||||
path: readonly string[],
|
||||
): TreeNode | undefined {
|
||||
let nodes: readonly TreeNode[] = categories
|
||||
let node: TreeNode | undefined
|
||||
for (const segment of path) {
|
||||
node = nodes.find((n) => n.id === segment)
|
||||
if (!node) return undefined
|
||||
nodes = node.children ?? []
|
||||
nodes = node.children
|
||||
}
|
||||
return node
|
||||
}
|
||||
|
||||
function descriptionOf(node: TreeNode, locale: Locale): string | undefined {
|
||||
const text: LocalizedOptionalText | undefined = node.description
|
||||
if (!text) return undefined
|
||||
return (
|
||||
(locale === 'en' ? text.en || text.fr : text.fr || text.en) || undefined
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* Drill-down picker over one finding zone of the sheet. A finding is keyed
|
||||
* by `(findingZoneId, path, side)`; labels are snapshotted at selection.
|
||||
*/
|
||||
export default function FindingsTreePicker({
|
||||
zoneId,
|
||||
tree,
|
||||
zone,
|
||||
side,
|
||||
selected,
|
||||
onChange,
|
||||
}: FindingsTreePickerProps) {
|
||||
const t = useT()
|
||||
const locale = useLocaleStore((s) => s.locale)
|
||||
const nameOf = (node: { name_fr: string; name_en: string }) =>
|
||||
locale === 'en' ? node.name_en : node.name_fr
|
||||
const descOf = (node: { description_fr?: string; description_en?: string }) =>
|
||||
locale === 'en' ? node.description_en : node.description_fr
|
||||
|
||||
const [path, setPath] = useState<string[]>([])
|
||||
const [direction, setDirection] = useState<1 | -1>(1)
|
||||
|
||||
@@ -86,74 +95,57 @@ export default function FindingsTreePicker({
|
||||
setPath(path.slice(0, depth))
|
||||
}
|
||||
|
||||
const currentNodes = useMemo<FindingNode[]>(() => {
|
||||
if (path.length === 0) return tree.categories
|
||||
const node = findNode(tree.categories, path)
|
||||
return node?.children ?? []
|
||||
}, [tree, path])
|
||||
const currentNodes = useMemo<readonly TreeNode[]>(() => {
|
||||
if (path.length === 0) return zone.categories
|
||||
return findNode(zone.categories, path)?.children ?? []
|
||||
}, [zone, path])
|
||||
|
||||
const focusedNode = useMemo(
|
||||
() => (path.length === 0 ? undefined : findNode(tree.categories, path)),
|
||||
[tree, path],
|
||||
() => (path.length === 0 ? undefined : findNode(zone.categories, path)),
|
||||
[zone, path],
|
||||
)
|
||||
|
||||
const breadcrumb = useMemo<{ label: string; depth: number }[]>(() => {
|
||||
const pick = (z: { name_fr: string; name_en: string }) =>
|
||||
locale === 'en' ? z.name_en : z.name_fr
|
||||
const crumbs: { label: string; depth: number }[] = [
|
||||
{ label: pick(tree), depth: 0 },
|
||||
]
|
||||
let nodes: FindingNode[] = tree.categories
|
||||
const crumbs = [{ label: pickLabel(zone.name, locale), depth: 0 }]
|
||||
let nodes: readonly TreeNode[] = zone.categories
|
||||
path.forEach((seg, i) => {
|
||||
const n = nodes.find((x) => x.id === seg)
|
||||
if (n) {
|
||||
crumbs.push({ label: pick(n), depth: i + 1 })
|
||||
nodes = n.children ?? []
|
||||
crumbs.push({ label: pickLabel(n.name, locale), depth: i + 1 })
|
||||
nodes = n.children
|
||||
}
|
||||
})
|
||||
return crumbs
|
||||
}, [tree, path, locale])
|
||||
}, [zone, path, locale])
|
||||
|
||||
function matchesSide(f: Finding): boolean {
|
||||
return f.zoneId === zoneId && f.side === side
|
||||
}
|
||||
const matches = (f: Finding) => f.findingZoneId === zone.id && f.side === side
|
||||
const isLeafSelected = (leafPath: string[]) =>
|
||||
selected.some((f) => matches(f) && samePath(f.path, leafPath))
|
||||
const countSelectedUnder = (nodePath: string[]) =>
|
||||
selected.filter((f) => matches(f) && pathStartsWith(f.path, nodePath))
|
||||
.length
|
||||
|
||||
function isLeafSelected(leafPath: string[]): boolean {
|
||||
return selected.some(
|
||||
(f) => matchesSide(f) && samePath(f.path, leafPath),
|
||||
)
|
||||
}
|
||||
|
||||
function countSelectedUnder(nodePath: string[]): number {
|
||||
let n = 0
|
||||
for (const f of selected) {
|
||||
if (!matchesSide(f)) continue
|
||||
if (!pathStartsWith(f.path, nodePath)) continue
|
||||
n += 1
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
function toggleLeaf(leafPath: string[], leaf: FindingNode) {
|
||||
function toggleLeaf(leafPath: string[], leaf: TreeNode) {
|
||||
if (isLeafSelected(leafPath)) {
|
||||
onChange(
|
||||
selected.filter(
|
||||
(f) => !(matchesSide(f) && samePath(f.path, leafPath)),
|
||||
),
|
||||
selected.filter((f) => !(matches(f) && samePath(f.path, leafPath))),
|
||||
)
|
||||
return
|
||||
}
|
||||
const next: Finding = {
|
||||
zoneId,
|
||||
findingZoneId: zone.id,
|
||||
path: leafPath,
|
||||
labelFrSnapshot: leaf.name_fr,
|
||||
labelEnSnapshot: leaf.name_en,
|
||||
labelFrSnapshot: leaf.name.fr,
|
||||
labelEnSnapshot: leaf.name.en,
|
||||
}
|
||||
if (leaf.requires_vet_referral) next.requiresVetReferral = true
|
||||
if ('requires_vet_referral' in leaf && leaf.requires_vet_referral)
|
||||
next.requiresVetReferral = true
|
||||
if (side) next.side = side
|
||||
onChange([...selected, next])
|
||||
}
|
||||
|
||||
const focusedDescription = focusedNode && descriptionOf(focusedNode, locale)
|
||||
|
||||
return (
|
||||
<div className="space-y-2">
|
||||
<div className="flex flex-wrap items-center gap-1 text-xs text-[var(--color-ink-muted)]">
|
||||
@@ -179,9 +171,9 @@ export default function FindingsTreePicker({
|
||||
})}
|
||||
</div>
|
||||
|
||||
{focusedNode && descOf(focusedNode) && (
|
||||
{focusedDescription && (
|
||||
<p className="text-xs italic text-[var(--color-ink-muted)]">
|
||||
{descOf(focusedNode)}
|
||||
{focusedDescription}
|
||||
</p>
|
||||
)}
|
||||
|
||||
@@ -196,16 +188,16 @@ export default function FindingsTreePicker({
|
||||
</Button>
|
||||
)}
|
||||
|
||||
<motion.ul
|
||||
key={path.join('/') || '__root__'}
|
||||
custom={direction}
|
||||
variants={levelVariants}
|
||||
initial="enter"
|
||||
animate="center"
|
||||
transition={{ duration: 0.22, ease: 'easeOut' }}
|
||||
style={{ willChange: 'transform, opacity' }}
|
||||
className="space-y-1.5 max-h-64 overflow-auto pr-1"
|
||||
>
|
||||
<motion.ul
|
||||
key={path.join('/') || '__root__'}
|
||||
custom={direction}
|
||||
variants={levelVariants}
|
||||
initial="enter"
|
||||
animate="center"
|
||||
transition={{ duration: 0.22, ease: 'easeOut' }}
|
||||
style={{ willChange: 'transform, opacity' }}
|
||||
className="space-y-1.5 max-h-64 overflow-auto pr-1"
|
||||
>
|
||||
{currentNodes.length === 0 ? (
|
||||
<li className="text-sm text-[var(--color-ink-muted)]">
|
||||
{t('findings.no_options')}
|
||||
@@ -213,16 +205,17 @@ export default function FindingsTreePicker({
|
||||
) : (
|
||||
currentNodes.map((node) => {
|
||||
const nodePath = [...path, node.id]
|
||||
const nodeLabel = pickLabel(node.name, locale)
|
||||
const nodeDesc = descriptionOf(node, locale)
|
||||
if (isLeaf(node)) {
|
||||
const checked = isLeafSelected(nodePath)
|
||||
const nodeLabel = nameOf(node)
|
||||
const nodeDesc = descOf(node)
|
||||
const vet =
|
||||
'requires_vet_referral' in node && node.requires_vet_referral
|
||||
return (
|
||||
<li key={node.id}>
|
||||
<label className="flex items-start gap-2 cursor-pointer">
|
||||
<input
|
||||
type="checkbox"
|
||||
checked={checked}
|
||||
checked={isLeafSelected(nodePath)}
|
||||
onChange={() => toggleLeaf(nodePath, node)}
|
||||
className="mt-1 accent-[var(--color-accent)]"
|
||||
aria-label={nodeLabel}
|
||||
@@ -232,7 +225,7 @@ export default function FindingsTreePicker({
|
||||
<span className="text-sm font-medium text-[var(--color-ink)]">
|
||||
{nodeLabel}
|
||||
</span>
|
||||
{node.requires_vet_referral && (
|
||||
{vet && (
|
||||
<span
|
||||
title={t('findings.vet_referral')}
|
||||
aria-label={t('findings.vet_referral')}
|
||||
@@ -253,7 +246,6 @@ export default function FindingsTreePicker({
|
||||
)
|
||||
}
|
||||
const selectedCount = countSelectedUnder(nodePath)
|
||||
const nodeLabel = nameOf(node)
|
||||
const selectedAria = `${selectedCount} ${
|
||||
selectedCount > 1
|
||||
? t('findings.selected_plural')
|
||||
@@ -278,7 +270,10 @@ export default function FindingsTreePicker({
|
||||
</span>
|
||||
)}
|
||||
</span>
|
||||
<span aria-hidden="true" className="text-[var(--color-ink-muted)]">
|
||||
<span
|
||||
aria-hidden="true"
|
||||
className="text-[var(--color-ink-muted)]"
|
||||
>
|
||||
›
|
||||
</span>
|
||||
</button>
|
||||
@@ -286,7 +281,7 @@ export default function FindingsTreePicker({
|
||||
)
|
||||
})
|
||||
)}
|
||||
</motion.ul>
|
||||
</motion.ul>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
@@ -1,6 +1,6 @@
|
||||
import Dialog from '@/components/ui/Dialog'
|
||||
import Button from '@/components/ui/Button'
|
||||
import type { LateralSide } from '@/domain/schema/observation'
|
||||
import type { LateralSide } from '@faunosteo/domain'
|
||||
import { useT } from '@/i18n/useT'
|
||||
|
||||
export interface LateralityPickerProps {
|
||||
|
||||
@@ -1,16 +1,11 @@
|
||||
import { useMemo, useState } from 'react'
|
||||
import type {
|
||||
Observation,
|
||||
ObservationZone,
|
||||
Vertebra,
|
||||
Finding,
|
||||
FindingZone,
|
||||
LateralSide,
|
||||
} from '@/domain/schema/observation'
|
||||
import type {
|
||||
SpeciesFindings,
|
||||
ZoneFindings,
|
||||
} from '@/domain/schema/findings'
|
||||
import type { Bone } from '@/anatomy/types'
|
||||
import { matchZoneFindings } from '@/lib/zoneMatch'
|
||||
Observation,
|
||||
ReportZone,
|
||||
} from '@faunosteo/domain'
|
||||
import { AnimatePresence, motion } from 'motion/react'
|
||||
import Card from '@/components/ui/Card'
|
||||
import Badge from '@/components/ui/Badge'
|
||||
@@ -20,9 +15,9 @@ import Textarea from '@/components/ui/Textarea'
|
||||
import FindingsTreePicker from './FindingsTreePicker'
|
||||
import FreeTextFindingInput from './FreeTextFindingInput'
|
||||
import SeveritySelector from './SeveritySelector'
|
||||
import { isObservable, pickLabel, type SheetIndex } from '@/services/sheetIndex'
|
||||
import { useT } from '@/i18n/useT'
|
||||
import { useLocaleStore } from '@/state/localeStore'
|
||||
import { boneLabel } from '@/anatomy/labels'
|
||||
import type { Locale } from '@/i18n/types'
|
||||
|
||||
export interface ObservationCardProps {
|
||||
@@ -36,35 +31,75 @@ export interface ObservationCardProps {
|
||||
canMoveUp: boolean
|
||||
canMoveDown: boolean
|
||||
// Editor body props (used only when expanded)
|
||||
bones: Map<string, Bone>
|
||||
findings: SpeciesFindings | null
|
||||
sheet: SheetIndex
|
||||
onChange: (next: Observation) => void
|
||||
onOpenVertebraPicker: (zoneIndex: number) => void
|
||||
onRemoveZone: (zoneIndex: number) => void
|
||||
}
|
||||
|
||||
/** Zone label: the sheet's current name, else the snapshot, else the id. */
|
||||
export function zoneLabel(
|
||||
z: ReportZone,
|
||||
sheet: SheetIndex,
|
||||
locale: Locale,
|
||||
): string {
|
||||
const annotation = sheet.annotation(z.annotationId)
|
||||
if (annotation) return pickLabel(sheet.name(annotation), locale)
|
||||
const snapshot =
|
||||
locale === 'en'
|
||||
? z.labelEnSnapshot || z.labelFrSnapshot
|
||||
: z.labelFrSnapshot || z.labelEnSnapshot
|
||||
return snapshot || z.annotationId
|
||||
}
|
||||
|
||||
function describeZone(
|
||||
z: ObservationZone,
|
||||
bones: Map<string, Bone>,
|
||||
z: ReportZone,
|
||||
sheet: SheetIndex,
|
||||
locale: Locale,
|
||||
t: (key: string) => string,
|
||||
): string {
|
||||
const label = boneLabel(bones.get(z.boneId), locale, z.boneId)
|
||||
const label = zoneLabel(z, sheet, locale)
|
||||
if (z.vertebrae?.length) {
|
||||
const vs = z.vertebrae
|
||||
.map((v: Vertebra) => `${v.region}${v.index}`)
|
||||
.join(', ')
|
||||
return `${label} (${vs})`
|
||||
return `${label} (${z.vertebrae.map((v) => `${v.region}${v.index}`).join(', ')})`
|
||||
}
|
||||
if (z.side) {
|
||||
const sideLabel = t(
|
||||
z.side === 'left' ? 'lateral.left_short' : 'lateral.right_short',
|
||||
)
|
||||
return `${label} (${sideLabel})`
|
||||
return `${label} (${t(z.side === 'left' ? 'lateral.left_short' : 'lateral.right_short')})`
|
||||
}
|
||||
return label
|
||||
}
|
||||
|
||||
interface ZoneTree {
|
||||
zone: FindingZone
|
||||
side?: LateralSide
|
||||
}
|
||||
|
||||
/** One picker per (finding zone, side) the observation's zones resolve to. */
|
||||
function zoneTrees(observation: Observation, sheet: SheetIndex): ZoneTree[] {
|
||||
const seen = new Set<string>()
|
||||
const out: ZoneTree[] = []
|
||||
for (const z of observation.zones) {
|
||||
const annotation = sheet.annotation(z.annotationId)
|
||||
if (!isObservable(annotation) || !annotation.finding_zone_id) continue
|
||||
const zone = sheet.findingZone(annotation.finding_zone_id)
|
||||
if (!zone) continue
|
||||
const key = z.side ? `${zone.id}:${z.side}` : zone.id
|
||||
if (seen.has(key)) continue
|
||||
seen.add(key)
|
||||
out.push({ zone, side: z.side })
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
/** Findings the sheet no longer holds at their path (migrated data, kept verbatim). */
|
||||
function unresolvedFindings(
|
||||
observation: Observation,
|
||||
sheet: SheetIndex,
|
||||
): Finding[] {
|
||||
return observation.findings.filter(
|
||||
(f) => !sheet.nodeAt(f.findingZoneId, f.path),
|
||||
)
|
||||
}
|
||||
|
||||
export default function ObservationCard({
|
||||
observation,
|
||||
index,
|
||||
@@ -75,34 +110,37 @@ export default function ObservationCard({
|
||||
onMoveDown,
|
||||
canMoveUp,
|
||||
canMoveDown,
|
||||
bones,
|
||||
findings,
|
||||
sheet,
|
||||
onChange,
|
||||
onOpenVertebraPicker,
|
||||
onRemoveZone,
|
||||
}: ObservationCardProps) {
|
||||
const t = useT()
|
||||
const locale = useLocaleStore((s) => s.locale)
|
||||
const nameOf = (z: { name_fr: string; name_en: string }) =>
|
||||
locale === 'en' ? z.name_en : z.name_fr
|
||||
|
||||
// Per-zone picker accordion — only one tree picker open at a time,
|
||||
// matching the observation-card accordion semantics. Closed by default
|
||||
// so the card stays compact when first expanded.
|
||||
const [expandedZoneId, setExpandedZoneId] = useState<string | null>(null)
|
||||
|
||||
const zoneCount = observation.zones.length
|
||||
const findingCount =
|
||||
observation.findings.length + observation.freeTextFindings.length
|
||||
|
||||
const zoneCountLabel =
|
||||
const zoneCountLabel = t(
|
||||
zoneCount > 1
|
||||
? t('observation.zone_label_plural')
|
||||
: t('observation.zone_label_singular')
|
||||
const findingCountLabel =
|
||||
? 'observation.zone_label_plural'
|
||||
: 'observation.zone_label_singular',
|
||||
)
|
||||
const findingCountLabel = t(
|
||||
findingCount > 1
|
||||
? t('observation.finding_label_plural')
|
||||
: t('observation.finding_label_singular')
|
||||
? 'observation.finding_label_plural'
|
||||
: 'observation.finding_label_singular',
|
||||
)
|
||||
|
||||
const trees = useMemo(
|
||||
() => zoneTrees(observation, sheet),
|
||||
[observation, sheet],
|
||||
)
|
||||
const unresolved = useMemo(
|
||||
() => unresolvedFindings(observation, sheet),
|
||||
[observation, sheet],
|
||||
)
|
||||
|
||||
function onHeaderKey(event: React.KeyboardEvent<HTMLDivElement>) {
|
||||
if (event.key === 'Enter' || event.key === ' ') {
|
||||
@@ -110,39 +148,15 @@ export default function ObservationCard({
|
||||
onToggle()
|
||||
}
|
||||
}
|
||||
|
||||
function stop(fn: () => void) {
|
||||
return (event: React.MouseEvent) => {
|
||||
event.stopPropagation()
|
||||
fn()
|
||||
}
|
||||
const stop = (fn: () => void) => (event: React.MouseEvent) => {
|
||||
event.stopPropagation()
|
||||
fn()
|
||||
}
|
||||
|
||||
const zonesArray = useMemo(
|
||||
() => (findings ? Object.values(findings.zones) : []),
|
||||
[findings],
|
||||
)
|
||||
|
||||
const zonesWithTree = useMemo(() => {
|
||||
if (zonesArray.length === 0)
|
||||
return [] as { tree: ZoneFindings; side?: LateralSide }[]
|
||||
const seen = new Set<string>()
|
||||
const out: { tree: ZoneFindings; side?: LateralSide }[] = []
|
||||
for (const z of observation.zones) {
|
||||
const bone = bones.get(z.boneId)
|
||||
if (!bone) continue
|
||||
const tree = matchZoneFindings(
|
||||
{ fr: bone.fr, en: bone.en },
|
||||
zonesArray,
|
||||
)
|
||||
if (!tree) continue
|
||||
const key = z.side ? `${tree.id}:${z.side}` : tree.id
|
||||
if (seen.has(key)) continue
|
||||
seen.add(key)
|
||||
out.push({ tree, side: z.side })
|
||||
}
|
||||
return out
|
||||
}, [observation.zones, bones, zonesArray])
|
||||
const removeFinding = (target: Finding) =>
|
||||
onChange({
|
||||
...observation,
|
||||
findings: observation.findings.filter((f) => f !== target),
|
||||
})
|
||||
|
||||
return (
|
||||
<Card
|
||||
@@ -164,13 +178,16 @@ export default function ObservationCard({
|
||||
>
|
||||
<div className="flex-1 min-h-[60px] text-left">
|
||||
<div className="flex items-center gap-2 mb-2">
|
||||
<Badge tone="neutral">{t('observation.badge_n')}{index + 1}</Badge>
|
||||
<Badge tone="neutral">
|
||||
{t('observation.badge_n')}
|
||||
{index + 1}
|
||||
</Badge>
|
||||
{observation.severity && (
|
||||
<Badge
|
||||
tone={
|
||||
observation.severity === 'sévère'
|
||||
observation.severity === 'severe'
|
||||
? 'danger'
|
||||
: observation.severity === 'modérée'
|
||||
: observation.severity === 'moderate'
|
||||
? 'warn'
|
||||
: 'neutral'
|
||||
}
|
||||
@@ -248,43 +265,49 @@ export default function ObservationCard({
|
||||
</p>
|
||||
) : (
|
||||
<ul className="flex flex-wrap gap-2">
|
||||
{observation.zones.map((z, i) => {
|
||||
const b = bones.get(z.boneId)
|
||||
const supportsVertebrae =
|
||||
b?.special === 'vertebral-precision'
|
||||
return (
|
||||
<li key={`${z.boneId}-${i}`}>
|
||||
<Badge tone="accent" className="gap-2">
|
||||
{describeZone(z, bones, locale, t)}
|
||||
{supportsVertebrae && (
|
||||
<button
|
||||
type="button"
|
||||
onClick={() => onOpenVertebraPicker(i)}
|
||||
className="underline text-xs text-[var(--color-accent-strong)]"
|
||||
title={t('observation.vertebrae_button_title')}
|
||||
{observation.zones.map((z, i) => (
|
||||
<li
|
||||
key={`${z.annotationId}-${z.viewId}-${z.side ?? ''}-${i}`}
|
||||
>
|
||||
<Badge tone="accent" className="gap-2">
|
||||
{describeZone(z, sheet, locale, t)}
|
||||
{z.unresolved &&
|
||||
!sheet.annotation(z.annotationId) && (
|
||||
<span
|
||||
className="text-xs italic"
|
||||
title={t('observation.zone_unresolved')}
|
||||
>
|
||||
{t('observation.vertebrae_button')}
|
||||
</button>
|
||||
{t('observation.unresolved_short')}
|
||||
</span>
|
||||
)}
|
||||
{sheet.isSpine(z.annotationId) && (
|
||||
<button
|
||||
type="button"
|
||||
aria-label={`${t('observation.remove_zone')} ${boneLabel(b, locale, z.boneId)}`}
|
||||
onClick={() => onRemoveZone(i)}
|
||||
className="ml-1 text-[var(--color-accent-strong)]"
|
||||
onClick={() => onOpenVertebraPicker(i)}
|
||||
className="underline text-xs text-[var(--color-accent-strong)]"
|
||||
title={t('observation.vertebrae_button_title')}
|
||||
>
|
||||
✕
|
||||
{t('observation.vertebrae_button')}
|
||||
</button>
|
||||
</Badge>
|
||||
</li>
|
||||
)
|
||||
})}
|
||||
)}
|
||||
<button
|
||||
type="button"
|
||||
aria-label={`${t('observation.remove_zone')} ${zoneLabel(z, sheet, locale)}`}
|
||||
onClick={() => onRemoveZone(i)}
|
||||
className="ml-1 text-[var(--color-accent-strong)]"
|
||||
>
|
||||
✕
|
||||
</button>
|
||||
</Badge>
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
)}
|
||||
</section>
|
||||
|
||||
<section>
|
||||
<Label>{t('observation.findings_catalog_label')}</Label>
|
||||
{zonesWithTree.length === 0 ? (
|
||||
{trees.length === 0 ? (
|
||||
<p className="text-sm text-[var(--color-ink-muted)]">
|
||||
{observation.zones.length === 0
|
||||
? t('observation.findings_pick_zone_first')
|
||||
@@ -292,26 +315,19 @@ export default function ObservationCard({
|
||||
</p>
|
||||
) : (
|
||||
<ul className="space-y-2">
|
||||
{zonesWithTree.map(({ tree, side }) => {
|
||||
const pickerKey = side
|
||||
? `${tree.id}:${side}`
|
||||
: tree.id
|
||||
const expanded = expandedZoneId === pickerKey
|
||||
{trees.map(({ zone, side }) => {
|
||||
const pickerKey = side ? `${zone.id}:${side}` : zone.id
|
||||
const open = expandedZoneId === pickerKey
|
||||
const selectedCount = observation.findings.filter(
|
||||
(f) =>
|
||||
f.zoneId === tree.id && f.side === side,
|
||||
(f) => f.findingZoneId === zone.id && f.side === side,
|
||||
).length
|
||||
const selectedAria = `${selectedCount} ${
|
||||
selectedCount > 1
|
||||
? t('findings.selected_plural')
|
||||
: t('findings.selected_singular')
|
||||
}`
|
||||
const selectedAria = `${selectedCount} ${selectedCount > 1 ? t('findings.selected_plural') : t('findings.selected_singular')}`
|
||||
return (
|
||||
<li
|
||||
key={pickerKey}
|
||||
className={[
|
||||
'rounded-xl border bg-[var(--color-surface)] transition',
|
||||
expanded
|
||||
open
|
||||
? 'border-[var(--color-accent)] ring-1 ring-[var(--color-accent)]'
|
||||
: 'border-[var(--color-border)]',
|
||||
].join(' ')}
|
||||
@@ -319,16 +335,17 @@ export default function ObservationCard({
|
||||
<button
|
||||
type="button"
|
||||
onClick={() =>
|
||||
setExpandedZoneId(expanded ? null : pickerKey)
|
||||
setExpandedZoneId(open ? null : pickerKey)
|
||||
}
|
||||
aria-expanded={expanded}
|
||||
aria-expanded={open}
|
||||
aria-controls={`findings-zone-${pickerKey}`}
|
||||
className="w-full flex items-center justify-between gap-2 px-3 py-2 text-left rounded-xl focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[var(--color-accent)]/40"
|
||||
>
|
||||
<span className="flex items-center gap-2">
|
||||
<span className="text-sm font-medium text-[var(--color-ink)]">
|
||||
{nameOf(tree)}
|
||||
{side && ` (${t(side === 'left' ? 'lateral.left' : 'lateral.right')})`}
|
||||
{pickLabel(zone.name, locale)}
|
||||
{side &&
|
||||
` (${t(side === 'left' ? 'lateral.left' : 'lateral.right')})`}
|
||||
</span>
|
||||
{selectedCount > 0 && (
|
||||
<span
|
||||
@@ -343,11 +360,11 @@ export default function ObservationCard({
|
||||
aria-hidden="true"
|
||||
className="text-[var(--color-ink-muted)]"
|
||||
>
|
||||
{expanded ? '▲' : '▼'}
|
||||
{open ? '▲' : '▼'}
|
||||
</span>
|
||||
</button>
|
||||
<AnimatePresence initial={false}>
|
||||
{expanded && (
|
||||
{open && (
|
||||
<motion.div
|
||||
key="picker-body"
|
||||
id={`findings-zone-${pickerKey}`}
|
||||
@@ -359,12 +376,14 @@ export default function ObservationCard({
|
||||
>
|
||||
<div className="px-3 pb-3 pt-1 border-t border-[var(--color-border)]">
|
||||
<FindingsTreePicker
|
||||
zoneId={tree.id}
|
||||
tree={tree}
|
||||
zone={zone}
|
||||
side={side}
|
||||
selected={observation.findings}
|
||||
onChange={(next) =>
|
||||
onChange({ ...observation, findings: next })
|
||||
onChange({
|
||||
...observation,
|
||||
findings: next,
|
||||
})
|
||||
}
|
||||
/>
|
||||
</div>
|
||||
@@ -378,6 +397,40 @@ export default function ObservationCard({
|
||||
)}
|
||||
</section>
|
||||
|
||||
{unresolved.length > 0 && (
|
||||
<section>
|
||||
<Label>{t('observation.findings_unresolved_label')}</Label>
|
||||
<p className="text-xs text-[var(--color-ink-muted)] mb-2">
|
||||
{t('observation.findings_unresolved_help')}
|
||||
</p>
|
||||
<ul className="space-y-1">
|
||||
{unresolved.map((f, i) => (
|
||||
<li
|
||||
key={`${f.findingZoneId}-${f.path.join('/')}-${f.side ?? ''}-${i}`}
|
||||
className="flex items-center gap-2 text-sm"
|
||||
>
|
||||
<span className="text-[var(--color-ink)]">
|
||||
{f.requiresVetReferral ? '⚠ ' : ''}
|
||||
{locale === 'en'
|
||||
? f.labelEnSnapshot
|
||||
: f.labelFrSnapshot}
|
||||
{f.side &&
|
||||
` (${t(f.side === 'left' ? 'lateral.left_short' : 'lateral.right_short')})`}
|
||||
</span>
|
||||
<button
|
||||
type="button"
|
||||
aria-label={`${t('common.delete')} ${locale === 'en' ? f.labelEnSnapshot : f.labelFrSnapshot}`}
|
||||
onClick={() => removeFinding(f)}
|
||||
className="text-[var(--color-accent-strong)]"
|
||||
>
|
||||
✕
|
||||
</button>
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
</section>
|
||||
)}
|
||||
|
||||
<section>
|
||||
<Label>{t('observation.findings_free_label')}</Label>
|
||||
<FreeTextFindingInput
|
||||
|
||||
@@ -1,8 +1,7 @@
|
||||
import type { Observation } from '@/domain/schema/observation'
|
||||
import type { SpeciesFindings } from '@/domain/schema/findings'
|
||||
import type { Bone } from '@/anatomy/types'
|
||||
import type { Observation } from '@faunosteo/domain'
|
||||
import ObservationCard from './ObservationCard'
|
||||
import Button from '@/components/ui/Button'
|
||||
import type { SheetIndex } from '@/services/sheetIndex'
|
||||
import { useT } from '@/i18n/useT'
|
||||
|
||||
export interface ObservationListProps {
|
||||
@@ -14,8 +13,7 @@ export interface ObservationListProps {
|
||||
onMoveUp: (i: number) => void
|
||||
onMoveDown: (i: number) => void
|
||||
// Editor body props forwarded to each card
|
||||
bones: Map<string, Bone>
|
||||
findings: SpeciesFindings | null
|
||||
sheet: SheetIndex
|
||||
onChange: (i: number, next: Observation) => void
|
||||
onOpenVertebraPicker: (i: number, zoneIndex: number) => void
|
||||
onRemoveZone: (i: number, zoneIndex: number) => void
|
||||
@@ -29,8 +27,7 @@ export default function ObservationList({
|
||||
onDelete,
|
||||
onMoveUp,
|
||||
onMoveDown,
|
||||
bones,
|
||||
findings,
|
||||
sheet,
|
||||
onChange,
|
||||
onOpenVertebraPicker,
|
||||
onRemoveZone,
|
||||
@@ -64,8 +61,7 @@ export default function ObservationList({
|
||||
onMoveDown={() => onMoveDown(i)}
|
||||
canMoveUp={i > 0}
|
||||
canMoveDown={i < observations.length - 1}
|
||||
bones={bones}
|
||||
findings={findings}
|
||||
sheet={sheet}
|
||||
onChange={(next) => onChange(i, next)}
|
||||
onOpenVertebraPicker={(zoneIndex) =>
|
||||
onOpenVertebraPicker(i, zoneIndex)
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
import type { Severity } from '@/domain/schema/observation'
|
||||
import type { Severity } from '@faunosteo/domain'
|
||||
import { useT } from '@/i18n/useT'
|
||||
|
||||
export interface SeveritySelectorProps {
|
||||
@@ -6,17 +6,25 @@ export interface SeveritySelectorProps {
|
||||
onChange: (s: Severity | undefined) => void
|
||||
}
|
||||
|
||||
const SEVERITIES: Severity[] = ['légère', 'modérée', 'sévère']
|
||||
export const SEVERITIES: Severity[] = ['mild', 'moderate', 'severe']
|
||||
const COLORS: Record<Severity, string> = {
|
||||
'légère': 'border-[var(--severity-mild)] text-[var(--severity-mild)]',
|
||||
'modérée': 'border-[var(--severity-moderate)] text-[var(--severity-moderate)]',
|
||||
'sévère': 'border-[var(--severity-severe)] text-[var(--severity-severe)]',
|
||||
mild: 'border-[var(--severity-mild)] text-[var(--severity-mild)]',
|
||||
moderate: 'border-[var(--severity-moderate)] text-[var(--severity-moderate)]',
|
||||
severe: 'border-[var(--severity-severe)] text-[var(--severity-severe)]',
|
||||
}
|
||||
|
||||
export default function SeveritySelector({ value, onChange }: SeveritySelectorProps) {
|
||||
/** Severity codes are persisted; labels come from the dictionary (D8). */
|
||||
export default function SeveritySelector({
|
||||
value,
|
||||
onChange,
|
||||
}: SeveritySelectorProps) {
|
||||
const t = useT()
|
||||
return (
|
||||
<div role="radiogroup" aria-label={t('severity.aria')} className="flex gap-2">
|
||||
<div
|
||||
role="radiogroup"
|
||||
aria-label={t('severity.aria')}
|
||||
className="flex gap-2"
|
||||
>
|
||||
{SEVERITIES.map((s) => (
|
||||
<button
|
||||
key={s}
|
||||
|
||||
@@ -1,86 +1,93 @@
|
||||
import { useState } from 'react'
|
||||
import type { Vertebra, VertebralRegion } from '@faunosteo/domain'
|
||||
import Dialog from '@/components/ui/Dialog'
|
||||
import Button from '@/components/ui/Button'
|
||||
import Chip from '@/components/ui/Chip'
|
||||
import type { Vertebra, VertebralRegion } from '@/domain/schema/observation'
|
||||
import type { VertebralFormula } from '@/domain/species/types'
|
||||
import { pickLabel } from '@/services/sheetIndex'
|
||||
import { useT } from '@/i18n/useT'
|
||||
|
||||
const REGIONS: VertebralRegion[] = ['C', 'T', 'L', 'S', 'Cd']
|
||||
const REGION_KEY: Record<VertebralRegion, string> = {
|
||||
C: 'vertebra.region.C',
|
||||
T: 'vertebra.region.T',
|
||||
L: 'vertebra.region.L',
|
||||
S: 'vertebra.region.S',
|
||||
Cd: 'vertebra.region.Cd',
|
||||
}
|
||||
import { useLocaleStore } from '@/state/localeStore'
|
||||
|
||||
export interface VertebraPickerProps {
|
||||
open: boolean
|
||||
onClose: () => void
|
||||
onConfirm: (vertebrae: Vertebra[]) => void
|
||||
initial: Vertebra[]
|
||||
formula: VertebralFormula
|
||||
/** Ordered regions of the sheet (`vertebral_config.regions`). */
|
||||
regions: readonly VertebralRegion[]
|
||||
title: string
|
||||
/** Tab to open on. Takes priority so a click always lands on its own zone. */
|
||||
initialRegion?: VertebralRegion
|
||||
initialRegion?: string
|
||||
}
|
||||
|
||||
const sameVertebra = (a: Vertebra, r: string, i: number) =>
|
||||
a.region === r && a.index === i
|
||||
|
||||
/**
|
||||
* Picks vertebrae across every region of the sheet. A region shows its
|
||||
* usual count; when the sheet documents a wider range (D6), one control
|
||||
* extends the grid to the documented maximum. Nothing horse-specific here.
|
||||
*/
|
||||
export default function VertebraPicker({
|
||||
open,
|
||||
onClose,
|
||||
onConfirm,
|
||||
initial,
|
||||
formula,
|
||||
regions,
|
||||
title,
|
||||
initialRegion,
|
||||
}: VertebraPickerProps) {
|
||||
const t = useT()
|
||||
const locale = useLocaleStore((s) => s.locale)
|
||||
const [selected, setSelected] = useState<Vertebra[]>(initial)
|
||||
const [activeRegion, setActiveRegion] = useState<VertebralRegion>(
|
||||
() => initialRegion ?? initial[0]?.region ?? 'C',
|
||||
const [activeCode, setActiveCode] = useState<string>(
|
||||
() => initialRegion ?? initial[0]?.region ?? regions[0]?.code ?? '',
|
||||
)
|
||||
const [extended, setExtended] = useState<Set<string>>(() => new Set())
|
||||
|
||||
const has = (r: VertebralRegion, i: number) =>
|
||||
selected.some((v) => v.region === r && v.index === i)
|
||||
const active = regions.find((r) => r.code === activeCode) ?? regions[0]
|
||||
if (!active) return null
|
||||
const maxCount = active.count_range?.max ?? active.count
|
||||
const highestPicked = Math.max(
|
||||
0,
|
||||
...selected.filter((v) => v.region === active.code).map((v) => v.index),
|
||||
)
|
||||
const canExtend = maxCount > active.count
|
||||
const showExtended = extended.has(active.code) || highestPicked > active.count
|
||||
const count = showExtended ? maxCount : active.count
|
||||
|
||||
const toggle = (r: VertebralRegion, i: number) => {
|
||||
const has = (r: string, i: number) =>
|
||||
selected.some((v) => sameVertebra(v, r, i))
|
||||
const toggle = (r: string, i: number) =>
|
||||
setSelected((cur) =>
|
||||
has(r, i)
|
||||
? cur.filter((v) => !(v.region === r && v.index === i))
|
||||
? cur.filter((v) => !sameVertebra(v, r, i))
|
||||
: [...cur, { region: r, index: i }],
|
||||
)
|
||||
}
|
||||
|
||||
const all = (r: VertebralRegion, count: number) => {
|
||||
setSelected((cur) => {
|
||||
const rest = cur.filter((v) => v.region !== r)
|
||||
return [...rest, ...Array.from({ length: count }, (_, k) => ({ region: r, index: k + 1 }))]
|
||||
})
|
||||
}
|
||||
|
||||
const none = (r: VertebralRegion) =>
|
||||
const all = (r: string, n: number) =>
|
||||
setSelected((cur) => [
|
||||
...cur.filter((v) => v.region !== r),
|
||||
...Array.from({ length: n }, (_, k) => ({ region: r, index: k + 1 })),
|
||||
])
|
||||
const none = (r: string) =>
|
||||
setSelected((cur) => cur.filter((v) => v.region !== r))
|
||||
|
||||
const count = formula[activeRegion]
|
||||
|
||||
return (
|
||||
<Dialog open={open} onClose={onClose} title={title} size="lg">
|
||||
<div role="tablist" className="flex flex-wrap gap-2 mb-4">
|
||||
{REGIONS.map((r) => (
|
||||
{regions.map((r) => (
|
||||
<button
|
||||
key={r}
|
||||
key={r.code}
|
||||
role="tab"
|
||||
aria-selected={activeRegion === r}
|
||||
onClick={() => setActiveRegion(r)}
|
||||
aria-selected={active.code === r.code}
|
||||
onClick={() => setActiveCode(r.code)}
|
||||
className={[
|
||||
'rounded-full px-4 py-2.5 sm:py-1.5 text-sm font-medium border min-h-[2.75rem]',
|
||||
activeRegion === r
|
||||
active.code === r.code
|
||||
? 'bg-[var(--color-accent)] text-white border-[var(--color-accent)]'
|
||||
: 'bg-white text-[var(--color-ink)] border-[var(--color-border)]',
|
||||
].join(' ')}
|
||||
>
|
||||
{t(REGION_KEY[r])}
|
||||
{pickLabel(r.name, locale)}
|
||||
</button>
|
||||
))}
|
||||
</div>
|
||||
@@ -89,26 +96,52 @@ export default function VertebraPicker({
|
||||
{Array.from({ length: count }, (_, k) => k + 1).map((i) => (
|
||||
<Chip
|
||||
key={i}
|
||||
active={has(activeRegion, i)}
|
||||
onClick={() => toggle(activeRegion, i)}
|
||||
active={has(active.code, i)}
|
||||
onClick={() => toggle(active.code, i)}
|
||||
>
|
||||
{activeRegion}{i}
|
||||
{active.code}
|
||||
{i}
|
||||
</Chip>
|
||||
))}
|
||||
</div>
|
||||
|
||||
<div className="flex flex-wrap items-center gap-2 mb-6">
|
||||
<Button variant="ghost" size="sm" onClick={() => all(activeRegion, count)}>
|
||||
<Button
|
||||
variant="ghost"
|
||||
size="sm"
|
||||
onClick={() => all(active.code, active.count)}
|
||||
>
|
||||
{t('vertebra.check_all')}
|
||||
</Button>
|
||||
<Button variant="ghost" size="sm" onClick={() => none(activeRegion)}>
|
||||
<Button variant="ghost" size="sm" onClick={() => none(active.code)}>
|
||||
{t('vertebra.uncheck_all')}
|
||||
</Button>
|
||||
{canExtend && !showExtended && (
|
||||
<Button
|
||||
variant="ghost"
|
||||
size="sm"
|
||||
onClick={() => setExtended((cur) => new Set(cur).add(active.code))}
|
||||
>
|
||||
{t('vertebra.extend_to').replace('{max}', String(maxCount))}
|
||||
</Button>
|
||||
)}
|
||||
{canExtend && showExtended && (
|
||||
<span className="text-xs text-[var(--color-ink-muted)]">
|
||||
{t('vertebra.range_note')
|
||||
.replace('{usual}', String(active.count))
|
||||
.replace('{min}', String(active.count_range?.min ?? active.count))
|
||||
.replace('{max}', String(maxCount))}
|
||||
</span>
|
||||
)}
|
||||
</div>
|
||||
|
||||
<div className="flex justify-end gap-2">
|
||||
<Button variant="ghost" onClick={onClose}>{t('common.cancel')}</Button>
|
||||
<Button onClick={() => onConfirm(selected)}>{t('common.confirm')}</Button>
|
||||
<Button variant="ghost" onClick={onClose}>
|
||||
{t('common.cancel')}
|
||||
</Button>
|
||||
<Button onClick={() => onConfirm(selected)}>
|
||||
{t('common.confirm')}
|
||||
</Button>
|
||||
</div>
|
||||
</Dialog>
|
||||
)
|
||||
|
||||
@@ -1,23 +1,36 @@
|
||||
import type { Animal, Owner } from '@/domain/schema/animal'
|
||||
import type { Animal, LocalizedText, Owner } from '@faunosteo/domain'
|
||||
import Label from '@/components/ui/Label'
|
||||
import Input from '@/components/ui/Input'
|
||||
import Select from '@/components/ui/Select'
|
||||
import { getAllSpecies, speciesLabel } from '@/domain/species/registry'
|
||||
import { pickLabel } from '@/services/sheetIndex'
|
||||
import { useT } from '@/i18n/useT'
|
||||
import { useLocaleStore } from '@/state/localeStore'
|
||||
|
||||
export interface SpeciesOption {
|
||||
id: string
|
||||
name: LocalizedText
|
||||
}
|
||||
|
||||
export interface AnimalFormProps {
|
||||
animal: Animal
|
||||
owner: Owner
|
||||
/** Species that have a sheet in this build (one today). */
|
||||
species: readonly SpeciesOption[]
|
||||
onChangeAnimal: (next: Animal) => void
|
||||
onChangeOwner: (next: Owner) => void
|
||||
}
|
||||
|
||||
export default function AnimalForm({ animal, owner, onChangeAnimal, onChangeOwner }: AnimalFormProps) {
|
||||
export default function AnimalForm({
|
||||
animal,
|
||||
owner,
|
||||
species,
|
||||
onChangeAnimal,
|
||||
onChangeOwner,
|
||||
}: AnimalFormProps) {
|
||||
const t = useT()
|
||||
const locale = useLocaleStore((s) => s.locale)
|
||||
const species = getAllSpecies()
|
||||
const setA = (patch: Partial<Animal>) => onChangeAnimal({ ...animal, ...patch })
|
||||
const setA = (patch: Partial<Animal>) =>
|
||||
onChangeAnimal({ ...animal, ...patch })
|
||||
return (
|
||||
<fieldset className="space-y-3">
|
||||
<legend className="font-serif text-xl mb-2 text-[var(--color-ink)]">
|
||||
@@ -31,25 +44,45 @@ export default function AnimalForm({ animal, owner, onChangeAnimal, onChangeOwne
|
||||
onChange={(e) => setA({ speciesId: e.target.value })}
|
||||
>
|
||||
{species.map((s) => (
|
||||
<option key={s.id} value={s.id}>{speciesLabel(s, locale)}</option>
|
||||
<option key={s.id} value={s.id}>
|
||||
{pickLabel(s.name, locale)}
|
||||
</option>
|
||||
))}
|
||||
</Select>
|
||||
</div>
|
||||
<div>
|
||||
<Label htmlFor="an-name">{t('form.animal.name')}</Label>
|
||||
<Input id="an-name" required value={animal.name} onChange={(e) => setA({ name: e.target.value })} />
|
||||
<Input
|
||||
id="an-name"
|
||||
required
|
||||
value={animal.name}
|
||||
onChange={(e) => setA({ name: e.target.value })}
|
||||
/>
|
||||
</div>
|
||||
<div>
|
||||
<Label htmlFor="an-breed">{t('form.animal.breed')}</Label>
|
||||
<Input id="an-breed" value={animal.breed ?? ''} onChange={(e) => setA({ breed: e.target.value || undefined })} />
|
||||
<Input
|
||||
id="an-breed"
|
||||
value={animal.breed ?? ''}
|
||||
onChange={(e) => setA({ breed: e.target.value || undefined })}
|
||||
/>
|
||||
</div>
|
||||
<div>
|
||||
<Label htmlFor="an-age">{t('form.animal.age')}</Label>
|
||||
<Input id="an-age" value={animal.age ?? ''} onChange={(e) => setA({ age: e.target.value || undefined })} />
|
||||
<Input
|
||||
id="an-age"
|
||||
value={animal.age ?? ''}
|
||||
onChange={(e) => setA({ age: e.target.value || undefined })}
|
||||
/>
|
||||
</div>
|
||||
<div>
|
||||
<Label htmlFor="own-name">{t('form.owner.name')}</Label>
|
||||
<Input id="own-name" required value={owner.name} onChange={(e) => onChangeOwner({ name: e.target.value })} />
|
||||
<Input
|
||||
id="own-name"
|
||||
required
|
||||
value={owner.name}
|
||||
onChange={(e) => onChangeOwner({ name: e.target.value })}
|
||||
/>
|
||||
</div>
|
||||
</fieldset>
|
||||
)
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
import type { Report } from '@/domain/schema/report'
|
||||
import type { Report } from '@faunosteo/domain'
|
||||
import Label from '@/components/ui/Label'
|
||||
import Textarea from '@/components/ui/Textarea'
|
||||
import NextAppointmentPicker from './NextAppointmentPicker'
|
||||
@@ -29,13 +29,26 @@ export default function ConclusionPanel({
|
||||
</h2>
|
||||
<div>
|
||||
<Label htmlFor="conclusion">{t('conclusion.conclusion')}</Label>
|
||||
<Textarea id="conclusion" value={conclusion} onChange={(e) => onChangeConclusion(e.target.value)} />
|
||||
<Textarea
|
||||
id="conclusion"
|
||||
value={conclusion}
|
||||
onChange={(e) => onChangeConclusion(e.target.value)}
|
||||
/>
|
||||
</div>
|
||||
<div>
|
||||
<Label htmlFor="recommendations">{t('conclusion.recommendations')}</Label>
|
||||
<Textarea id="recommendations" value={recommendations} onChange={(e) => onChangeRecommendations(e.target.value)} />
|
||||
<Label htmlFor="recommendations">
|
||||
{t('conclusion.recommendations')}
|
||||
</Label>
|
||||
<Textarea
|
||||
id="recommendations"
|
||||
value={recommendations}
|
||||
onChange={(e) => onChangeRecommendations(e.target.value)}
|
||||
/>
|
||||
</div>
|
||||
<NextAppointmentPicker value={nextAppointment} onChange={onChangeNextAppointment} />
|
||||
<NextAppointmentPicker
|
||||
value={nextAppointment}
|
||||
onChange={onChangeNextAppointment}
|
||||
/>
|
||||
</section>
|
||||
)
|
||||
}
|
||||
@@ -1,4 +1,4 @@
|
||||
import type { Report } from '@/domain/schema/report'
|
||||
import type { Report } from '@faunosteo/domain'
|
||||
import Input from '@/components/ui/Input'
|
||||
import Label from '@/components/ui/Label'
|
||||
import { useT } from '@/i18n/useT'
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
import type { Practitioner } from '@/domain/schema/practitioner'
|
||||
import type { Practitioner } from '@faunosteo/domain'
|
||||
import Label from '@/components/ui/Label'
|
||||
import Input from '@/components/ui/Input'
|
||||
import { useT } from '@/i18n/useT'
|
||||
@@ -8,7 +8,10 @@ export interface PractitionerFormProps {
|
||||
onChange: (next: Practitioner) => void
|
||||
}
|
||||
|
||||
export default function PractitionerForm({ value, onChange }: PractitionerFormProps) {
|
||||
export default function PractitionerForm({
|
||||
value,
|
||||
onChange,
|
||||
}: PractitionerFormProps) {
|
||||
const t = useT()
|
||||
const set = (patch: Partial<Practitioner>) => onChange({ ...value, ...patch })
|
||||
return (
|
||||
@@ -18,19 +21,36 @@ export default function PractitionerForm({ value, onChange }: PractitionerFormPr
|
||||
</legend>
|
||||
<div>
|
||||
<Label htmlFor="prac-name">{t('form.practitioner.name')}</Label>
|
||||
<Input id="prac-name" required value={value.name} onChange={(e) => set({ name: e.target.value })} />
|
||||
<Input
|
||||
id="prac-name"
|
||||
required
|
||||
value={value.name}
|
||||
onChange={(e) => set({ name: e.target.value })}
|
||||
/>
|
||||
</div>
|
||||
<div>
|
||||
<Label htmlFor="prac-cabinet">{t('form.practitioner.cabinet')}</Label>
|
||||
<Input id="prac-cabinet" value={value.cabinet ?? ''} onChange={(e) => set({ cabinet: e.target.value || undefined })} />
|
||||
<Input
|
||||
id="prac-cabinet"
|
||||
value={value.cabinet ?? ''}
|
||||
onChange={(e) => set({ cabinet: e.target.value || undefined })}
|
||||
/>
|
||||
</div>
|
||||
<div>
|
||||
<Label htmlFor="prac-contact">{t('form.practitioner.contact')}</Label>
|
||||
<Input id="prac-contact" value={value.contact ?? ''} onChange={(e) => set({ contact: e.target.value || undefined })} />
|
||||
<Input
|
||||
id="prac-contact"
|
||||
value={value.contact ?? ''}
|
||||
onChange={(e) => set({ contact: e.target.value || undefined })}
|
||||
/>
|
||||
</div>
|
||||
<div>
|
||||
<Label htmlFor="prac-siret">{t('form.practitioner.siret')}</Label>
|
||||
<Input id="prac-siret" value={value.siret ?? ''} onChange={(e) => set({ siret: e.target.value || undefined })} />
|
||||
<Input
|
||||
id="prac-siret"
|
||||
value={value.siret ?? ''}
|
||||
onChange={(e) => set({ siret: e.target.value || undefined })}
|
||||
/>
|
||||
</div>
|
||||
</fieldset>
|
||||
)
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
import type { Report } from '@/domain/schema/report'
|
||||
import type { Report } from '@faunosteo/domain'
|
||||
import AppHeader from '@/components/brand/AppHeader'
|
||||
import Button from '@/components/ui/Button'
|
||||
import { formatDate } from '@/lib/dates'
|
||||
@@ -10,7 +10,10 @@ export interface ReportHeaderProps {
|
||||
onEditInfos?: () => void
|
||||
}
|
||||
|
||||
export default function ReportHeader({ report, onEditInfos }: ReportHeaderProps) {
|
||||
export default function ReportHeader({
|
||||
report,
|
||||
onEditInfos,
|
||||
}: ReportHeaderProps) {
|
||||
const t = useT()
|
||||
const locale = useLocaleStore((s) => s.locale)
|
||||
return (
|
||||
|
||||
@@ -6,7 +6,11 @@ export interface CardProps {
|
||||
as?: 'div' | 'section' | 'article'
|
||||
}
|
||||
|
||||
export default function Card({ children, className = '', as: Tag = 'div' }: CardProps) {
|
||||
export default function Card({
|
||||
children,
|
||||
className = '',
|
||||
as: Tag = 'div',
|
||||
}: CardProps) {
|
||||
return (
|
||||
<Tag
|
||||
className={[
|
||||
|
||||
@@ -5,7 +5,10 @@ export default function Chip({
|
||||
children,
|
||||
className = '',
|
||||
...rest
|
||||
}: ButtonHTMLAttributes<HTMLButtonElement> & { active?: boolean; children: ReactNode }) {
|
||||
}: ButtonHTMLAttributes<HTMLButtonElement> & {
|
||||
active?: boolean
|
||||
children: ReactNode
|
||||
}) {
|
||||
return (
|
||||
<button
|
||||
type="button"
|
||||
|
||||
@@ -17,7 +17,13 @@ const SIZE: Record<NonNullable<DialogProps['size']>, string> = {
|
||||
xl: 'max-w-4xl',
|
||||
}
|
||||
|
||||
export default function Dialog({ open, onClose, title, children, size = 'md' }: DialogProps) {
|
||||
export default function Dialog({
|
||||
open,
|
||||
onClose,
|
||||
title,
|
||||
children,
|
||||
size = 'md',
|
||||
}: DialogProps) {
|
||||
const t = useT()
|
||||
useEffect(() => {
|
||||
if (!open) return
|
||||
@@ -50,7 +56,9 @@ export default function Dialog({ open, onClose, title, children, size = 'md' }:
|
||||
className={`relative w-full ${SIZE[size]} max-h-[85vh] overflow-y-auto rounded-2xl bg-[var(--color-surface)] shadow-xl`}
|
||||
>
|
||||
<header className="flex items-center justify-between px-4 sm:px-6 py-3 sm:py-4 border-b border-[var(--color-border)]">
|
||||
<h2 className="text-lg font-semibold text-[var(--color-ink)]">{title}</h2>
|
||||
<h2 className="text-lg font-semibold text-[var(--color-ink)]">
|
||||
{title}
|
||||
</h2>
|
||||
<button
|
||||
type="button"
|
||||
aria-label={t('common.close')}
|
||||
|
||||
@@ -1,16 +1,17 @@
|
||||
import { forwardRef, type InputHTMLAttributes } from 'react'
|
||||
|
||||
const Input = forwardRef<HTMLInputElement, InputHTMLAttributes<HTMLInputElement>>(
|
||||
({ className = '', ...rest }, ref) => (
|
||||
<input
|
||||
ref={ref}
|
||||
className={[
|
||||
'h-10 w-full rounded-lg border border-[var(--color-border)] bg-white px-3 text-base text-[var(--color-ink)] placeholder:text-[var(--color-ink-muted)] focus-visible:border-[var(--color-accent)] focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[var(--color-accent)]/30',
|
||||
className,
|
||||
].join(' ')}
|
||||
{...rest}
|
||||
/>
|
||||
),
|
||||
)
|
||||
const Input = forwardRef<
|
||||
HTMLInputElement,
|
||||
InputHTMLAttributes<HTMLInputElement>
|
||||
>(({ className = '', ...rest }, ref) => (
|
||||
<input
|
||||
ref={ref}
|
||||
className={[
|
||||
'h-10 w-full rounded-lg border border-[var(--color-border)] bg-white px-3 text-base text-[var(--color-ink)] placeholder:text-[var(--color-ink-muted)] focus-visible:border-[var(--color-accent)] focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[var(--color-accent)]/30',
|
||||
className,
|
||||
].join(' ')}
|
||||
{...rest}
|
||||
/>
|
||||
))
|
||||
Input.displayName = 'Input'
|
||||
export default Input
|
||||
@@ -1,18 +1,19 @@
|
||||
import { forwardRef, type SelectHTMLAttributes } from 'react'
|
||||
|
||||
const Select = forwardRef<HTMLSelectElement, SelectHTMLAttributes<HTMLSelectElement>>(
|
||||
({ className = '', children, ...rest }, ref) => (
|
||||
<select
|
||||
ref={ref}
|
||||
className={[
|
||||
'h-10 w-full rounded-lg border border-[var(--color-border)] bg-white px-3 text-base text-[var(--color-ink)] focus-visible:border-[var(--color-accent)] focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[var(--color-accent)]/30',
|
||||
className,
|
||||
].join(' ')}
|
||||
{...rest}
|
||||
>
|
||||
{children}
|
||||
</select>
|
||||
),
|
||||
)
|
||||
const Select = forwardRef<
|
||||
HTMLSelectElement,
|
||||
SelectHTMLAttributes<HTMLSelectElement>
|
||||
>(({ className = '', children, ...rest }, ref) => (
|
||||
<select
|
||||
ref={ref}
|
||||
className={[
|
||||
'h-10 w-full rounded-lg border border-[var(--color-border)] bg-white px-3 text-base text-[var(--color-ink)] focus-visible:border-[var(--color-accent)] focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[var(--color-accent)]/30',
|
||||
className,
|
||||
].join(' ')}
|
||||
{...rest}
|
||||
>
|
||||
{children}
|
||||
</select>
|
||||
))
|
||||
Select.displayName = 'Select'
|
||||
export default Select
|
||||
@@ -1,16 +1,17 @@
|
||||
import { forwardRef, type TextareaHTMLAttributes } from 'react'
|
||||
|
||||
const Textarea = forwardRef<HTMLTextAreaElement, TextareaHTMLAttributes<HTMLTextAreaElement>>(
|
||||
({ className = '', ...rest }, ref) => (
|
||||
<textarea
|
||||
ref={ref}
|
||||
className={[
|
||||
'w-full min-h-[96px] rounded-lg border border-[var(--color-border)] bg-white p-3 text-base text-[var(--color-ink)] placeholder:text-[var(--color-ink-muted)] focus-visible:border-[var(--color-accent)] focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[var(--color-accent)]/30',
|
||||
className,
|
||||
].join(' ')}
|
||||
{...rest}
|
||||
/>
|
||||
),
|
||||
)
|
||||
const Textarea = forwardRef<
|
||||
HTMLTextAreaElement,
|
||||
TextareaHTMLAttributes<HTMLTextAreaElement>
|
||||
>(({ className = '', ...rest }, ref) => (
|
||||
<textarea
|
||||
ref={ref}
|
||||
className={[
|
||||
'w-full min-h-[96px] rounded-lg border border-[var(--color-border)] bg-white p-3 text-base text-[var(--color-ink)] placeholder:text-[var(--color-ink-muted)] focus-visible:border-[var(--color-accent)] focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-[var(--color-accent)]/30',
|
||||
className,
|
||||
].join(' ')}
|
||||
{...rest}
|
||||
/>
|
||||
))
|
||||
Textarea.displayName = 'Textarea'
|
||||
export default Textarea
|
||||
@@ -1,17 +0,0 @@
|
||||
import { z } from 'zod'
|
||||
|
||||
export const AnimalSchema = z.object({
|
||||
/** Must match a registered species id (e.g. 'equine') */
|
||||
speciesId: z.string().min(1),
|
||||
name: z.string().min(1),
|
||||
breed: z.string().optional(),
|
||||
age: z.string().optional(),
|
||||
})
|
||||
|
||||
export type Animal = z.infer<typeof AnimalSchema>
|
||||
|
||||
export const OwnerSchema = z.object({
|
||||
name: z.string().min(1),
|
||||
})
|
||||
|
||||
export type Owner = z.infer<typeof OwnerSchema>
|
||||
@@ -1,67 +0,0 @@
|
||||
import { z } from 'zod'
|
||||
|
||||
/**
|
||||
* Schema for the species findings tree.
|
||||
*
|
||||
* Source of truth for what a practitioner can attach to an observation:
|
||||
* a hierarchical tree of dysfunctions/observations per anatomical zone,
|
||||
* authored by the domain expert in JSON and parsed at boot.
|
||||
*
|
||||
* Field names match the JSON authoring contract (snake_case).
|
||||
* Recursive children are typed via z.lazy + an explicit ZodType annotation
|
||||
* so TS can resolve the self-reference.
|
||||
*/
|
||||
|
||||
export const SourceRefSchema = z.object({
|
||||
type: z.enum(['manual', 'journal', 'database', 'web']),
|
||||
citation: z.string().min(1),
|
||||
url: z.string().url().optional(),
|
||||
})
|
||||
|
||||
export type SourceRef = z.infer<typeof SourceRefSchema>
|
||||
|
||||
export interface FindingNode {
|
||||
id: string
|
||||
name_fr: string
|
||||
name_en: string
|
||||
description_fr?: string
|
||||
description_en?: string
|
||||
requires_vet_referral?: boolean
|
||||
sources?: SourceRef[]
|
||||
children?: FindingNode[]
|
||||
}
|
||||
|
||||
export const FindingNodeSchema: z.ZodType<FindingNode> = z.lazy(() =>
|
||||
z.object({
|
||||
id: z.string().min(1),
|
||||
name_fr: z.string().min(1),
|
||||
name_en: z.string().min(1),
|
||||
description_fr: z.string().optional(),
|
||||
description_en: z.string().optional(),
|
||||
requires_vet_referral: z.boolean().optional(),
|
||||
sources: z.array(SourceRefSchema).optional(),
|
||||
children: z.array(FindingNodeSchema).optional(),
|
||||
}),
|
||||
)
|
||||
|
||||
export const ZoneFindingsSchema = z.object({
|
||||
id: z.string().min(1),
|
||||
name_fr: z.string().min(1),
|
||||
name_en: z.string().min(1),
|
||||
categories: z.array(FindingNodeSchema),
|
||||
})
|
||||
|
||||
export type ZoneFindings = z.infer<typeof ZoneFindingsSchema>
|
||||
|
||||
export const SpeciesFindingsSchema = z.object({
|
||||
schema_version: z.string().min(1),
|
||||
scope_disclaimer: z.string().min(1),
|
||||
species: z.object({
|
||||
id: z.string().min(1),
|
||||
name_fr: z.string().min(1),
|
||||
name_en: z.string().min(1),
|
||||
}),
|
||||
zones: z.record(z.string(), ZoneFindingsSchema),
|
||||
})
|
||||
|
||||
export type SpeciesFindings = z.infer<typeof SpeciesFindingsSchema>
|
||||
@@ -1,61 +0,0 @@
|
||||
import { z } from 'zod'
|
||||
|
||||
export const SeveritySchema = z.enum(['légère', 'modérée', 'sévère'])
|
||||
|
||||
export type Severity = z.infer<typeof SeveritySchema>
|
||||
|
||||
export const VertebralRegionSchema = z.enum(['C', 'T', 'L', 'S', 'Cd'])
|
||||
|
||||
export type VertebralRegion = z.infer<typeof VertebralRegionSchema>
|
||||
|
||||
export const VertebraSchema = z.object({
|
||||
region: VertebralRegionSchema,
|
||||
index: z.number().int().positive(),
|
||||
})
|
||||
|
||||
export type Vertebra = z.infer<typeof VertebraSchema>
|
||||
|
||||
export const LateralSideSchema = z.enum(['left', 'right'])
|
||||
export type LateralSide = z.infer<typeof LateralSideSchema>
|
||||
|
||||
export const ObservationZoneSchema = z.object({
|
||||
/** Must match data-anno-id attribute on the SVG element */
|
||||
boneId: z.string().min(1),
|
||||
/** Set when zone originates from a detail popup SVG */
|
||||
detailSourceId: z.string().optional(),
|
||||
/** Set when boneId is a spine-zone; replaces the block semantically */
|
||||
vertebrae: z.array(VertebraSchema).optional(),
|
||||
/** Set for bilateral zones to distinguish left from right */
|
||||
side: LateralSideSchema.optional(),
|
||||
})
|
||||
|
||||
export type ObservationZone = z.infer<typeof ObservationZoneSchema>
|
||||
|
||||
/**
|
||||
* A selected leaf from the species findings tree. The path is anchored at the
|
||||
* zone root (categories array), e.g. ['sphenoid-dysfunctions', 'physiological',
|
||||
* 'flexion']. Labels are snapshotted at selection time so previously exported
|
||||
* reports remain readable if the catalog is later edited.
|
||||
*/
|
||||
export const FindingSchema = z.object({
|
||||
zoneId: z.string().min(1),
|
||||
path: z.array(z.string().min(1)).min(1),
|
||||
labelFrSnapshot: z.string().min(1),
|
||||
labelEnSnapshot: z.string().min(1),
|
||||
requiresVetReferral: z.boolean().optional(),
|
||||
side: LateralSideSchema.optional(),
|
||||
})
|
||||
|
||||
export type Finding = z.infer<typeof FindingSchema>
|
||||
|
||||
export const ObservationSchema = z.object({
|
||||
id: z.string().min(1),
|
||||
zones: z.array(ObservationZoneSchema),
|
||||
findings: z.array(FindingSchema),
|
||||
/** Free-text additions when the tree does not cover a finding */
|
||||
freeTextFindings: z.array(z.string()),
|
||||
severity: SeveritySchema.optional(),
|
||||
comment: z.string(),
|
||||
})
|
||||
|
||||
export type Observation = z.infer<typeof ObservationSchema>
|
||||
@@ -1,11 +0,0 @@
|
||||
import { z } from 'zod'
|
||||
|
||||
export const PractitionerSchema = z.object({
|
||||
name: z.string().min(1),
|
||||
cabinet: z.string().optional(),
|
||||
contact: z.string().optional(),
|
||||
/** SIRET — 14-digit French business identifier */
|
||||
siret: z.string().optional(),
|
||||
})
|
||||
|
||||
export type Practitioner = z.infer<typeof PractitionerSchema>
|
||||
@@ -1,33 +0,0 @@
|
||||
import { z } from 'zod'
|
||||
import { PractitionerSchema } from './practitioner'
|
||||
import { AnimalSchema, OwnerSchema } from './animal'
|
||||
import { ObservationSchema } from './observation'
|
||||
|
||||
const NextAppointmentSchema = z.discriminatedUnion('kind', [
|
||||
z.object({ kind: z.literal('date'), date: z.string() }),
|
||||
z.object({ kind: z.literal('period'), text: z.string() }),
|
||||
])
|
||||
|
||||
export type NextAppointment = z.infer<typeof NextAppointmentSchema>
|
||||
|
||||
export const ReportSchema = z.object({
|
||||
/**
|
||||
* Schema version. v2 introduced the hierarchical findings tree
|
||||
* (replacing the flat pathology list). Bump on breaking changes.
|
||||
*/
|
||||
version: z.literal(2),
|
||||
id: z.string().min(1),
|
||||
/** ISO timestamp of report creation */
|
||||
createdAt: z.string(),
|
||||
/** ISO date of clinical encounter */
|
||||
date: z.string(),
|
||||
practitioner: PractitionerSchema,
|
||||
animal: AnimalSchema,
|
||||
owner: OwnerSchema,
|
||||
observations: z.array(ObservationSchema),
|
||||
conclusion: z.string(),
|
||||
recommendations: z.string(),
|
||||
nextAppointment: NextAppointmentSchema.optional(),
|
||||
})
|
||||
|
||||
export type Report = z.infer<typeof ReportSchema>
|
||||
@@ -1,18 +0,0 @@
|
||||
import type { SpeciesManifest } from '@/domain/species/types'
|
||||
import { EQUINE_VERTEBRAL_FORMULA } from './vertebrae'
|
||||
|
||||
const equine: SpeciesManifest = {
|
||||
id: 'equine',
|
||||
labelFr: 'Cheval',
|
||||
labelEn: 'Horse',
|
||||
mainSvg: '/species/equine/Horse.svg',
|
||||
details: {
|
||||
head: '/species/equine/Horse_head.svg',
|
||||
},
|
||||
vertebralFormula: EQUINE_VERTEBRAL_FORMULA,
|
||||
findings: () => import('./pathologies'),
|
||||
}
|
||||
|
||||
// Default export is the convention picked up by the registry's
|
||||
// import.meta.glob() auto-discovery.
|
||||
export default equine
|
||||
File diff suppressed because it is too large.
Load diff
@@ -1,13 +0,0 @@
|
||||
import {
|
||||
SpeciesFindingsSchema,
|
||||
type SpeciesFindings,
|
||||
} from '@/domain/schema/findings'
|
||||
import data from './pathologies.json'
|
||||
|
||||
/**
|
||||
* Equine findings tree. Authored as JSON, parsed via Zod at boot so any
|
||||
* malformed data crashes loudly instead of corrupting an observation later.
|
||||
*/
|
||||
const EQUINE_FINDINGS: SpeciesFindings = SpeciesFindingsSchema.parse(data)
|
||||
|
||||
export default EQUINE_FINDINGS
|
||||
@@ -1,57 +0,0 @@
|
||||
import type { SpeciesManifest } from './types'
|
||||
import type { Locale } from '@/i18n/types'
|
||||
|
||||
/**
|
||||
* Auto-discovers every species manifest in `src/domain/species/*\/index.ts`
|
||||
* via Vite's `import.meta.glob`. Each manifest module must default-export
|
||||
* its `SpeciesManifest`. Drop a new folder with a conforming `index.ts`
|
||||
* (and its `vertebrae.ts` + `pathologies.ts` siblings) and the species
|
||||
* shows up everywhere — the AnimalForm dropdown, the editor canvas,
|
||||
* the PDF export — without any registry edit.
|
||||
*
|
||||
* `eager: true` resolves modules synchronously at build time so the
|
||||
* registry is a plain object literal in the bundled output (no async
|
||||
* loading required to enumerate species).
|
||||
*/
|
||||
const modules = import.meta.glob<{ default: SpeciesManifest }>(
|
||||
'./*/index.ts',
|
||||
{ eager: true },
|
||||
)
|
||||
|
||||
function buildRegistry(): Record<string, SpeciesManifest> {
|
||||
const reg: Record<string, SpeciesManifest> = {}
|
||||
for (const [path, mod] of Object.entries(modules)) {
|
||||
const manifest = mod.default
|
||||
if (!manifest || typeof manifest.id !== 'string' || !manifest.id) {
|
||||
console.warn(`Species manifest at ${path} has no valid default export — skipping.`)
|
||||
continue
|
||||
}
|
||||
if (reg[manifest.id]) {
|
||||
console.warn(
|
||||
`Duplicate species id "${manifest.id}" — keeping the first one (from ${path} ignored).`,
|
||||
)
|
||||
continue
|
||||
}
|
||||
reg[manifest.id] = manifest
|
||||
}
|
||||
return reg
|
||||
}
|
||||
|
||||
const SPECIES_REGISTRY: Record<string, SpeciesManifest> = buildRegistry()
|
||||
|
||||
/** Returns a species manifest by id, or undefined if not registered. */
|
||||
export function getSpecies(id: string): SpeciesManifest | undefined {
|
||||
return SPECIES_REGISTRY[id]
|
||||
}
|
||||
|
||||
/** Returns all registered species manifests, sorted alphabetically by labelFr. */
|
||||
export function getAllSpecies(): SpeciesManifest[] {
|
||||
return Object.values(SPECIES_REGISTRY).sort((a, b) =>
|
||||
a.labelFr.localeCompare(b.labelFr, 'fr'),
|
||||
)
|
||||
}
|
||||
|
||||
/** Display label of a species for the given locale. */
|
||||
export function speciesLabel(s: SpeciesManifest, locale: Locale): string {
|
||||
return locale === 'en' ? s.labelEn : s.labelFr
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
import type { SpeciesFindings } from '@/domain/schema/findings'
|
||||
|
||||
/** Vertebral formula defines segment counts for a species. */
|
||||
export interface VertebralFormula {
|
||||
C: number
|
||||
T: number
|
||||
L: number
|
||||
S: number
|
||||
Cd: number
|
||||
}
|
||||
|
||||
/** Lazy import returning a module with a default export of SpeciesFindings. */
|
||||
export type FindingsLoader = () => Promise<{ default: SpeciesFindings }>
|
||||
|
||||
/** Species manifest — one per registered species. */
|
||||
export interface SpeciesManifest {
|
||||
id: string
|
||||
/** Display name in French */
|
||||
labelFr: string
|
||||
/** Display name in English */
|
||||
labelEn: string
|
||||
/** Absolute public path to the main anatomy SVG */
|
||||
mainSvg: string
|
||||
/**
|
||||
* Map of detail popup id → absolute public path to detail SVG.
|
||||
* Keys match data-anno-opens-detail attribute values in the main SVG.
|
||||
*/
|
||||
details: Record<string, string>
|
||||
vertebralFormula: VertebralFormula
|
||||
/** Lazy-loaded findings tree (zones + categories + leaves) for this species */
|
||||
findings: FindingsLoader
|
||||
}
|
||||
+37
-99
@@ -16,10 +16,12 @@ export const en: Dict = {
|
||||
'common.back_to_home': 'Back to home',
|
||||
|
||||
'home.new_report.title': 'New report',
|
||||
'home.new_report.description': 'Start a new osteopathic report for an animal.',
|
||||
'home.new_report.description':
|
||||
'Start a new osteopathic report for an animal.',
|
||||
'home.new_report.cta': 'Start',
|
||||
'home.import.title': 'Import a PDF',
|
||||
'home.import.description': 'Reopen a previous report generated by this app to follow up.',
|
||||
'home.import.description':
|
||||
'Reopen a previous report generated by this app to follow up.',
|
||||
'home.import.cta': 'Choose a PDF',
|
||||
'home.import.loading': 'Reading…',
|
||||
'home.import.error_generic': 'Failed to read the PDF.',
|
||||
@@ -27,24 +29,18 @@ export const en: Dict = {
|
||||
'home.import.error_no_attachment':
|
||||
'This PDF was not generated by Faunosteo (no data detected).',
|
||||
'home.import.error_incompatible_version':
|
||||
'This PDF uses format v{version}, incompatible with the current version (v2). Re-export the report from a recent version of the app.',
|
||||
'This PDF uses format v{version}, which this version of the application cannot read (accepted formats: v2 and v3).',
|
||||
'home.import.migrated':
|
||||
'Report imported from an older format. Findings not found in the current sheet: {count} (kept with their labels).',
|
||||
'home.no_sheet.title': 'No anatomical sheet',
|
||||
'home.no_sheet.description':
|
||||
'This build of the application carries no anatomical sheet: no report can be created or imported.',
|
||||
|
||||
// footer
|
||||
'footer.all_rights_reserved': 'All rights reserved.',
|
||||
'footer.powered_by': 'Powered by',
|
||||
'footer.editors': 'Editors',
|
||||
'footer.in_partnership': 'In partnership with',
|
||||
|
||||
// editors page
|
||||
'editors.svg.title': 'SVG Editor',
|
||||
'editors.svg.description':
|
||||
'Annotate an anatomical SVG file: add clickable zones, categories, and FR/EN labels.',
|
||||
'editors.svg.cta': 'Open',
|
||||
'editors.pathology.title': 'Pathology Editor',
|
||||
'editors.pathology.description':
|
||||
'Create and edit the pathology catalog (JSON tree) for a species.',
|
||||
'editors.pathology.cta': 'Open',
|
||||
|
||||
'not_found.title': 'Page not found',
|
||||
'not_found.description': 'The requested path does not exist.',
|
||||
|
||||
@@ -58,20 +54,22 @@ export const en: Dict = {
|
||||
'editor.edit_infos': 'Edit info',
|
||||
'editor.edit_dialog_title': 'Edit information',
|
||||
'editor.disclaimer_title': 'Legal scope of animal osteopathy',
|
||||
'editor.detail_title_prefix': 'Detail — ',
|
||||
|
||||
'detail.click_to_add': 'Click the zones to add them to the current observation.',
|
||||
'detail.click_to_add':
|
||||
'Click the zones to add them to the current observation.',
|
||||
|
||||
'observation.section_title': 'Observations',
|
||||
'observation.add': '+ New observation',
|
||||
'observation.empty': 'No observation. Click "+ New observation" then on the zones in the diagram.',
|
||||
'observation.empty':
|
||||
'No observation. Click "+ New observation" then on the zones in the diagram.',
|
||||
'observation.badge_n': 'Observation #',
|
||||
'observation.zone_label_singular': 'zone',
|
||||
'observation.zone_label_plural': 'zones',
|
||||
'observation.finding_label_singular': 'finding',
|
||||
'observation.finding_label_plural': 'findings',
|
||||
'observation.zones_label': 'Selected zones',
|
||||
'observation.zones_empty': 'Click on the zones in the diagram to add them to this observation.',
|
||||
'observation.zones_empty':
|
||||
'Click on the zones in the diagram to add them to this observation.',
|
||||
'observation.findings_catalog_label': 'Findings (catalog)',
|
||||
'observation.findings_pick_zone_first': 'Pick a zone to access the catalog.',
|
||||
'observation.findings_no_catalog':
|
||||
@@ -118,13 +116,26 @@ export const en: Dict = {
|
||||
'conclusion.next_period_placeholder': 'e.g. in 3 weeks',
|
||||
|
||||
'vertebra.title_prefix': 'Specify vertebrae — ',
|
||||
'vertebra.region.C': 'Cervical',
|
||||
'vertebra.region.T': 'Thoracic',
|
||||
'vertebra.region.L': 'Lumbar',
|
||||
'vertebra.region.S': 'Sacral',
|
||||
'vertebra.region.Cd': 'Caudal',
|
||||
'vertebra.check_all': 'Select all',
|
||||
'vertebra.uncheck_all': 'Clear all',
|
||||
'vertebra.extend_to': 'Show up to {max}',
|
||||
'vertebra.range_note':
|
||||
'Usual count: {usual}; documented variation: {min} to {max}.',
|
||||
|
||||
// sheet
|
||||
'sheet.status.draft':
|
||||
'Anatomical sheet: reference draft, not medically validated',
|
||||
'sheet.status.published': 'Official anatomical sheet',
|
||||
'sheet.loading': 'Loading the anatomical sheet…',
|
||||
|
||||
// unresolved (migrated) data
|
||||
'observation.unresolved_short': 'inherited',
|
||||
'observation.zone_unresolved':
|
||||
'Zone inherited from an older report, absent from the current sheet',
|
||||
'observation.findings_unresolved_label':
|
||||
'Inherited findings (outside the current catalog)',
|
||||
'observation.findings_unresolved_help':
|
||||
'Findings imported from an older report whose path no longer exists in the sheet: kept with their original labels.',
|
||||
|
||||
// laterality
|
||||
'lateral.which_side': 'Which side?',
|
||||
@@ -135,9 +146,9 @@ export const en: Dict = {
|
||||
'lateral.right_short': 'R',
|
||||
|
||||
'severity.aria': 'Severity',
|
||||
'severity.légère': 'mild',
|
||||
'severity.modérée': 'moderate',
|
||||
'severity.sévère': 'severe',
|
||||
'severity.mild': 'mild',
|
||||
'severity.moderate': 'moderate',
|
||||
'severity.severe': 'severe',
|
||||
|
||||
'pdf.eyebrow.observation': 'OBSERVATION',
|
||||
'pdf.eyebrow.synthesis': 'SYNTHESIS',
|
||||
@@ -163,77 +174,4 @@ export const en: Dict = {
|
||||
'lang.switch_to_en': 'Switch to English',
|
||||
'lang.fr': 'FR',
|
||||
'lang.en': 'EN',
|
||||
|
||||
// svg editor
|
||||
'svg_editor.title': 'SVG Anatomy Editor',
|
||||
'svg_editor.subtitle': 'Points, zones & clickable categories',
|
||||
'svg_editor.file': 'File',
|
||||
'svg_editor.choose_file': 'Choose an SVG file',
|
||||
'svg_editor.change_file': 'Change SVG file',
|
||||
'svg_editor.export': 'Export SVG',
|
||||
'svg_editor.mode': 'Mode',
|
||||
'svg_editor.mode_select': 'Select / move',
|
||||
'svg_editor.mode_point': 'Add point',
|
||||
'svg_editor.mode_polygon': 'Add polygon',
|
||||
'svg_editor.validate_polygon': 'Validate polygon (Enter)',
|
||||
'svg_editor.cancel_polygon': 'Cancel (Esc)',
|
||||
'svg_editor.category_for_new': 'Category for new elements',
|
||||
'svg_editor.categories': 'Categories',
|
||||
'svg_editor.shared_color': '(shared color)',
|
||||
'svg_editor.category_placeholder': 'Category name',
|
||||
'svg_editor.selected_element': 'Selected element',
|
||||
'svg_editor.opens_detail': 'This zone opens a detail view',
|
||||
'svg_editor.detail_id_label': 'Detail view ID (e.g. head, front-leg)',
|
||||
'svg_editor.detail_id_placeholder': 'head',
|
||||
'svg_editor.name_fr': 'French name',
|
||||
'svg_editor.name_fr_placeholder': 'e.g. Hanche',
|
||||
'svg_editor.name_en': 'English name',
|
||||
'svg_editor.name_en_placeholder': 'e.g. Hip joint',
|
||||
'svg_editor.category': 'Category',
|
||||
'svg_editor.radius': 'Radius (circle)',
|
||||
'svg_editor.fill_opacity': 'Fill opacity',
|
||||
'svg_editor.polygon_editing': 'Polygon editing:',
|
||||
'svg_editor.polygon_drag': 'Drag a yellow handle to move it',
|
||||
'svg_editor.polygon_insert': 'Click a white mid-handle to insert a vertex',
|
||||
'svg_editor.polygon_delete': 'Alt+click or right-click a yellow handle to delete it',
|
||||
'svg_editor.redraw_polygon': 'Redraw this polygon',
|
||||
'svg_editor.delete': 'Delete',
|
||||
'svg_editor.elements': 'Elements',
|
||||
'svg_editor.filter_placeholder': 'Filter...',
|
||||
'svg_editor.welcome_title': 'SVG Anatomy Editor',
|
||||
'svg_editor.welcome_text': 'Upload an SVG file to begin. If your file already has points/zones with ',
|
||||
'svg_editor.welcome_text_suffix': ', they will be detected and configured automatically.',
|
||||
'svg_editor.welcome_drag_hint': 'or drag & drop an SVG file anywhere',
|
||||
'svg_editor.no_categories': 'No categories yet. Use the form below to add one.',
|
||||
'svg_editor.new_point_fr': 'Nouveau point',
|
||||
'svg_editor.new_point_en': 'New point',
|
||||
'svg_editor.new_zone_fr': 'Nouvelle zone',
|
||||
'svg_editor.new_zone_en': 'New zone',
|
||||
'svg_editor.alert_drop_svg': 'Drop an SVG file.',
|
||||
'svg_editor.alert_invalid_svg': 'Invalid file: no SVG element found.',
|
||||
'svg_editor.alert_min_3': 'Need at least 3 points.',
|
||||
'svg_editor.alert_min_3_vertices': 'A polygon must have at least 3 vertices.',
|
||||
'svg_editor.alert_upload_first': 'Upload an SVG first.',
|
||||
'svg_editor.alert_no_svg_loaded': 'No SVG loaded. Upload a file first.',
|
||||
'svg_editor.alert_cat_name_required': 'Give the category a name.',
|
||||
'svg_editor.alert_cat_invalid_name': 'Invalid name.',
|
||||
'svg_editor.alert_cat_exists': 'This category already exists.',
|
||||
'svg_editor.confirm_delete_element': 'Delete this element?',
|
||||
'svg_editor.confirm_delete_cat': 'Delete category "{name}"?',
|
||||
'svg_editor.confirm_delete_cat_count': '\n\nIt contains {count} element(s) that will also be deleted.',
|
||||
'svg_editor.confirm_redraw': 'Erase this polygon and redraw it?',
|
||||
'svg_editor.handle_drag': 'Drag to move | Alt+click or right-click to delete',
|
||||
'svg_editor.handle_insert': 'Click to insert a vertex here',
|
||||
'svg_editor.polygon_vertices': 'polygon ({count} vertices)',
|
||||
'svg_editor.drop_svg_here': 'Drop SVG here',
|
||||
'svg_editor.lateral': 'Laterality',
|
||||
'svg_editor.lateral_unpaired': 'Unilateral (no side)',
|
||||
'svg_editor.lateral_bilateral': 'Bilateral (left / right)',
|
||||
'svg_editor.source_project': 'Project SVGs',
|
||||
'svg_editor.source_upload': 'Upload a file',
|
||||
'svg_editor.species': 'Species',
|
||||
'svg_editor.view': 'View',
|
||||
'svg_editor.view_main': 'Full body',
|
||||
'svg_editor.view_detail': 'Detail: {name}',
|
||||
'svg_editor.load': 'Load',
|
||||
}
|
||||
+41
-103
@@ -18,37 +18,31 @@ export const fr: Dict = {
|
||||
|
||||
// home
|
||||
'home.new_report.title': 'Nouveau bilan',
|
||||
'home.new_report.description': "Démarrer un nouveau bilan d'ostéopathie sur un animal.",
|
||||
'home.new_report.description':
|
||||
"Démarrer un nouveau bilan d'ostéopathie sur un animal.",
|
||||
'home.new_report.cta': 'Commencer',
|
||||
'home.import.title': 'Importer un PDF',
|
||||
'home.import.description':
|
||||
"Reprendre un bilan précédent généré par cette application pour effectuer un suivi.",
|
||||
'Reprendre un bilan précédent généré par cette application pour effectuer un suivi.',
|
||||
'home.import.cta': 'Choisir un PDF',
|
||||
'home.import.loading': 'Lecture…',
|
||||
'home.import.error_generic': 'Erreur de lecture du PDF.',
|
||||
'home.import.error_invalid_pdf':
|
||||
"Ce fichier n'est pas un PDF lisible.",
|
||||
'home.import.error_invalid_pdf': "Ce fichier n'est pas un PDF lisible.",
|
||||
'home.import.error_no_attachment':
|
||||
"Ce PDF n'a pas été généré par Faunosteo (pas de données détectées).",
|
||||
'home.import.error_incompatible_version':
|
||||
"Ce PDF est au format v{version}, incompatible avec la version actuelle (v2). Réexportez le bilan depuis une version récente de l'application.",
|
||||
"Ce PDF est au format v{version}, que cette version de l'application ne sait pas lire (formats acceptés : v2 et v3).",
|
||||
'home.import.migrated':
|
||||
'Bilan importé depuis un ancien format. Constats non retrouvés dans la fiche actuelle : {count} (conservés avec leurs libellés).',
|
||||
'home.no_sheet.title': 'Aucune fiche anatomique',
|
||||
'home.no_sheet.description':
|
||||
"Cette version de l'application n'embarque aucune fiche anatomique : aucun bilan ne peut être créé ni importé.",
|
||||
|
||||
// footer
|
||||
'footer.all_rights_reserved': 'Tous droits réservés.',
|
||||
'footer.powered_by': 'Propulsé par',
|
||||
'footer.editors': 'Éditeurs',
|
||||
'footer.in_partnership': 'En partenariat avec',
|
||||
|
||||
// editors page
|
||||
'editors.svg.title': 'Éditeur SVG',
|
||||
'editors.svg.description':
|
||||
'Annoter un fichier SVG anatomique : ajouter des zones cliquables, catégories et labels FR/EN.',
|
||||
'editors.svg.cta': 'Ouvrir',
|
||||
'editors.pathology.title': 'Éditeur de pathologies',
|
||||
'editors.pathology.description':
|
||||
'Créer et modifier le référentiel de pathologies (arbre JSON) pour une espèce.',
|
||||
'editors.pathology.cta': 'Ouvrir',
|
||||
|
||||
// not found
|
||||
'not_found.title': 'Page introuvable',
|
||||
'not_found.description': "Le chemin demandé n'existe pas.",
|
||||
@@ -61,14 +55,15 @@ export const fr: Dict = {
|
||||
// editor
|
||||
'editor.export': 'Exporter en PDF',
|
||||
'editor.exporting': 'Génération…',
|
||||
'editor.export_failed': 'Échec de la génération du PDF. Réessayez ou contactez le support.',
|
||||
'editor.export_failed':
|
||||
'Échec de la génération du PDF. Réessayez ou contactez le support.',
|
||||
'editor.edit_infos': 'Modifier les infos',
|
||||
'editor.edit_dialog_title': 'Modifier les informations',
|
||||
'editor.disclaimer_title': "Périmètre légal de l'ostéopathie animale",
|
||||
'editor.detail_title_prefix': 'Détail — ',
|
||||
|
||||
// detail modal
|
||||
'detail.click_to_add': "Cliquez sur les zones pour les ajouter à l'observation en cours.",
|
||||
'detail.click_to_add':
|
||||
"Cliquez sur les zones pour les ajouter à l'observation en cours.",
|
||||
|
||||
// observation list / card
|
||||
'observation.section_title': 'Observations',
|
||||
@@ -81,9 +76,11 @@ export const fr: Dict = {
|
||||
'observation.finding_label_singular': 'constat',
|
||||
'observation.finding_label_plural': 'constats',
|
||||
'observation.zones_label': 'Zones sélectionnées',
|
||||
'observation.zones_empty': 'Cliquez sur les zones du schéma pour les ajouter à cette observation.',
|
||||
'observation.zones_empty':
|
||||
'Cliquez sur les zones du schéma pour les ajouter à cette observation.',
|
||||
'observation.findings_catalog_label': 'Constats (référentiel)',
|
||||
'observation.findings_pick_zone_first': 'Sélectionnez une zone pour accéder au référentiel.',
|
||||
'observation.findings_pick_zone_first':
|
||||
'Sélectionnez une zone pour accéder au référentiel.',
|
||||
'observation.findings_no_catalog':
|
||||
'Aucun référentiel disponible pour ces zones. Utilisez le texte libre ci-dessous.',
|
||||
'observation.findings_free_label': 'Constats (texte libre)',
|
||||
@@ -93,7 +90,8 @@ export const fr: Dict = {
|
||||
'observation.comment_label': 'Commentaire',
|
||||
'observation.comment_placeholder': 'Notes cliniques détaillées…',
|
||||
'observation.vertebrae_button': 'Vertèbres…',
|
||||
'observation.vertebrae_button_title': 'Préciser les vertèbres pour cette zone',
|
||||
'observation.vertebrae_button_title':
|
||||
'Préciser les vertèbres pour cette zone',
|
||||
'observation.remove_zone': 'Retirer',
|
||||
'observation.expand_aria': "Développer l'observation",
|
||||
'observation.collapse_aria': "Réduire l'observation",
|
||||
@@ -132,13 +130,26 @@ export const fr: Dict = {
|
||||
|
||||
// vertebra picker
|
||||
'vertebra.title_prefix': 'Préciser les vertèbres — ',
|
||||
'vertebra.region.C': 'Cervicales',
|
||||
'vertebra.region.T': 'Thoraciques',
|
||||
'vertebra.region.L': 'Lombaires',
|
||||
'vertebra.region.S': 'Sacrales',
|
||||
'vertebra.region.Cd': 'Caudales',
|
||||
'vertebra.check_all': 'Tout cocher',
|
||||
'vertebra.uncheck_all': 'Tout décocher',
|
||||
'vertebra.extend_to': "Afficher jusqu'à {max}",
|
||||
'vertebra.range_note':
|
||||
'Nombre usuel : {usual} ; variation documentée : {min} à {max}.',
|
||||
|
||||
// sheet
|
||||
'sheet.status.draft':
|
||||
'Fiche anatomique : brouillon de référence, non validé médicalement',
|
||||
'sheet.status.published': 'Fiche anatomique officielle',
|
||||
'sheet.loading': 'Chargement de la fiche anatomique…',
|
||||
|
||||
// unresolved (migrated) data
|
||||
'observation.unresolved_short': 'hérité',
|
||||
'observation.zone_unresolved':
|
||||
"Zone héritée d'un ancien bilan, absente de la fiche actuelle",
|
||||
'observation.findings_unresolved_label':
|
||||
'Constats hérités (hors référentiel actuel)',
|
||||
'observation.findings_unresolved_help':
|
||||
"Constats importés d'un ancien bilan dont le chemin n'existe plus dans la fiche : conservés avec leurs libellés d'origine.",
|
||||
|
||||
// laterality
|
||||
'lateral.which_side': 'Quel côté ?',
|
||||
@@ -150,9 +161,9 @@ export const fr: Dict = {
|
||||
|
||||
// severity
|
||||
'severity.aria': 'Sévérité',
|
||||
'severity.légère': 'légère',
|
||||
'severity.modérée': 'modérée',
|
||||
'severity.sévère': 'sévère',
|
||||
'severity.mild': 'légère',
|
||||
'severity.moderate': 'modérée',
|
||||
'severity.severe': 'sévère',
|
||||
|
||||
// pdf
|
||||
'pdf.eyebrow.observation': 'OBSERVATION',
|
||||
@@ -180,77 +191,4 @@ export const fr: Dict = {
|
||||
'lang.switch_to_en': 'Switch to English',
|
||||
'lang.fr': 'FR',
|
||||
'lang.en': 'EN',
|
||||
|
||||
// svg editor
|
||||
'svg_editor.title': 'Editeur SVG anatomique',
|
||||
'svg_editor.subtitle': 'Points, zones & catégories cliquables',
|
||||
'svg_editor.file': 'Fichier',
|
||||
'svg_editor.choose_file': 'Choisir un fichier SVG',
|
||||
'svg_editor.change_file': 'Changer de fichier SVG',
|
||||
'svg_editor.export': 'Exporter le SVG',
|
||||
'svg_editor.mode': 'Mode',
|
||||
'svg_editor.mode_select': 'Sélectionner / déplacer',
|
||||
'svg_editor.mode_point': 'Ajouter un point',
|
||||
'svg_editor.mode_polygon': 'Ajouter un polygone',
|
||||
'svg_editor.validate_polygon': 'Valider le polygone (Entrée)',
|
||||
'svg_editor.cancel_polygon': 'Annuler (Echap)',
|
||||
'svg_editor.category_for_new': 'Catégorie des nouveaux éléments',
|
||||
'svg_editor.categories': 'Catégories',
|
||||
'svg_editor.shared_color': '(couleur partagée)',
|
||||
'svg_editor.category_placeholder': 'Nom de catégorie',
|
||||
'svg_editor.selected_element': 'Elément sélectionné',
|
||||
'svg_editor.opens_detail': 'Cette zone ouvre une vue détaillée',
|
||||
'svg_editor.detail_id_label': 'ID vue détaillée (ex. head, front-leg)',
|
||||
'svg_editor.detail_id_placeholder': 'head',
|
||||
'svg_editor.name_fr': 'Nom français',
|
||||
'svg_editor.name_fr_placeholder': 'ex: Hanche',
|
||||
'svg_editor.name_en': 'Nom anglais',
|
||||
'svg_editor.name_en_placeholder': 'ex: Hip joint',
|
||||
'svg_editor.category': 'Catégorie',
|
||||
'svg_editor.radius': 'Rayon (cercle)',
|
||||
'svg_editor.fill_opacity': 'Opacité du remplissage',
|
||||
'svg_editor.polygon_editing': 'Edition du polygone :',
|
||||
'svg_editor.polygon_drag': 'Glissez une poignée jaune pour la déplacer',
|
||||
'svg_editor.polygon_insert': 'Cliquez une poignée blanche pour insérer un sommet',
|
||||
'svg_editor.polygon_delete': 'Alt+clic ou clic droit sur une poignée jaune pour la supprimer',
|
||||
'svg_editor.redraw_polygon': 'Redessiner ce polygone',
|
||||
'svg_editor.delete': 'Supprimer',
|
||||
'svg_editor.elements': 'Eléments',
|
||||
'svg_editor.filter_placeholder': 'Filtrer...',
|
||||
'svg_editor.welcome_title': 'Editeur SVG anatomique',
|
||||
'svg_editor.welcome_text': 'Importez un fichier SVG pour commencer. Si votre fichier contient déjà des points/zones avec ',
|
||||
'svg_editor.welcome_text_suffix': ', ils seront détectés et configurés automatiquement.',
|
||||
'svg_editor.welcome_drag_hint': 'ou glissez-déposez un fichier SVG n\'importe où',
|
||||
'svg_editor.no_categories': 'Aucune catégorie. Utilisez le formulaire ci-dessous pour en ajouter une.',
|
||||
'svg_editor.new_point_fr': 'Nouveau point',
|
||||
'svg_editor.new_point_en': 'New point',
|
||||
'svg_editor.new_zone_fr': 'Nouvelle zone',
|
||||
'svg_editor.new_zone_en': 'New zone',
|
||||
'svg_editor.alert_drop_svg': 'Déposez un fichier SVG.',
|
||||
'svg_editor.alert_invalid_svg': 'Fichier invalide : aucun élément SVG trouvé.',
|
||||
'svg_editor.alert_min_3': 'Il faut au moins 3 points.',
|
||||
'svg_editor.alert_min_3_vertices': 'Un polygone doit avoir au moins 3 sommets.',
|
||||
'svg_editor.alert_upload_first': 'Importez d\'abord un SVG.',
|
||||
'svg_editor.alert_no_svg_loaded': 'Aucun SVG chargé. Importez d\'abord un fichier.',
|
||||
'svg_editor.alert_cat_name_required': 'Donnez un nom à la catégorie.',
|
||||
'svg_editor.alert_cat_invalid_name': 'Nom invalide.',
|
||||
'svg_editor.alert_cat_exists': 'Cette catégorie existe déjà.',
|
||||
'svg_editor.confirm_delete_element': 'Supprimer cet élément ?',
|
||||
'svg_editor.confirm_delete_cat': 'Supprimer la catégorie "{name}" ?',
|
||||
'svg_editor.confirm_delete_cat_count': '\n\nElle contient {count} élément(s) qui seront aussi supprimés.',
|
||||
'svg_editor.confirm_redraw': 'Effacer ce polygone et le redessiner ?',
|
||||
'svg_editor.handle_drag': 'Glisser pour déplacer | Alt+clic ou clic droit pour supprimer',
|
||||
'svg_editor.handle_insert': 'Cliquez pour insérer un sommet ici',
|
||||
'svg_editor.polygon_vertices': 'polygone ({count} sommets)',
|
||||
'svg_editor.drop_svg_here': 'Déposez le SVG ici',
|
||||
'svg_editor.lateral': 'Latéralité',
|
||||
'svg_editor.lateral_unpaired': 'Unilatéral (pas de côté)',
|
||||
'svg_editor.lateral_bilateral': 'Bilatéral (gauche / droite)',
|
||||
'svg_editor.source_project': 'SVG du projet',
|
||||
'svg_editor.source_upload': 'Importer un fichier',
|
||||
'svg_editor.species': 'Espèce',
|
||||
'svg_editor.view': 'Vue',
|
||||
'svg_editor.view_main': 'Corps entier',
|
||||
'svg_editor.view_detail': 'Détail : {name}',
|
||||
'svg_editor.load': 'Charger',
|
||||
}
|
||||
@@ -18,7 +18,8 @@ export function formatDate(isoDate: string, locale: Locale): string {
|
||||
if (!match) throw new Error(`Invalid ISO date: ${isoDate}`)
|
||||
const [, y, mo, d] = match
|
||||
const date = new Date(Date.UTC(Number(y), Number(mo) - 1, Number(d)))
|
||||
if (Number.isNaN(date.getTime())) throw new Error(`Invalid ISO date: ${isoDate}`)
|
||||
if (Number.isNaN(date.getTime()))
|
||||
throw new Error(`Invalid ISO date: ${isoDate}`)
|
||||
return new Intl.DateTimeFormat(LOCALE_TAG[locale], {
|
||||
day: 'numeric',
|
||||
month: 'long',
|
||||
|
||||
@@ -1,131 +0,0 @@
|
||||
import type {
|
||||
ObservationZone,
|
||||
Vertebra,
|
||||
VertebralRegion,
|
||||
} from '@/domain/schema/observation'
|
||||
import type { Bone } from '@/anatomy/types'
|
||||
|
||||
/**
|
||||
* Infers the matching vertebral region from a free-form anatomical label
|
||||
* (zone name in FR or EN). Matches on substring roots, case-insensitive,
|
||||
* accent-insensitive. Returns undefined when no root matches.
|
||||
*/
|
||||
export function regionFromLabel(label: string): VertebralRegion | undefined {
|
||||
const norm = label
|
||||
.normalize('NFD')
|
||||
.replace(/\p{Diacritic}/gu, '')
|
||||
.toLowerCase()
|
||||
if (norm.includes('cervic')) return 'C'
|
||||
if (norm.includes('thorac') || norm.includes('dors')) return 'T'
|
||||
if (norm.includes('lombair') || norm.includes('lumbar')) return 'L'
|
||||
if (norm.includes('sacral') || norm.includes('sacre')) return 'S'
|
||||
if (norm.includes('caudal') || norm.includes('coccyg')) return 'Cd'
|
||||
return undefined
|
||||
}
|
||||
|
||||
/**
|
||||
* Finds the spine-zone boneId whose label maps to the given vertebral region.
|
||||
* Spine zones are the SVG elements flagged data-anno-special="vertebral-precision".
|
||||
* Returns undefined when the SVG exposes no zone for that region.
|
||||
*/
|
||||
export function findSpineZoneId(
|
||||
region: VertebralRegion,
|
||||
bones: Map<string, Bone>,
|
||||
): string | undefined {
|
||||
for (const [id, bone] of bones) {
|
||||
if (bone.special !== 'vertebral-precision') continue
|
||||
const r = regionFromLabel(bone.fr) ?? regionFromLabel(bone.en)
|
||||
if (r === region) return id
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
|
||||
const key = (v: Vertebra) => `${v.region}${v.index}`
|
||||
|
||||
const isSpineZone = (z: ObservationZone, bones: Map<string, Bone>) =>
|
||||
!z.detailSourceId && bones.get(z.boneId)?.special === 'vertebral-precision'
|
||||
|
||||
/**
|
||||
* Gathers the union of vertebrae across every spine zone of an observation so
|
||||
* the picker can show selections from all regions at once. `priorityBoneId`'s
|
||||
* vertebrae are listed first so the picker opens on the clicked zone's tab
|
||||
* (the picker keys its default tab off the first vertebra's region).
|
||||
*
|
||||
* Deduplicated by region+index; order otherwise follows zone order.
|
||||
*/
|
||||
export function collectSpineVertebrae(
|
||||
zones: ObservationZone[],
|
||||
bones: Map<string, Bone>,
|
||||
priorityBoneId?: string,
|
||||
): Vertebra[] {
|
||||
const spine = zones.filter((z) => isSpineZone(z, bones))
|
||||
const ordered = priorityBoneId
|
||||
? [
|
||||
...spine.filter((z) => z.boneId === priorityBoneId),
|
||||
...spine.filter((z) => z.boneId !== priorityBoneId),
|
||||
]
|
||||
: spine
|
||||
|
||||
const out: Vertebra[] = []
|
||||
const seen = new Set<string>()
|
||||
for (const z of ordered) {
|
||||
for (const v of z.vertebrae ?? []) {
|
||||
if (seen.has(key(v))) continue
|
||||
seen.add(key(v))
|
||||
out.push(v)
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
/**
|
||||
* Reconciles the observation's spine zones with the full set of vertebrae the
|
||||
* picker confirmed (the picker shows and edits every region at once).
|
||||
*
|
||||
* Authoritative per region: each region's zone gets exactly the vertebrae
|
||||
* picked for it (replace, so unchecking sticks); a region with no vertebrae
|
||||
* left has its spine zone pruned; a region picked for the first time spawns its
|
||||
* zone so the SVG highlights it and its findings picker appears. Non-spine
|
||||
* zones (and their order) are preserved untouched.
|
||||
*
|
||||
* Returns a new zones array; the original is not mutated.
|
||||
*/
|
||||
export function syncSpineZones(
|
||||
zones: ObservationZone[],
|
||||
vertebrae: Vertebra[],
|
||||
bones: Map<string, Bone>,
|
||||
): ObservationZone[] {
|
||||
const byRegion = new Map<VertebralRegion, Vertebra[]>()
|
||||
for (const v of vertebrae) {
|
||||
byRegion.set(v.region, [...(byRegion.get(v.region) ?? []), v])
|
||||
}
|
||||
|
||||
const result: ObservationZone[] = []
|
||||
const handled = new Set<VertebralRegion>()
|
||||
|
||||
for (const z of zones) {
|
||||
const bone = bones.get(z.boneId)
|
||||
const region =
|
||||
!z.detailSourceId && bone?.special === 'vertebral-precision'
|
||||
? (regionFromLabel(bone.fr) ?? regionFromLabel(bone.en))
|
||||
: undefined
|
||||
// Non-spine, detail-sourced, or unrecognized-label zones pass through.
|
||||
if (!region) {
|
||||
result.push(z)
|
||||
continue
|
||||
}
|
||||
const verts = byRegion.get(region)
|
||||
if (!verts) continue // region deselected to zero → prune the zone
|
||||
result.push({ ...z, vertebrae: verts })
|
||||
handled.add(region)
|
||||
}
|
||||
|
||||
// Regions picked that had no existing zone yet → spawn one.
|
||||
for (const [region, verts] of byRegion) {
|
||||
if (handled.has(region)) continue
|
||||
const zoneId = findSpineZoneId(region, bones)
|
||||
if (zoneId) result.push({ boneId: zoneId, vertebrae: verts })
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
@@ -1,130 +0,0 @@
|
||||
import type { ZoneFindings } from '@/domain/schema/findings'
|
||||
|
||||
/**
|
||||
* Bridges SVG anatomy labels to the JSON findings catalog when the two
|
||||
* carry slightly different strings (casse, accents, abbreviations like
|
||||
* "(ATM)" vs "Articulation Temporo-Mandibulaire (ATM)", or genuine typos).
|
||||
*
|
||||
* Strategy: normalize aggressively (lowercase + NFD-strip accents + drop
|
||||
* non-alphanumerics), then score each (boneLabel, zoneLabel) pair:
|
||||
*
|
||||
* 0 exact normalized match
|
||||
* 1 one normalized string is contained in the other (substring)
|
||||
* 2+d Levenshtein distance d, within a length-relative threshold
|
||||
* ∞ beyond tolerance — discarded
|
||||
*
|
||||
* Language strategy: English first (no accents → fewer normalization
|
||||
* edge cases), French as fallback, fuzzy matching across both languages
|
||||
* as last resort. Falls through silently when nothing matches.
|
||||
*/
|
||||
|
||||
export function normalizeLabel(s: string | undefined | null): string {
|
||||
if (!s) return ''
|
||||
return s
|
||||
.toLowerCase()
|
||||
.normalize('NFD')
|
||||
.replace(/[\u0300-\u036f]/g, '')
|
||||
.replace(/[^a-z0-9]+/g, '')
|
||||
}
|
||||
|
||||
export function levenshtein(a: string, b: string): number {
|
||||
if (a === b) return 0
|
||||
const al = a.length
|
||||
const bl = b.length
|
||||
if (al === 0) return bl
|
||||
if (bl === 0) return al
|
||||
let prev: number[] = new Array(bl + 1)
|
||||
let curr: number[] = new Array(bl + 1)
|
||||
for (let j = 0; j <= bl; j += 1) prev[j] = j
|
||||
for (let i = 1; i <= al; i += 1) {
|
||||
curr[0] = i
|
||||
for (let j = 1; j <= bl; j += 1) {
|
||||
const cost = a.charCodeAt(i - 1) === b.charCodeAt(j - 1) ? 0 : 1
|
||||
curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost)
|
||||
}
|
||||
const tmp = prev
|
||||
prev = curr
|
||||
curr = tmp
|
||||
}
|
||||
return prev[bl]
|
||||
}
|
||||
|
||||
const SCORE_EXACT = 0
|
||||
const SCORE_SUBSTRING = 1
|
||||
const SCORE_FUZZY_BASE = 2
|
||||
const SCORE_NO_MATCH = Number.POSITIVE_INFINITY
|
||||
|
||||
/**
|
||||
* Compares two raw labels after normalization. Lower scores beat higher
|
||||
* ones; SCORE_NO_MATCH means the inputs are too dissimilar to be linked
|
||||
* confidently.
|
||||
*/
|
||||
export function scorePair(boneLabel: string, zoneLabel: string): number {
|
||||
const a = normalizeLabel(boneLabel)
|
||||
const b = normalizeLabel(zoneLabel)
|
||||
if (!a || !b) return SCORE_NO_MATCH
|
||||
if (a === b) return SCORE_EXACT
|
||||
if (a.includes(b) || b.includes(a)) return SCORE_SUBSTRING
|
||||
const distance = levenshtein(a, b)
|
||||
const longest = Math.max(a.length, b.length)
|
||||
// 25% character tolerance, with a minimum of 2 edits so short labels
|
||||
// (e.g. "Hip") still admit one typo without exploding into the matcher.
|
||||
const threshold = Math.max(2, Math.floor(longest * 0.25))
|
||||
if (distance > threshold) return SCORE_NO_MATCH
|
||||
return SCORE_FUZZY_BASE + distance
|
||||
}
|
||||
|
||||
export interface BoneLabels {
|
||||
fr: string
|
||||
en: string
|
||||
}
|
||||
|
||||
interface ScoredZone {
|
||||
zone: ZoneFindings
|
||||
score: number
|
||||
}
|
||||
|
||||
function bestOnLanguage(
|
||||
boneLabel: string,
|
||||
zones: ZoneFindings[],
|
||||
pickZoneLabel: (zone: ZoneFindings) => string,
|
||||
): ScoredZone | undefined {
|
||||
let best: ScoredZone | undefined
|
||||
for (const zone of zones) {
|
||||
const score = scorePair(boneLabel, pickZoneLabel(zone))
|
||||
if (score === SCORE_NO_MATCH) continue
|
||||
if (!best || score < best.score) best = { zone, score }
|
||||
}
|
||||
return best
|
||||
}
|
||||
|
||||
/**
|
||||
* Pick the findings tree most likely to describe a clicked SVG zone.
|
||||
*
|
||||
* 1. If the English bone label exactly matches (or is contained in) an
|
||||
* English zone label, return that zone — cheapest, most reliable.
|
||||
* 2. Otherwise try the same on the French side.
|
||||
* 3. As a last resort, take the lowest fuzzy score across all four
|
||||
* (bone-lang, zone-lang) pairings.
|
||||
*/
|
||||
export function matchZoneFindings(
|
||||
bone: BoneLabels,
|
||||
zones: ZoneFindings[],
|
||||
): ZoneFindings | undefined {
|
||||
if (zones.length === 0) return undefined
|
||||
|
||||
const enOnEn = bestOnLanguage(bone.en, zones, (z) => z.name_en)
|
||||
if (enOnEn && enOnEn.score <= SCORE_SUBSTRING) return enOnEn.zone
|
||||
|
||||
const frOnFr = bestOnLanguage(bone.fr, zones, (z) => z.name_fr)
|
||||
if (frOnFr && frOnFr.score <= SCORE_SUBSTRING) return frOnFr.zone
|
||||
|
||||
const enOnFr = bestOnLanguage(bone.en, zones, (z) => z.name_fr)
|
||||
const frOnEn = bestOnLanguage(bone.fr, zones, (z) => z.name_en)
|
||||
const candidates = [enOnEn, frOnFr, enOnFr, frOnEn].filter(
|
||||
(x): x is ScoredZone => x !== undefined,
|
||||
)
|
||||
if (candidates.length === 0) return undefined
|
||||
candidates.sort((a, b) => a.score - b.score)
|
||||
return candidates[0].zone
|
||||
}
|
||||
@@ -1,59 +1,92 @@
|
||||
import { AFRelationship, type PDFDocument } from 'pdf-lib'
|
||||
import { ReportSchema, type Report } from '@/domain/schema/report'
|
||||
import {
|
||||
readReportDocument,
|
||||
REPORT_VERSION,
|
||||
UnsupportedReportVersionError,
|
||||
type MigrationOutcome,
|
||||
type Report,
|
||||
type ReportMigrationMap,
|
||||
} from '@faunosteo/domain'
|
||||
|
||||
/**
|
||||
* The report document travels inside the PDF as a native attachment.
|
||||
* Written as v3; read back as v3, or as v2 migrated through the sheet's
|
||||
* migration map (the practitioner's archive). Any other version is refused
|
||||
* with the found version.
|
||||
*/
|
||||
|
||||
const FILENAME = 'osteo-report.json'
|
||||
|
||||
/**
|
||||
* Internal sentinel raised when the attached JSON's `version` field is
|
||||
* present but not 2. The UI-facing message is composed by the importer
|
||||
* caller against the active i18n dict — this error only carries the
|
||||
* discriminating data.
|
||||
*/
|
||||
export class IncompatibleReportVersionError extends Error {
|
||||
constructor(public readonly foundVersion: number) {
|
||||
super(`incompatible_version:${foundVersion}`)
|
||||
constructor(public readonly foundVersion: number | null) {
|
||||
super(`incompatible_version:${foundVersion ?? 'unknown'}`)
|
||||
this.name = 'IncompatibleReportVersionError'
|
||||
}
|
||||
}
|
||||
|
||||
export async function attachReportJson(pdfDoc: PDFDocument, report: Report): Promise<void> {
|
||||
export async function attachReportJson(
|
||||
pdfDoc: PDFDocument,
|
||||
report: Report,
|
||||
): Promise<void> {
|
||||
const bytes = new TextEncoder().encode(JSON.stringify(report, null, 2))
|
||||
await pdfDoc.attach(bytes, FILENAME, {
|
||||
mimeType: 'application/json',
|
||||
description: 'Faunosteo state v2',
|
||||
description: `Faunosteo state v${REPORT_VERSION}`,
|
||||
creationDate: new Date(),
|
||||
modificationDate: new Date(),
|
||||
afRelationship: AFRelationship.Data,
|
||||
})
|
||||
}
|
||||
|
||||
export async function extractReportJson(pdfDoc: PDFDocument): Promise<Report> {
|
||||
const maybeApi = pdfDoc as unknown as { getAttachments?: () => Array<{ name: string; data: Uint8Array }> }
|
||||
export interface ExtractedReport extends MigrationOutcome {
|
||||
/** True when the attachment was an older version lifted to v3. */
|
||||
migrated: boolean
|
||||
}
|
||||
|
||||
export async function extractReportJson(
|
||||
pdfDoc: PDFDocument,
|
||||
map: ReportMigrationMap,
|
||||
): Promise<ExtractedReport> {
|
||||
const maybeApi = pdfDoc as unknown as {
|
||||
getAttachments?: () => Array<{ name: string; data: Uint8Array }>
|
||||
}
|
||||
if (typeof maybeApi.getAttachments === 'function') {
|
||||
const list = maybeApi.getAttachments()
|
||||
if (list && list.length) {
|
||||
const hit = list.find((a) => a.name.startsWith('osteo-report') && a.name.endsWith('.json')) ?? list[0]
|
||||
return parseAttachment(hit.data)
|
||||
const hit =
|
||||
list.find(
|
||||
(a) => a.name.startsWith('osteo-report') && a.name.endsWith('.json'),
|
||||
) ?? list[0]
|
||||
return parseAttachment(hit.data, map)
|
||||
}
|
||||
}
|
||||
const fallback = await traverseForJsonAttachment(pdfDoc)
|
||||
if (!fallback) throw new Error('No osteo-report attachment found')
|
||||
return parseAttachment(fallback)
|
||||
return parseAttachment(fallback, map)
|
||||
}
|
||||
|
||||
function parseAttachment(bytes: Uint8Array): Report {
|
||||
const text = new TextDecoder().decode(bytes)
|
||||
const data: unknown = JSON.parse(text)
|
||||
if (
|
||||
function parseAttachment(
|
||||
bytes: Uint8Array,
|
||||
map: ReportMigrationMap,
|
||||
): ExtractedReport {
|
||||
const data: unknown = JSON.parse(new TextDecoder().decode(bytes))
|
||||
const version =
|
||||
data !== null &&
|
||||
typeof data === 'object' &&
|
||||
'version' in data &&
|
||||
typeof (data as { version: unknown }).version === 'number' &&
|
||||
(data as { version: number }).version !== 2
|
||||
) {
|
||||
throw new IncompatibleReportVersionError((data as { version: number }).version)
|
||||
typeof (data as { version?: unknown }).version === 'number'
|
||||
? (data as { version: number }).version
|
||||
: null
|
||||
try {
|
||||
return {
|
||||
...readReportDocument(data, map),
|
||||
migrated: version !== REPORT_VERSION,
|
||||
}
|
||||
} catch (err) {
|
||||
if (err instanceof UnsupportedReportVersionError) {
|
||||
throw new IncompatibleReportVersionError(err.foundVersion)
|
||||
}
|
||||
throw err
|
||||
}
|
||||
return ReportSchema.parse(data)
|
||||
}
|
||||
|
||||
interface RawObj {
|
||||
@@ -68,10 +101,14 @@ interface RawObj {
|
||||
const MAX_INFLATED_BYTES = 16 * 1024 * 1024
|
||||
|
||||
/** Exported for tests. Returns null on failure or when the cap is exceeded. */
|
||||
export async function inflateFlate(bytes: Uint8Array): Promise<Uint8Array | null> {
|
||||
export async function inflateFlate(
|
||||
bytes: Uint8Array,
|
||||
): Promise<Uint8Array | null> {
|
||||
if (typeof DecompressionStream === 'undefined') return null
|
||||
try {
|
||||
const stream = new Blob([bytes as BlobPart]).stream().pipeThrough(new DecompressionStream('deflate'))
|
||||
const stream = new Blob([bytes as BlobPart])
|
||||
.stream()
|
||||
.pipeThrough(new DecompressionStream('deflate'))
|
||||
const reader = stream.getReader()
|
||||
const chunks: Uint8Array[] = []
|
||||
let total = 0
|
||||
@@ -99,13 +136,20 @@ export async function inflateFlate(bytes: Uint8Array): Promise<Uint8Array | null
|
||||
|
||||
function dictHasFlateFilter(entries: Array<[unknown, unknown]>): boolean {
|
||||
for (const [k, v] of entries) {
|
||||
if (String(k).includes('Filter') && String(v).includes('FlateDecode')) return true
|
||||
if (String(k).includes('Filter') && String(v).includes('FlateDecode'))
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
async function traverseForJsonAttachment(pdfDoc: PDFDocument): Promise<Uint8Array | null> {
|
||||
const ctx = (pdfDoc as unknown as { context: { enumerateIndirectObjects(): Array<[unknown, RawObj]> } }).context
|
||||
async function traverseForJsonAttachment(
|
||||
pdfDoc: PDFDocument,
|
||||
): Promise<Uint8Array | null> {
|
||||
const ctx = (
|
||||
pdfDoc as unknown as {
|
||||
context: { enumerateIndirectObjects(): Array<[unknown, RawObj]> }
|
||||
}
|
||||
).context
|
||||
for (const [, obj] of ctx.enumerateIndirectObjects()) {
|
||||
if (!obj || typeof obj !== 'object') continue
|
||||
if (!(obj.contents instanceof Uint8Array)) continue
|
||||
@@ -115,9 +159,13 @@ async function traverseForJsonAttachment(pdfDoc: PDFDocument): Promise<Uint8Arra
|
||||
for (const [k, v] of entries) {
|
||||
const ks = String(k)
|
||||
const vs = String(v)
|
||||
if (ks.includes('Type') && vs.includes('EmbeddedFile')) isEmbeddedFile = true
|
||||
if (ks.includes('Type') && vs.includes('EmbeddedFile'))
|
||||
isEmbeddedFile = true
|
||||
// PDF name syntax escapes '/' as '#2F': /application#2Fjson
|
||||
if (ks.includes('Subtype') && (vs.includes('application/json') || vs.includes('application#2Fjson'))) {
|
||||
if (
|
||||
ks.includes('Subtype') &&
|
||||
(vs.includes('application/json') || vs.includes('application#2Fjson'))
|
||||
) {
|
||||
isJsonSubtype = true
|
||||
}
|
||||
}
|
||||
|
||||
+18
-90
@@ -1,94 +1,32 @@
|
||||
import { PDFDocument } from 'pdf-lib'
|
||||
import type { Report } from '@/domain/schema/report'
|
||||
import type { SpeciesFindings } from '@/domain/schema/findings'
|
||||
import type { Report } from '@faunosteo/domain'
|
||||
import type { Locale } from '@/i18n/types'
|
||||
import { getDict } from '@/i18n'
|
||||
import type { SheetIndex } from '@/services/sheetIndex'
|
||||
import { embedFonts } from './fonts'
|
||||
import { addObservationPage } from './render/observationPage'
|
||||
import { addConclusionPage } from './render/conclusionPage'
|
||||
import { attachReportJson } from './attachment'
|
||||
import { drawFooter } from './render/footer'
|
||||
import { loadFaunosteoLogo, loadFaunosteoComLogo, loadZenqualityLogo } from './render/logo'
|
||||
import {
|
||||
loadFaunosteoLogo,
|
||||
loadFaunosteoComLogo,
|
||||
loadZenqualityLogo,
|
||||
} from './render/logo'
|
||||
import { rasterizeSvg } from './render/svgToPng'
|
||||
import { loadSvg } from '@/anatomy/svgLoader'
|
||||
import { parseSvgBones } from '@/anatomy/svgConvention'
|
||||
import { getSpecies } from '@/domain/species/registry'
|
||||
|
||||
export interface PdfExportOptions {
|
||||
locale: Locale
|
||||
}
|
||||
|
||||
/** Bilingual label pair surfaced to the PDF render layer. */
|
||||
export interface ZoneLabelPair {
|
||||
fr: string
|
||||
en: string
|
||||
}
|
||||
|
||||
/**
|
||||
* Builds a `data-anno-id → { fr, en }` map by parsing every SVG the
|
||||
* species manifest knows about. Each SVG is loaded independently so a
|
||||
* failure on the detail asset never prevents the main labels (or vice
|
||||
* versa) from making it into the returned map. The PDF render layer
|
||||
* picks the locale-appropriate label at draw time (falls back to the
|
||||
* opposite language when one side is missing).
|
||||
*
|
||||
* Exported for unit testing — the editor calls it indirectly via
|
||||
* `exportReportToPdf`.
|
||||
* Exports a report to PDF from the in-memory document and the loaded sheet:
|
||||
* labels and drawings come from the sheet, nothing is fetched except the
|
||||
* partner logos. The v3 document is attached for re-import.
|
||||
*/
|
||||
export async function buildZoneLabels(
|
||||
report: Report,
|
||||
): Promise<Map<string, ZoneLabelPair>> {
|
||||
const labels = new Map<string, ZoneLabelPair>()
|
||||
const species = getSpecies(report.animal.speciesId)
|
||||
if (!species) return labels
|
||||
|
||||
const sources: string[] = [
|
||||
species.mainSvg,
|
||||
...Object.values(species.details),
|
||||
]
|
||||
await Promise.all(
|
||||
sources.map(async (src) => {
|
||||
try {
|
||||
const root = await loadSvg(src)
|
||||
parseSvgBones(root).forEach((b, id) => {
|
||||
const existing = labels.get(id)
|
||||
if (existing) {
|
||||
if (!existing.fr && b.fr) existing.fr = b.fr
|
||||
if (!existing.en && b.en) existing.en = b.en
|
||||
} else if (b.fr || b.en) {
|
||||
labels.set(id, { fr: b.fr, en: b.en })
|
||||
}
|
||||
})
|
||||
} catch (err) {
|
||||
console.warn(`buildZoneLabels: skipped ${src}`, err)
|
||||
}
|
||||
}),
|
||||
)
|
||||
|
||||
return labels
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads the parsed findings catalog for a species so the PDF renderer
|
||||
* can resolve a Finding's `zoneId` (JSON catalog key) back to its
|
||||
* human-readable zone name.
|
||||
*/
|
||||
async function loadSpeciesFindings(
|
||||
speciesId: string,
|
||||
): Promise<SpeciesFindings | null> {
|
||||
const species = getSpecies(speciesId)
|
||||
if (!species) return null
|
||||
try {
|
||||
const m = await species.findings()
|
||||
return m.default
|
||||
} catch (err) {
|
||||
console.warn(`loadSpeciesFindings: failed for ${speciesId}`, err)
|
||||
return null
|
||||
}
|
||||
}
|
||||
|
||||
export async function exportReportToPdf(
|
||||
report: Report,
|
||||
sheet: SheetIndex,
|
||||
opts: PdfExportOptions,
|
||||
): Promise<Uint8Array> {
|
||||
const { locale } = opts
|
||||
@@ -101,53 +39,43 @@ export async function exportReportToPdf(
|
||||
pdfDoc.setModificationDate(new Date())
|
||||
|
||||
const fonts = await embedFonts(pdfDoc)
|
||||
const zoneLabels = await buildZoneLabels(report)
|
||||
const findingsTree = await loadSpeciesFindings(report.animal.speciesId)
|
||||
|
||||
let headerLogoPdf = null
|
||||
let footerLogoPdf = null
|
||||
let zqLogoPdfImage = null
|
||||
let pawsLogoPdf = null
|
||||
try {
|
||||
const bytes = await loadFaunosteoLogo()
|
||||
headerLogoPdf = await pdfDoc.embedPng(bytes)
|
||||
headerLogoPdf = await pdfDoc.embedPng(await loadFaunosteoLogo())
|
||||
} catch (err) {
|
||||
console.warn('Faunosteo logo embed failed:', err)
|
||||
}
|
||||
try {
|
||||
const bytes = await loadFaunosteoComLogo()
|
||||
footerLogoPdf = await pdfDoc.embedPng(bytes)
|
||||
footerLogoPdf = await pdfDoc.embedPng(await loadFaunosteoComLogo())
|
||||
} catch (err) {
|
||||
console.warn('Faunosteo -com logo embed failed:', err)
|
||||
}
|
||||
try {
|
||||
const zqPngBytes = await loadZenqualityLogo()
|
||||
zqLogoPdfImage = await pdfDoc.embedPng(zqPngBytes)
|
||||
zqLogoPdfImage = await pdfDoc.embedPng(await loadZenqualityLogo())
|
||||
} catch (err) {
|
||||
console.warn('ZenQuality logo embed failed:', err)
|
||||
}
|
||||
try {
|
||||
const resp = await fetch('/Paws_in_harmony.svg')
|
||||
if (!resp.ok) throw new Error(`Paws logo fetch failed: HTTP ${resp.status}`)
|
||||
const svgText = await resp.text()
|
||||
const pawsPngBytes = await rasterizeSvg(svgText)
|
||||
pawsLogoPdf = await pdfDoc.embedPng(pawsPngBytes)
|
||||
pawsLogoPdf = await pdfDoc.embedPng(await rasterizeSvg(await resp.text()))
|
||||
} catch (err) {
|
||||
console.warn('Paws in Harmony logo embed failed:', err)
|
||||
}
|
||||
|
||||
const headerAssets = { logoPng: headerLogoPdf }
|
||||
const totalObs = report.observations.length
|
||||
|
||||
for (let i = 0; i < totalObs; i += 1) {
|
||||
for (let i = 0; i < report.observations.length; i += 1) {
|
||||
await addObservationPage({
|
||||
pdfDoc,
|
||||
report,
|
||||
observation: report.observations[i],
|
||||
observation: report.observations[i]!,
|
||||
obsIndex: i,
|
||||
fonts,
|
||||
zoneLabels,
|
||||
findingsTree,
|
||||
sheet,
|
||||
locale,
|
||||
headerAssets,
|
||||
})
|
||||
|
||||
@@ -1,6 +1,10 @@
|
||||
import { PDFDocument } from 'pdf-lib'
|
||||
import { extractReportJson, IncompatibleReportVersionError } from './attachment'
|
||||
import type { Report } from '@/domain/schema/report'
|
||||
import type { ReportMigrationMap } from '@faunosteo/domain'
|
||||
import {
|
||||
extractReportJson,
|
||||
IncompatibleReportVersionError,
|
||||
type ExtractedReport,
|
||||
} from './attachment'
|
||||
|
||||
export type ImportErrorKind =
|
||||
| 'invalid_pdf'
|
||||
@@ -15,14 +19,22 @@ export type ImportErrorKind =
|
||||
export class ImportError extends Error {
|
||||
constructor(
|
||||
public readonly kind: ImportErrorKind,
|
||||
public readonly foundVersion?: number,
|
||||
public readonly foundVersion?: number | null,
|
||||
) {
|
||||
super(kind)
|
||||
this.name = 'ImportError'
|
||||
}
|
||||
}
|
||||
|
||||
export async function importReportFromPdf(pdfBytes: Uint8Array): Promise<Report> {
|
||||
/**
|
||||
* Reads a Faunosteo PDF back into a report document (v3, or v2 migrated
|
||||
* through the reference sheet's map). The outcome says whether a migration
|
||||
* happened and how many zones or findings it could not place.
|
||||
*/
|
||||
export async function importReportFromPdf(
|
||||
pdfBytes: Uint8Array,
|
||||
map: ReportMigrationMap,
|
||||
): Promise<ExtractedReport> {
|
||||
let pdfDoc: PDFDocument
|
||||
try {
|
||||
pdfDoc = await PDFDocument.load(pdfBytes, { ignoreEncryption: true })
|
||||
@@ -30,7 +42,7 @@ export async function importReportFromPdf(pdfBytes: Uint8Array): Promise<Report>
|
||||
throw new ImportError('invalid_pdf')
|
||||
}
|
||||
try {
|
||||
return await extractReportJson(pdfDoc)
|
||||
return await extractReportJson(pdfDoc, map)
|
||||
} catch (err) {
|
||||
if (err instanceof IncompatibleReportVersionError) {
|
||||
throw new ImportError('incompatible_version', err.foundVersion)
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import { PageSizes, type PDFDocument } from 'pdf-lib'
|
||||
import type { EmbeddedFonts } from '@/pdf/fonts'
|
||||
import type { Report } from '@/domain/schema/report'
|
||||
import type { Report } from '@faunosteo/domain'
|
||||
import type { Locale } from '@/i18n/types'
|
||||
import { getDict } from '@/i18n'
|
||||
import { drawHeader, type HeaderAssets } from './header'
|
||||
@@ -61,9 +61,19 @@ export async function addConclusionPage(
|
||||
|
||||
let cursorY = titleY - SECTION_TOP_GAP
|
||||
|
||||
const sections: Array<{ label: string; body: string; color?: typeof COLOR_INK }> = [
|
||||
{ label: dict['pdf.section.conclusion'], body: report.conclusion || dict['pdf.empty'] },
|
||||
{ label: dict['pdf.section.recommendations'], body: report.recommendations || dict['pdf.empty'] },
|
||||
const sections: Array<{
|
||||
label: string
|
||||
body: string
|
||||
color?: typeof COLOR_INK
|
||||
}> = [
|
||||
{
|
||||
label: dict['pdf.section.conclusion'],
|
||||
body: report.conclusion || dict['pdf.empty'],
|
||||
},
|
||||
{
|
||||
label: dict['pdf.section.recommendations'],
|
||||
body: report.recommendations || dict['pdf.empty'],
|
||||
},
|
||||
]
|
||||
if (report.nextAppointment) {
|
||||
const txt =
|
||||
|
||||
@@ -55,7 +55,10 @@ export function drawFooter(
|
||||
}
|
||||
|
||||
const poweredLabel = `${dict['footer.powered_by']} `
|
||||
const poweredLabelW = fonts.bodyRegular.widthOfTextAtSize(poweredLabel, FONT_SIZE)
|
||||
const poweredLabelW = fonts.bodyRegular.widthOfTextAtSize(
|
||||
poweredLabel,
|
||||
FONT_SIZE,
|
||||
)
|
||||
const zqLogoW = 70
|
||||
const zqLogoH = 16
|
||||
const zqFallback = 'zenquality.fr'
|
||||
@@ -106,12 +109,16 @@ export function drawFooter(
|
||||
}
|
||||
|
||||
const partnerLabel = `${dict['footer.in_partnership']} `
|
||||
const partnerLabelW = fonts.bodyRegular.widthOfTextAtSize(partnerLabel, FONT_SIZE)
|
||||
const partnerLabelW = fonts.bodyRegular.widthOfTextAtSize(
|
||||
partnerLabel,
|
||||
FONT_SIZE,
|
||||
)
|
||||
const partnerUrl = 'https://www.instagram.com/paws.iin.harmony'
|
||||
|
||||
if (assets.pawsLogoPng) {
|
||||
const pawsLogoH = 16
|
||||
const pawsLogoW = pawsLogoH * (assets.pawsLogoPng.width / assets.pawsLogoPng.height)
|
||||
const pawsLogoW =
|
||||
pawsLogoH * (assets.pawsLogoPng.width / assets.pawsLogoPng.height)
|
||||
const partnerX = width - MARGIN_X - partnerLabelW - pawsLogoW
|
||||
page.drawText(partnerLabel, {
|
||||
x: partnerX,
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import type { PDFPage, PDFImage } from 'pdf-lib'
|
||||
import type { EmbeddedFonts } from '@/pdf/fonts'
|
||||
import type { Report } from '@/domain/schema/report'
|
||||
import type { Report } from '@faunosteo/domain'
|
||||
import type { Locale } from '@/i18n/types'
|
||||
import { getDict } from '@/i18n'
|
||||
import { formatDate } from '@/lib/dates'
|
||||
|
||||
@@ -1,19 +1,25 @@
|
||||
import { rgb, PageSizes, type PDFDocument, type PDFPage, type PDFImage } from 'pdf-lib'
|
||||
import {
|
||||
rgb,
|
||||
PageSizes,
|
||||
type PDFDocument,
|
||||
type PDFPage,
|
||||
type PDFImage,
|
||||
} from 'pdf-lib'
|
||||
import type {
|
||||
Finding,
|
||||
Observation,
|
||||
Report,
|
||||
ReportZone,
|
||||
Severity,
|
||||
} from '@faunosteo/domain'
|
||||
import type { EmbeddedFonts } from '@/pdf/fonts'
|
||||
import type { Report } from '@/domain/schema/report'
|
||||
import type { Finding, Observation } from '@/domain/schema/observation'
|
||||
import type { SpeciesFindings } from '@/domain/schema/findings'
|
||||
import type { SpeciesManifest } from '@/domain/species/types'
|
||||
import type { Locale, Dict } from '@/i18n/types'
|
||||
import { getDict } from '@/i18n'
|
||||
import { pickLocaleLabel } from '@/i18n/pickLocaleLabel'
|
||||
import type { ZoneLabelPair } from '@/pdf/export'
|
||||
import { pickLabel, type SheetIndex } from '@/services/sheetIndex'
|
||||
import { buildViewSvg } from '@/anatomy/drawing'
|
||||
import { drawHeader, type HeaderAssets } from './header'
|
||||
import { rasterizeSvg } from './svgToPng'
|
||||
import { wrapLines } from './text'
|
||||
import { loadSvg } from '@/anatomy/svgLoader'
|
||||
import { parseSvgBones } from '@/anatomy/svgConvention'
|
||||
import { getSpecies } from '@/domain/species/registry'
|
||||
import {
|
||||
MARGIN_X,
|
||||
EYEBROW_Y_OFFSET,
|
||||
@@ -39,10 +45,10 @@ const SECTION_BLOCK_GAP = 10
|
||||
|
||||
const COLOR_WHITE = rgb(1, 1, 1)
|
||||
|
||||
const SEVERITY_BG: Record<string, ReturnType<typeof rgb>> = {
|
||||
'légère': rgb(0.55, 0.65, 0.45),
|
||||
'modérée': rgb(0.85, 0.55, 0.18),
|
||||
'sévère': rgb(0.78, 0.20, 0.20),
|
||||
const SEVERITY_BG: Record<Severity, ReturnType<typeof rgb>> = {
|
||||
mild: rgb(0.55, 0.65, 0.45),
|
||||
moderate: rgb(0.85, 0.55, 0.18),
|
||||
severe: rgb(0.78, 0.2, 0.2),
|
||||
}
|
||||
|
||||
const SECTION_TEXT_SIZE = 10
|
||||
@@ -70,7 +76,7 @@ function countSegmentedLines(
|
||||
let x = 0
|
||||
for (let i = 0; i < items.length; i += 1) {
|
||||
const itemW = fonts.bodyRegular.widthOfTextAtSize(
|
||||
items[i],
|
||||
items[i]!,
|
||||
SECTION_TEXT_SIZE,
|
||||
)
|
||||
if (x + itemW > maxWidth && x > 0) {
|
||||
@@ -92,8 +98,7 @@ function countSegmentedLines(
|
||||
|
||||
/**
|
||||
* Renders a list of items separated by a visibly larger accent-coloured
|
||||
* bullet. Returns the cursor y *below* the last line drawn so the
|
||||
* caller can keep advancing the page cursor like a plain wrapLines run.
|
||||
* bullet. Returns the cursor y *below* the last line drawn.
|
||||
*/
|
||||
function drawSegmentedText(
|
||||
page: PDFPage,
|
||||
@@ -105,15 +110,11 @@ function drawSegmentedText(
|
||||
): number {
|
||||
if (items.length === 0) return startY - TEXT_LINE_HEIGHT
|
||||
const sepW = separatorWidth(fonts)
|
||||
// The bullet's larger size pushes its baseline above the surrounding
|
||||
// text. Shift it down a touch so it visually centers on the x-height
|
||||
// of the items it separates.
|
||||
const sepBaselineOffset = (SEPARATOR_SIZE - SECTION_TEXT_SIZE) * 0.3
|
||||
|
||||
let x = startX
|
||||
let y = startY
|
||||
for (let i = 0; i < items.length; i += 1) {
|
||||
const item = items[i]
|
||||
const item = items[i]!
|
||||
const itemW = fonts.bodyRegular.widthOfTextAtSize(item, SECTION_TEXT_SIZE)
|
||||
if (x + itemW > startX + maxWidth && x > startX) {
|
||||
x = startX
|
||||
@@ -150,22 +151,17 @@ const SVG_NS = 'http://www.w3.org/2000/svg'
|
||||
const HALO_FILTER_ID = 'osteo-halo'
|
||||
|
||||
/**
|
||||
* Adds a Gaussian-blur "halo" filter to the SVG defs the first time it
|
||||
* is called on a root. The filter widens the visible footprint of the
|
||||
* highlighted zones on the whole-animal view, where individual point
|
||||
* markers are otherwise tiny relative to the full body silhouette.
|
||||
* Adds a Gaussian-blur "halo" filter so the highlighted markers stay
|
||||
* visible on the whole-animal view once rasterised at print scale.
|
||||
*/
|
||||
function ensureHaloFilter(root: SVGSVGElement): void {
|
||||
const doc = root.ownerDocument
|
||||
if (!doc) return
|
||||
if (doc.getElementById(HALO_FILTER_ID)) return
|
||||
|
||||
if (root.querySelector(`#${HALO_FILTER_ID}`)) return
|
||||
let defs = root.querySelector('defs')
|
||||
if (!defs) {
|
||||
defs = doc.createElementNS(SVG_NS, 'defs')
|
||||
root.insertBefore(defs, root.firstChild)
|
||||
}
|
||||
|
||||
const filter = doc.createElementNS(SVG_NS, 'filter')
|
||||
filter.setAttribute('id', HALO_FILTER_ID)
|
||||
filter.setAttribute('x', '-100%')
|
||||
@@ -173,84 +169,63 @@ function ensureHaloFilter(root: SVGSVGElement): void {
|
||||
filter.setAttribute('width', '300%')
|
||||
filter.setAttribute('height', '300%')
|
||||
filter.setAttribute('filterUnits', 'userSpaceOnUse')
|
||||
|
||||
// Two-stage blur: a wide outer halo for "spotted from across the
|
||||
// room" visibility, plus a tighter inner halo that keeps the
|
||||
// selection anchored to the original point so it doesn't dissolve.
|
||||
const wide = doc.createElementNS(SVG_NS, 'feGaussianBlur')
|
||||
wide.setAttribute('in', 'SourceGraphic')
|
||||
wide.setAttribute('stdDeviation', '18')
|
||||
wide.setAttribute('result', 'haloWide')
|
||||
filter.appendChild(wide)
|
||||
|
||||
const tight = doc.createElementNS(SVG_NS, 'feGaussianBlur')
|
||||
tight.setAttribute('in', 'SourceGraphic')
|
||||
tight.setAttribute('stdDeviation', '8')
|
||||
tight.setAttribute('result', 'haloTight')
|
||||
filter.appendChild(tight)
|
||||
|
||||
const merge = doc.createElementNS(SVG_NS, 'feMerge')
|
||||
// Stack the wide halo three times so its contribution survives the
|
||||
// SVG → PNG → pdf-lib pipeline (each pass attenuates alpha) and
|
||||
// still reads as a strong glow at print scale.
|
||||
for (let i = 0; i < 3; i += 1) {
|
||||
for (const input of [
|
||||
'haloWide',
|
||||
'haloWide',
|
||||
'haloWide',
|
||||
'haloTight',
|
||||
'haloTight',
|
||||
'SourceGraphic',
|
||||
]) {
|
||||
const n = doc.createElementNS(SVG_NS, 'feMergeNode')
|
||||
n.setAttribute('in', 'haloWide')
|
||||
n.setAttribute('in', input)
|
||||
merge.appendChild(n)
|
||||
}
|
||||
for (let i = 0; i < 2; i += 1) {
|
||||
const n = doc.createElementNS(SVG_NS, 'feMergeNode')
|
||||
n.setAttribute('in', 'haloTight')
|
||||
merge.appendChild(n)
|
||||
}
|
||||
const source = doc.createElementNS(SVG_NS, 'feMergeNode')
|
||||
source.setAttribute('in', 'SourceGraphic')
|
||||
merge.appendChild(source)
|
||||
filter.appendChild(merge)
|
||||
|
||||
defs.appendChild(filter)
|
||||
}
|
||||
|
||||
async function colorizedSvgString(
|
||||
speciesSvgPath: string,
|
||||
/**
|
||||
* The view rendered from the sheet with the observation's zones of that
|
||||
* view highlighted (legacy picture: accent fill, halo on the main view,
|
||||
* other markers hidden, no data attributes left).
|
||||
*/
|
||||
export function highlightedViewSvg(
|
||||
sheet: SheetIndex,
|
||||
viewId: string,
|
||||
observation: Observation,
|
||||
sourceDetailId: string | undefined,
|
||||
): Promise<string> {
|
||||
const root = await loadSvg(speciesSvgPath)
|
||||
const bones = parseSvgBones(root)
|
||||
const selectedIds = new Set(
|
||||
): string {
|
||||
const selected = new Set(
|
||||
observation.zones
|
||||
.filter((z) => z.detailSourceId === sourceDetailId)
|
||||
.map((z) => z.boneId),
|
||||
.filter((z) => z.viewId === viewId)
|
||||
.map((z) => z.annotationId),
|
||||
)
|
||||
|
||||
// Whole-animal view: zone hitboxes are tiny markers on a big
|
||||
// silhouette, so we apply a blurred halo to make selections pop.
|
||||
// Detail views are already zoomed in and don't need it.
|
||||
const applyHalo = sourceDetailId === undefined
|
||||
const root = buildViewSvg(sheet, viewId, new Map())
|
||||
const applyHalo = sheet.view(viewId)?.kind === 'main'
|
||||
if (applyHalo) ensureHaloFilter(root)
|
||||
|
||||
bones.forEach((bone, id) => {
|
||||
const selected = selectedIds.has(id)
|
||||
bone.els.forEach((el) => {
|
||||
if (selected) {
|
||||
el.setAttribute('fill', '#b85a3f')
|
||||
el.setAttribute('fill-opacity', '0.85')
|
||||
if (applyHalo) {
|
||||
el.setAttribute('filter', `url(#${HALO_FILTER_ID})`)
|
||||
}
|
||||
} else {
|
||||
el.setAttribute('display', 'none')
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
root.querySelectorAll('[data-anno-id]').forEach((el) => {
|
||||
root.querySelectorAll<Element>('[data-anno-id]').forEach((el) => {
|
||||
if (selected.has(el.getAttribute('data-anno-id') ?? '')) {
|
||||
el.setAttribute('fill', '#b85a3f')
|
||||
el.setAttribute('fill-opacity', '0.85')
|
||||
if (applyHalo) el.setAttribute('filter', `url(#${HALO_FILTER_ID})`)
|
||||
} else {
|
||||
el.setAttribute('display', 'none')
|
||||
}
|
||||
Array.from(el.attributes)
|
||||
.filter((a) => a.name.startsWith('data-anno-'))
|
||||
.filter((a) => a.name.startsWith('data-'))
|
||||
.forEach((a) => el.removeAttribute(a.name))
|
||||
})
|
||||
|
||||
return new XMLSerializer().serializeToString(root)
|
||||
}
|
||||
|
||||
@@ -261,49 +236,40 @@ export interface ObservationPageContext {
|
||||
observation: Observation
|
||||
obsIndex: number
|
||||
fonts: EmbeddedFonts
|
||||
zoneLabels: Map<string, ZoneLabelPair>
|
||||
findingsTree: SpeciesFindings | null
|
||||
sheet: SheetIndex
|
||||
locale: Locale
|
||||
headerAssets: HeaderAssets
|
||||
}
|
||||
|
||||
/** Shared draw handles threaded through the observation-page sub-renderers. */
|
||||
interface PageDrawContext {
|
||||
page: PDFPage
|
||||
fonts: EmbeddedFonts
|
||||
width: number
|
||||
}
|
||||
|
||||
/** One rasterized anatomy view (main body or a detail popup) ready to embed. */
|
||||
interface RenderedImage {
|
||||
label: string
|
||||
img: PDFImage
|
||||
aspect: number
|
||||
}
|
||||
|
||||
/** One label/value block drawn under the images (zones, findings, comment...). */
|
||||
interface ObservationSection {
|
||||
label: string
|
||||
value: string
|
||||
}
|
||||
|
||||
/**
|
||||
* Draws the eyebrow, index/severity title, and accent rule for an
|
||||
* observation page. Returns titleY so callers can lay out the content
|
||||
* below it.
|
||||
*/
|
||||
function drawObservationTitleBlock(
|
||||
ctx: PageDrawContext,
|
||||
dict: Dict,
|
||||
obsIndex: number,
|
||||
severity: Observation['severity'],
|
||||
severity: Severity | undefined,
|
||||
): number {
|
||||
const { page, fonts } = ctx
|
||||
const { height } = page.getSize()
|
||||
const eyebrowY = height - EYEBROW_Y_OFFSET
|
||||
const titleY = height - TITLE_Y_OFFSET
|
||||
const obsLabel = String(obsIndex + 1).padStart(2, '0')
|
||||
page.drawText(dict['pdf.eyebrow.observation'], {
|
||||
page.drawText(dict['pdf.eyebrow.observation']!, {
|
||||
x: MARGIN_X,
|
||||
y: eyebrowY,
|
||||
size: 9,
|
||||
@@ -319,14 +285,11 @@ function drawObservationTitleBlock(
|
||||
})
|
||||
if (severity) {
|
||||
const numW = fonts.headingRegular.widthOfTextAtSize(obsLabel, 22)
|
||||
const sev = severity
|
||||
const sevLabel = dict[`severity.${sev}`] ?? sev
|
||||
const sevText = sevLabel.toUpperCase()
|
||||
const sevText = (dict[`severity.${severity}`] ?? severity).toUpperCase()
|
||||
const sevSize = 9
|
||||
const sevTextW = fonts.bodyBold.widthOfTextAtSize(sevText, sevSize)
|
||||
const padX = 8
|
||||
const padY = 4
|
||||
const pillW = sevTextW + padX * 2
|
||||
const pillW = fonts.bodyBold.widthOfTextAtSize(sevText, sevSize) + padX * 2
|
||||
const pillH = sevSize + padY * 2
|
||||
const pillX = MARGIN_X + numW + 14
|
||||
const pillY = titleY + 4
|
||||
@@ -335,7 +298,7 @@ function drawObservationTitleBlock(
|
||||
y: pillY,
|
||||
width: pillW,
|
||||
height: pillH,
|
||||
color: SEVERITY_BG[sev] ?? COLOR_MUTED,
|
||||
color: SEVERITY_BG[severity] ?? COLOR_MUTED,
|
||||
})
|
||||
page.drawText(sevText, {
|
||||
x: pillX + padX,
|
||||
@@ -354,100 +317,97 @@ function drawObservationTitleBlock(
|
||||
return titleY
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolves the main-body view plus every detail-popup view referenced by
|
||||
* the observation, rasterizing each to a PNG ready for pdf-lib.
|
||||
*/
|
||||
/** Every view the observation touches, main first, each rasterised with its highlights. */
|
||||
async function buildObservationImages(
|
||||
pdfDoc: PDFDocument,
|
||||
species: SpeciesManifest,
|
||||
sheet: SheetIndex,
|
||||
observation: Observation,
|
||||
locale: Locale,
|
||||
dict: Dict,
|
||||
): Promise<RenderedImage[]> {
|
||||
const hasMainZones = observation.zones.some((z) => !z.detailSourceId)
|
||||
const detailIds = Array.from(
|
||||
new Set(observation.zones.map((z) => z.detailSourceId).filter(Boolean) as string[]),
|
||||
)
|
||||
|
||||
const items: Array<{ label: string; src: string; sourceId: string | undefined }> = []
|
||||
if (hasMainZones) {
|
||||
items.push({ label: dict['pdf.view.general'], src: species.mainSvg, sourceId: undefined })
|
||||
}
|
||||
for (const detailId of detailIds) {
|
||||
const detailPath = species.details[detailId]
|
||||
if (!detailPath) continue
|
||||
items.push({
|
||||
label: `${dict['pdf.view.detail_prefix']}${detailId.toUpperCase()}`,
|
||||
src: detailPath,
|
||||
sourceId: detailId,
|
||||
})
|
||||
}
|
||||
|
||||
const viewIds = [...new Set(observation.zones.map((z) => z.viewId))]
|
||||
.filter((id) => sheet.view(id))
|
||||
.sort(
|
||||
(a, b) =>
|
||||
Number(b === sheet.mainView.id) - Number(a === sheet.mainView.id),
|
||||
)
|
||||
return Promise.all(
|
||||
items.map(async (it) => {
|
||||
const svgStr = await colorizedSvgString(it.src, observation, it.sourceId)
|
||||
const png = await rasterizeSvg(svgStr)
|
||||
viewIds.map(async (viewId) => {
|
||||
const view = sheet.view(viewId)!
|
||||
const label =
|
||||
view.kind === 'main'
|
||||
? dict['pdf.view.general']!
|
||||
: `${dict['pdf.view.detail_prefix']}${pickLabel(view.name, locale).toUpperCase()}`
|
||||
const png = await rasterizeSvg(
|
||||
highlightedViewSvg(sheet, viewId, observation),
|
||||
)
|
||||
const img = await pdfDoc.embedPng(png)
|
||||
const aspect = img.width > 0 ? img.height / img.width : 0.6
|
||||
return { label: it.label, img, aspect }
|
||||
return {
|
||||
label,
|
||||
img,
|
||||
aspect: img.width > 0 ? img.height / img.width : 0.6,
|
||||
}
|
||||
}),
|
||||
)
|
||||
}
|
||||
|
||||
/** Renders the "Zones" section value: bilingual labels + vertebra/side suffixes. */
|
||||
function zoneText(z: ReportZone, sheet: SheetIndex, locale: Locale): string {
|
||||
const annotation = sheet.annotation(z.annotationId)
|
||||
if (annotation) return pickLabel(sheet.name(annotation), locale)
|
||||
const snapshot =
|
||||
locale === 'en'
|
||||
? z.labelEnSnapshot || z.labelFrSnapshot
|
||||
: z.labelFrSnapshot || z.labelEnSnapshot
|
||||
return snapshot || z.annotationId
|
||||
}
|
||||
|
||||
function describeObservationZones(
|
||||
zones: Observation['zones'],
|
||||
zoneLabels: Map<string, ZoneLabelPair>,
|
||||
zones: ReportZone[],
|
||||
sheet: SheetIndex,
|
||||
locale: Locale,
|
||||
dict: Dict,
|
||||
): string {
|
||||
return zones
|
||||
.map((z) => {
|
||||
const pair = zoneLabels.get(z.boneId)
|
||||
const label = pickLocaleLabel(pair?.fr, pair?.en, locale, z.boneId)
|
||||
const v = z.vertebrae?.length
|
||||
? ` (${z.vertebrae.map((x) => `${x.region}${x.index}`).join(', ')})`
|
||||
: ''
|
||||
const side = z.side
|
||||
? ` (${dict[z.side === 'left' ? 'lateral.left' : 'lateral.right']})`
|
||||
: ''
|
||||
return `${label}${v}${side}`
|
||||
return `${zoneText(z, sheet, locale)}${v}${side}`
|
||||
})
|
||||
.join(' · ')
|
||||
}
|
||||
|
||||
/** Groups findings by zone+side, one label/value section entry per group. */
|
||||
function findingZoneName(
|
||||
zoneId: string,
|
||||
sheet: SheetIndex,
|
||||
locale: Locale,
|
||||
): string {
|
||||
const zone = sheet.findingZone(zoneId)
|
||||
return zone ? pickLabel(zone.name, locale) : zoneId
|
||||
}
|
||||
|
||||
/** Groups findings by zone+side, one section per group; snapshots give the text. */
|
||||
function buildFindingsSections(
|
||||
findings: Finding[],
|
||||
findingsTree: SpeciesFindings | null,
|
||||
sheet: SheetIndex,
|
||||
locale: Locale,
|
||||
dict: Dict,
|
||||
): ObservationSection[] {
|
||||
const byZoneSide = new Map<string, Finding[]>()
|
||||
for (const f of findings) {
|
||||
const key = f.side ? `${f.zoneId}:${f.side}` : f.zoneId
|
||||
const list = byZoneSide.get(key)
|
||||
if (list) {
|
||||
list.push(f)
|
||||
} else {
|
||||
byZoneSide.set(key, [f])
|
||||
}
|
||||
const key = f.side ? `${f.findingZoneId}:${f.side}` : f.findingZoneId
|
||||
byZoneSide.set(key, [...(byZoneSide.get(key) ?? []), f])
|
||||
}
|
||||
|
||||
const sections: ObservationSection[] = []
|
||||
for (const [key, group] of byZoneSide) {
|
||||
const zoneId = key.split(':')[0]
|
||||
const zoneId = key.split(':')[0]!
|
||||
const side = group[0]?.side
|
||||
const zoneTree = findingsTree?.zones[zoneId]
|
||||
let zoneName = zoneTree
|
||||
? locale === 'en'
|
||||
? zoneTree.name_en
|
||||
: zoneTree.name_fr
|
||||
: zoneId
|
||||
if (side) {
|
||||
const sideLabel = dict[side === 'left' ? 'lateral.left' : 'lateral.right']
|
||||
zoneName = `${zoneName} (${sideLabel})`
|
||||
}
|
||||
let zoneName = findingZoneName(zoneId, sheet, locale)
|
||||
if (side)
|
||||
zoneName = `${zoneName} (${dict[side === 'left' ? 'lateral.left' : 'lateral.right']})`
|
||||
const value = group
|
||||
.map((f) => {
|
||||
const lbl = locale === 'en' ? f.labelEnSnapshot : f.labelFrSnapshot
|
||||
@@ -462,37 +422,46 @@ function buildFindingsSections(
|
||||
return sections
|
||||
}
|
||||
|
||||
/** Assembles the ordered label/value sections drawn below the images. */
|
||||
function buildObservationSections(
|
||||
observation: Observation,
|
||||
zoneLabels: Map<string, ZoneLabelPair>,
|
||||
findingsTree: SpeciesFindings | null,
|
||||
sheet: SheetIndex,
|
||||
locale: Locale,
|
||||
dict: Dict,
|
||||
): ObservationSection[] {
|
||||
const zonesText = describeObservationZones(observation.zones, zoneLabels, locale, dict)
|
||||
const zonesText = describeObservationZones(
|
||||
observation.zones,
|
||||
sheet,
|
||||
locale,
|
||||
dict,
|
||||
)
|
||||
const sections: ObservationSection[] = [
|
||||
{ label: dict['pdf.section.zones'], value: zonesText || dict['pdf.empty'] },
|
||||
{
|
||||
label: dict['pdf.section.zones']!,
|
||||
value: zonesText || dict['pdf.empty']!,
|
||||
},
|
||||
...buildFindingsSections(observation.findings, sheet, locale, dict),
|
||||
]
|
||||
sections.push(...buildFindingsSections(observation.findings, findingsTree, locale, dict))
|
||||
|
||||
if (observation.freeTextFindings.length) {
|
||||
sections.push({
|
||||
label: dict['pdf.section.free_findings'],
|
||||
label: dict['pdf.section.free_findings']!,
|
||||
value: observation.freeTextFindings.join(' · '),
|
||||
})
|
||||
}
|
||||
if (observation.severity) {
|
||||
const sevLabel = dict[`severity.${observation.severity}`] ?? observation.severity
|
||||
sections.push({ label: dict['pdf.section.severity'], value: sevLabel })
|
||||
sections.push({
|
||||
label: dict['pdf.section.severity']!,
|
||||
value: dict[`severity.${observation.severity}`] ?? observation.severity,
|
||||
})
|
||||
}
|
||||
if (observation.comment.trim()) {
|
||||
sections.push({ label: dict['pdf.section.comment'], value: observation.comment.trim() })
|
||||
sections.push({
|
||||
label: dict['pdf.section.comment']!,
|
||||
value: observation.comment.trim(),
|
||||
})
|
||||
}
|
||||
return sections
|
||||
}
|
||||
|
||||
/** Estimates the vertical space the given sections will occupy once drawn. */
|
||||
function estimateSectionsHeight(
|
||||
sections: ObservationSection[],
|
||||
fonts: EmbeddedFonts,
|
||||
@@ -503,16 +472,13 @@ function estimateSectionsHeight(
|
||||
const lineCount = value.includes(' · ')
|
||||
? countSegmentedLines(value.split(' · '), fonts, maxTextW)
|
||||
: wrapLines(value, fonts.bodyRegular, SECTION_TEXT_SIZE, maxTextW).length
|
||||
h += SECTION_LABEL_GAP + 9 + lineCount * TEXT_LINE_HEIGHT + SECTION_BLOCK_GAP
|
||||
h +=
|
||||
SECTION_LABEL_GAP + 9 + lineCount * TEXT_LINE_HEIGHT + SECTION_BLOCK_GAP
|
||||
}
|
||||
return h
|
||||
}
|
||||
|
||||
/**
|
||||
* Lays out and draws the (up to 2-column) image grid for an observation
|
||||
* page. Returns the cursor y directly below the images — unchanged from
|
||||
* startY when there is nothing to draw.
|
||||
*/
|
||||
/** Lays out the (up to 2-column) image grid; returns the cursor y below it. */
|
||||
function drawObservationImageGrid(
|
||||
ctx: PageDrawContext,
|
||||
rendered: RenderedImage[],
|
||||
@@ -522,14 +488,10 @@ function drawObservationImageGrid(
|
||||
const { page, fonts, width } = ctx
|
||||
let cursorY = startY
|
||||
if (rendered.length === 0) return cursorY
|
||||
|
||||
const isSingle = rendered.length === 1
|
||||
const cols = isSingle ? 1 : 2
|
||||
const rows = Math.ceil(rendered.length / cols)
|
||||
const fullCellW = (width - MARGIN_X * 2 - IMAGE_COL_GAP * (cols - 1)) / cols
|
||||
// Single-image observations get rendered at half the available width
|
||||
// and centered, so they don't dominate the page when the surrounding
|
||||
// text is short.
|
||||
const cellW = isSingle ? fullCellW / 2 : fullCellW
|
||||
const singleOffsetX = isSingle ? (fullCellW - cellW) / 2 : 0
|
||||
const availH = Math.max(IMAGE_MIN_CELL_H, cursorY - reservedBottom)
|
||||
@@ -537,7 +499,6 @@ function drawObservationImageGrid(
|
||||
IMAGE_MIN_CELL_H,
|
||||
(availH - rows * IMAGE_LABEL_GAP - (rows - 1) * IMAGE_ROW_GAP) / rows,
|
||||
)
|
||||
|
||||
for (let r = 0; r < rows; r += 1) {
|
||||
const rowItems = rendered.slice(r * cols, r * cols + cols)
|
||||
const cellHs = rowItems.map((it) => Math.min(cellW * it.aspect, rowBudget))
|
||||
@@ -557,9 +518,9 @@ function drawObservationImageGrid(
|
||||
const x = MARGIN_X + singleOffsetX + c * (cellW + IMAGE_COL_GAP)
|
||||
page.drawImage(it.img, {
|
||||
x,
|
||||
y: cursorY - cellHs[c],
|
||||
y: cursorY - cellHs[c]!,
|
||||
width: cellW,
|
||||
height: cellHs[c],
|
||||
height: cellHs[c]!,
|
||||
})
|
||||
})
|
||||
cursorY -= rowH
|
||||
@@ -569,7 +530,6 @@ function drawObservationImageGrid(
|
||||
return cursorY
|
||||
}
|
||||
|
||||
/** Draws each label/value section, returns the cursor y below the last one. */
|
||||
function drawObservationSections(
|
||||
ctx: PageDrawContext,
|
||||
sections: ObservationSection[],
|
||||
@@ -597,8 +557,12 @@ function drawObservationSections(
|
||||
fonts,
|
||||
)
|
||||
} else {
|
||||
const lines = wrapLines(value, fonts.bodyRegular, SECTION_TEXT_SIZE, maxTextW)
|
||||
for (const line of lines) {
|
||||
for (const line of wrapLines(
|
||||
value,
|
||||
fonts.bodyRegular,
|
||||
SECTION_TEXT_SIZE,
|
||||
maxTextW,
|
||||
)) {
|
||||
page.drawText(line, {
|
||||
x: MARGIN_X,
|
||||
y: cursorY,
|
||||
@@ -623,8 +587,7 @@ export async function addObservationPage(
|
||||
observation,
|
||||
obsIndex,
|
||||
fonts,
|
||||
zoneLabels,
|
||||
findingsTree,
|
||||
sheet,
|
||||
locale,
|
||||
headerAssets,
|
||||
} = ctx
|
||||
@@ -634,18 +597,31 @@ export async function addObservationPage(
|
||||
drawHeader(page, report, fonts, locale, headerAssets)
|
||||
|
||||
const drawCtx: PageDrawContext = { page, fonts, width }
|
||||
const titleY = drawObservationTitleBlock(drawCtx, dict, obsIndex, observation.severity)
|
||||
|
||||
const species = getSpecies(report.animal.speciesId)
|
||||
if (!species) return
|
||||
|
||||
const rendered = await buildObservationImages(pdfDoc, species, observation, dict)
|
||||
|
||||
const titleY = drawObservationTitleBlock(
|
||||
drawCtx,
|
||||
dict,
|
||||
obsIndex,
|
||||
observation.severity,
|
||||
)
|
||||
const rendered = await buildObservationImages(
|
||||
pdfDoc,
|
||||
sheet,
|
||||
observation,
|
||||
locale,
|
||||
dict,
|
||||
)
|
||||
const maxTextW = width - MARGIN_X * 2
|
||||
const sections = buildObservationSections(observation, zoneLabels, findingsTree, locale, dict)
|
||||
const reservedBottom = MARGIN_BOTTOM + estimateSectionsHeight(sections, fonts, maxTextW) + IMAGE_BOTTOM_GAP
|
||||
|
||||
let cursorY = drawObservationImageGrid(drawCtx, rendered, titleY - IMAGE_TOP_GAP, reservedBottom)
|
||||
const sections = buildObservationSections(observation, sheet, locale, dict)
|
||||
const reservedBottom =
|
||||
MARGIN_BOTTOM +
|
||||
estimateSectionsHeight(sections, fonts, maxTextW) +
|
||||
IMAGE_BOTTOM_GAP
|
||||
let cursorY = drawObservationImageGrid(
|
||||
drawCtx,
|
||||
rendered,
|
||||
titleY - IMAGE_TOP_GAP,
|
||||
reservedBottom,
|
||||
)
|
||||
cursorY -= TEXT_TOP_GAP
|
||||
drawObservationSections(drawCtx, sections, cursorY, maxTextW)
|
||||
}
|
||||
@@ -22,7 +22,8 @@ function ensureSvgAttributes(
|
||||
root.setAttribute('xmlns', 'http://www.w3.org/2000/svg')
|
||||
}
|
||||
if (!root.getAttribute('width')) root.setAttribute('width', String(widthPx))
|
||||
if (!root.getAttribute('height')) root.setAttribute('height', String(heightPx))
|
||||
if (!root.getAttribute('height'))
|
||||
root.setAttribute('height', String(heightPx))
|
||||
return new XMLSerializer().serializeToString(root)
|
||||
}
|
||||
|
||||
@@ -77,7 +78,9 @@ async function rasterizeWithImageElement(
|
||||
return canvas
|
||||
}
|
||||
|
||||
async function canvasToPngBytes(canvas: HTMLCanvasElement): Promise<Uint8Array> {
|
||||
async function canvasToPngBytes(
|
||||
canvas: HTMLCanvasElement,
|
||||
): Promise<Uint8Array> {
|
||||
const blob = await new Promise<Blob | null>((resolve) => {
|
||||
canvas.toBlob((b) => resolve(b), 'image/png')
|
||||
})
|
||||
|
||||
@@ -0,0 +1,113 @@
|
||||
import type {
|
||||
Annotation,
|
||||
FindingCategory,
|
||||
FindingNode,
|
||||
FindingZone,
|
||||
LocalizedText,
|
||||
SheetView,
|
||||
VertebralRegion,
|
||||
} from '@faunosteo/domain'
|
||||
import type { Locale } from '@/i18n/types'
|
||||
import type { LoadedSheet } from '@/sheets/provider'
|
||||
|
||||
/**
|
||||
* Read-only lookups over a loaded sheet. Everything the editor used to derive
|
||||
* from SVG attributes, label matching or the species manifest comes from the
|
||||
* document here, by stable id: no label drives logic.
|
||||
*/
|
||||
|
||||
export type ObservableAnnotation = Extract<
|
||||
Annotation,
|
||||
{ kind: 'point' | 'zone' }
|
||||
>
|
||||
|
||||
export interface SheetIndex {
|
||||
sheet: LoadedSheet
|
||||
mainView: SheetView
|
||||
view(id: string): SheetView | undefined
|
||||
annotation(id: string): Annotation | undefined
|
||||
annotationsOfView(viewId: string): Annotation[]
|
||||
findingZone(id: string): FindingZone | undefined
|
||||
/** The category or node at a path, undefined when absent from the sheet. */
|
||||
nodeAt(
|
||||
zoneId: string,
|
||||
path: readonly string[],
|
||||
): FindingCategory | FindingNode | undefined
|
||||
regions(): VertebralRegion[]
|
||||
region(code: string): VertebralRegion | undefined
|
||||
/** The annotation that opens the vertebra picker for a region on a view. */
|
||||
spineAnnotation(
|
||||
regionCode: string,
|
||||
viewId: string,
|
||||
): ObservableAnnotation | undefined
|
||||
/** Whether an annotation opens the vertebra picker. */
|
||||
isSpine(annotationId: string): boolean
|
||||
name(annotation: Annotation): LocalizedText
|
||||
}
|
||||
|
||||
export function pickLabel(
|
||||
text: LocalizedText | null | undefined,
|
||||
locale: Locale,
|
||||
): string {
|
||||
if (!text) return ''
|
||||
return locale === 'en' ? text.en || text.fr : text.fr || text.en
|
||||
}
|
||||
|
||||
export function isObservable(
|
||||
a: Annotation | undefined,
|
||||
): a is ObservableAnnotation {
|
||||
return a !== undefined && a.kind !== 'detail_trigger'
|
||||
}
|
||||
|
||||
export function buildSheetIndex(sheet: LoadedSheet): SheetIndex {
|
||||
const { document } = sheet
|
||||
const views = new Map(document.views.map((v) => [v.id, v]))
|
||||
const annotations = new Map(document.annotations.map((a) => [a.id, a]))
|
||||
const zones = new Map(document.finding_zones.map((z) => [z.id, z]))
|
||||
const regions = new Map(
|
||||
document.vertebral_config.regions.map((r) => [r.code, r]),
|
||||
)
|
||||
const mainView = document.views.find((v) => v.kind === 'main')
|
||||
if (!mainView) throw new Error('sheet has no main view')
|
||||
|
||||
const nodeAt: SheetIndex['nodeAt'] = (zoneId, path) => {
|
||||
const zone = zones.get(zoneId)
|
||||
if (!zone || path.length === 0) return undefined
|
||||
let node: FindingCategory | FindingNode | undefined = zone.categories.find(
|
||||
(c) => c.id === path[0],
|
||||
)
|
||||
for (const segment of path.slice(1)) {
|
||||
if (!node) return undefined
|
||||
node = node.children.find((n) => n.id === segment)
|
||||
}
|
||||
return node
|
||||
}
|
||||
|
||||
return {
|
||||
sheet,
|
||||
mainView,
|
||||
view: (id) => views.get(id),
|
||||
annotation: (id) => annotations.get(id),
|
||||
annotationsOfView: (viewId) =>
|
||||
document.annotations.filter((a) => a.view_id === viewId),
|
||||
findingZone: (id) => zones.get(id),
|
||||
nodeAt,
|
||||
regions: () => document.vertebral_config.regions,
|
||||
region: (code) => regions.get(code),
|
||||
spineAnnotation: (code, viewId) =>
|
||||
document.annotations.find(
|
||||
(a): a is ObservableAnnotation =>
|
||||
isObservable(a) &&
|
||||
a.view_id === viewId &&
|
||||
a.vertebral_region_code === code,
|
||||
),
|
||||
isSpine: (id) => {
|
||||
const a = annotations.get(id)
|
||||
return isObservable(a) && a.vertebral_region_code !== null
|
||||
},
|
||||
name: (a) =>
|
||||
a.kind === 'detail_trigger'
|
||||
? (a.name ?? views.get(a.opens_view_id)?.name ?? { fr: '', en: '' })
|
||||
: a.name,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,213 @@
|
||||
import type {
|
||||
Annotation,
|
||||
LateralSide,
|
||||
Observation,
|
||||
ReportZone,
|
||||
Vertebra,
|
||||
} from '@faunosteo/domain'
|
||||
import { isObservable, type SheetIndex } from './sheetIndex'
|
||||
|
||||
/**
|
||||
* Zone interaction rules of the report editor, pure: what a click on an
|
||||
* annotation means for the active observation, and the observation
|
||||
* reducers the route applies. The rules are the legacy ones (click chain
|
||||
* of EditorRoute, BDR-019 vertebra sync), keyed by annotation ids.
|
||||
*/
|
||||
|
||||
export interface ZoneRef {
|
||||
annotationId: string
|
||||
viewId: string
|
||||
}
|
||||
|
||||
export type ZoneClickDecision =
|
||||
| { kind: 'ignore' }
|
||||
| { kind: 'open_view'; viewId: string }
|
||||
| { kind: 'activate_fallback' }
|
||||
| { kind: 'open_vertebra_picker' }
|
||||
| { kind: 'open_laterality_picker' }
|
||||
| { kind: 'remove_both_sides' }
|
||||
| { kind: 'toggle' }
|
||||
|
||||
export function sameZone(zone: ReportZone, ref: ZoneRef): boolean {
|
||||
return zone.annotationId === ref.annotationId && zone.viewId === ref.viewId
|
||||
}
|
||||
|
||||
export function refOf(annotation: Annotation): ZoneRef {
|
||||
return { annotationId: annotation.id, viewId: annotation.view_id }
|
||||
}
|
||||
|
||||
export function sidesPresent(obs: Observation, ref: ZoneRef): LateralSide[] {
|
||||
return obs.zones
|
||||
.filter((z) => sameZone(z, ref) && z.side)
|
||||
.map((z) => z.side as LateralSide)
|
||||
}
|
||||
|
||||
/**
|
||||
* Legacy click chain: detail trigger opens its view and is never added; no
|
||||
* active observation → the click only activates one; spine zones always open
|
||||
* the picker; bilateral zones go through the side picker, or clear both sides
|
||||
* when both are set; anything else toggles.
|
||||
*/
|
||||
export function decideZoneClick(
|
||||
annotation: Annotation | undefined,
|
||||
active: Observation | undefined,
|
||||
): ZoneClickDecision {
|
||||
if (!annotation) return { kind: 'ignore' }
|
||||
if (annotation.kind === 'detail_trigger') {
|
||||
return { kind: 'open_view', viewId: annotation.opens_view_id }
|
||||
}
|
||||
if (!active) return { kind: 'activate_fallback' }
|
||||
if (annotation.vertebral_region_code !== null) {
|
||||
return { kind: 'open_vertebra_picker' }
|
||||
}
|
||||
if (annotation.laterality === 'bilateral') {
|
||||
const sides = sidesPresent(active, refOf(annotation))
|
||||
return sides.includes('left') && sides.includes('right')
|
||||
? { kind: 'remove_both_sides' }
|
||||
: { kind: 'open_laterality_picker' }
|
||||
}
|
||||
return { kind: 'toggle' }
|
||||
}
|
||||
|
||||
function newZone(annotation: Annotation, side?: LateralSide): ReportZone {
|
||||
const zone: ReportZone = refOf(annotation)
|
||||
if (isObservable(annotation)) {
|
||||
zone.labelFrSnapshot = annotation.name.fr
|
||||
zone.labelEnSnapshot = annotation.name.en
|
||||
}
|
||||
if (side) zone.side = side
|
||||
return zone
|
||||
}
|
||||
|
||||
function withZones(obs: Observation, zones: ReportZone[]): Observation {
|
||||
return { ...obs, zones }
|
||||
}
|
||||
|
||||
/** Plain zone: added when absent, removed when present (no side). */
|
||||
export function toggleZone(
|
||||
obs: Observation,
|
||||
annotation: Annotation,
|
||||
): Observation {
|
||||
const index = obs.zones.findIndex((z) => sameZone(z, refOf(annotation)))
|
||||
if (index >= 0)
|
||||
return withZones(
|
||||
obs,
|
||||
obs.zones.filter((_, i) => i !== index),
|
||||
)
|
||||
return withZones(obs, [...obs.zones, newZone(annotation)])
|
||||
}
|
||||
|
||||
/** The zone exists after the call; returns its index. */
|
||||
export function ensureZone(
|
||||
obs: Observation,
|
||||
annotation: Annotation,
|
||||
): { observation: Observation; index: number } {
|
||||
const index = obs.zones.findIndex((z) => sameZone(z, refOf(annotation)))
|
||||
if (index >= 0) return { observation: obs, index }
|
||||
const zones = [...obs.zones, newZone(annotation)]
|
||||
return { observation: withZones(obs, zones), index: zones.length - 1 }
|
||||
}
|
||||
|
||||
/** Appends the sides not present yet; never removes one (legacy semantics). */
|
||||
export function addSides(
|
||||
obs: Observation,
|
||||
annotation: Annotation,
|
||||
sides: readonly LateralSide[],
|
||||
): Observation {
|
||||
const present = sidesPresent(obs, refOf(annotation))
|
||||
const added = sides
|
||||
.filter((side) => !present.includes(side))
|
||||
.map((side) => newZone(annotation, side))
|
||||
return added.length === 0 ? obs : withZones(obs, [...obs.zones, ...added])
|
||||
}
|
||||
|
||||
export function removeAllSides(obs: Observation, ref: ZoneRef): Observation {
|
||||
return withZones(
|
||||
obs,
|
||||
obs.zones.filter((z) => !sameZone(z, ref)),
|
||||
)
|
||||
}
|
||||
|
||||
export function removeZoneAt(obs: Observation, index: number): Observation {
|
||||
return withZones(
|
||||
obs,
|
||||
obs.zones.filter((_, i) => i !== index),
|
||||
)
|
||||
}
|
||||
|
||||
function isSpineZone(zone: ReportZone, index: SheetIndex): boolean {
|
||||
return index.isSpine(zone.annotationId)
|
||||
}
|
||||
|
||||
/**
|
||||
* Vertebrae of every spine zone of the observation, the zone at `priority`
|
||||
* first (the one the picker was opened from), without duplicates.
|
||||
*/
|
||||
export function collectVertebrae(
|
||||
obs: Observation,
|
||||
index: SheetIndex,
|
||||
priority: number,
|
||||
): Vertebra[] {
|
||||
const ordered = [
|
||||
...obs.zones.filter((_, i) => i === priority),
|
||||
...obs.zones.filter((_, i) => i !== priority),
|
||||
]
|
||||
const seen = new Set<string>()
|
||||
const out: Vertebra[] = []
|
||||
for (const zone of ordered) {
|
||||
if (!isSpineZone(zone, index)) continue
|
||||
for (const v of zone.vertebrae ?? []) {
|
||||
const key = `${v.region}${v.index}`
|
||||
if (seen.has(key)) continue
|
||||
seen.add(key)
|
||||
out.push({ ...v })
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
function regionOf(zone: ReportZone, index: SheetIndex): string | null {
|
||||
const a = index.annotation(zone.annotationId)
|
||||
return isObservable(a) ? a.vertebral_region_code : null
|
||||
}
|
||||
|
||||
/**
|
||||
* BDR-019: the picker edits every region at once. Per region the selection
|
||||
* REPLACES the zone's vertebrae; a spine zone left without vertebrae is
|
||||
* pruned; a region picked without a zone gets one on the view the picker
|
||||
* was opened from (or the main view).
|
||||
*/
|
||||
export function syncVertebrae(
|
||||
obs: Observation,
|
||||
selection: readonly Vertebra[],
|
||||
index: SheetIndex,
|
||||
viewId: string,
|
||||
): Observation {
|
||||
const byRegion = new Map<string, Vertebra[]>()
|
||||
for (const v of selection) {
|
||||
const list = byRegion.get(v.region) ?? []
|
||||
list.push({ ...v })
|
||||
byRegion.set(v.region, list)
|
||||
}
|
||||
const kept: ReportZone[] = []
|
||||
for (const zone of obs.zones) {
|
||||
const region = isSpineZone(zone, index) ? regionOf(zone, index) : null
|
||||
if (region === null) {
|
||||
kept.push(zone)
|
||||
continue
|
||||
}
|
||||
const picked = byRegion.get(region)
|
||||
byRegion.delete(region)
|
||||
if (!picked || picked.length === 0) continue
|
||||
kept.push({ ...zone, vertebrae: picked })
|
||||
}
|
||||
for (const [region, picked] of byRegion) {
|
||||
if (picked.length === 0) continue
|
||||
const annotation =
|
||||
index.spineAnnotation(region, viewId) ??
|
||||
index.spineAnnotation(region, index.mainView.id)
|
||||
if (!annotation) continue
|
||||
kept.push({ ...newZone(annotation), vertebrae: picked })
|
||||
}
|
||||
return withZones(obs, kept)
|
||||
}
|
||||
@@ -0,0 +1,83 @@
|
||||
import {
|
||||
AnatomicalSheetDocumentSchema,
|
||||
ReportMigrationMapSchema,
|
||||
type AnatomicalSheetDocument,
|
||||
type ReportMigrationMap,
|
||||
type SheetRef,
|
||||
} from '@faunosteo/domain'
|
||||
|
||||
/**
|
||||
* Where the application gets the anatomical sheet it works on. Step 5 ships
|
||||
* one implementation, the sheet bundled at build time (virtual module, see
|
||||
* vite/sheet-bundle.ts); the Supabase implementation of Step 13 sits behind
|
||||
* the same interface. A loaded sheet is immutable for the session.
|
||||
*/
|
||||
|
||||
export type SheetStatus = 'draft' | 'published'
|
||||
|
||||
/** Raw payload of the virtual module, validated here before use. */
|
||||
export interface BundledSheetData {
|
||||
status: SheetStatus
|
||||
ref: {
|
||||
sheet_id: string
|
||||
version_id: string | null
|
||||
document_sha256: string
|
||||
schema_version: number
|
||||
species_id: string
|
||||
}
|
||||
document: unknown
|
||||
migrationMap: unknown
|
||||
assets: Record<string, string>
|
||||
}
|
||||
|
||||
export interface LoadedSheet {
|
||||
status: SheetStatus
|
||||
ref: SheetRef
|
||||
speciesId: string
|
||||
document: AnatomicalSheetDocument
|
||||
/** SVG text by `svg_asset_id`. */
|
||||
assets: Readonly<Record<string, string>>
|
||||
migrationMap: ReportMigrationMap
|
||||
}
|
||||
|
||||
export interface SheetProvider {
|
||||
/** The reference sheet of a species, or null when none is available. */
|
||||
getReferenceSheet(speciesId: string): Promise<LoadedSheet | null>
|
||||
}
|
||||
|
||||
export function parseBundledSheet(data: BundledSheetData): LoadedSheet {
|
||||
const document = AnatomicalSheetDocumentSchema.parse(data.document)
|
||||
const migrationMap = ReportMigrationMapSchema.parse(data.migrationMap)
|
||||
return {
|
||||
status: data.status,
|
||||
ref: {
|
||||
sheetId: data.ref.sheet_id,
|
||||
versionId: data.ref.version_id,
|
||||
documentSha256: data.ref.document_sha256,
|
||||
},
|
||||
speciesId: data.ref.species_id,
|
||||
document,
|
||||
assets: data.assets,
|
||||
migrationMap,
|
||||
}
|
||||
}
|
||||
|
||||
let cached: Promise<LoadedSheet | null> | null = null
|
||||
|
||||
async function loadBundled(): Promise<LoadedSheet | null> {
|
||||
const mod = await import('virtual:faunosteo-sheet')
|
||||
return mod.bundledSheet ? parseBundledSheet(mod.bundledSheet) : null
|
||||
}
|
||||
|
||||
export const bundledSheetProvider: SheetProvider = {
|
||||
async getReferenceSheet(speciesId) {
|
||||
cached ??= loadBundled()
|
||||
const sheet = await cached
|
||||
return sheet && sheet.speciesId === speciesId ? sheet : null
|
||||
},
|
||||
}
|
||||
|
||||
/** Test seam: forget the memoised bundle. */
|
||||
export function resetBundledSheetCache(): void {
|
||||
cached = null
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
import { useEffect, useState } from 'react'
|
||||
import { buildSheetIndex, type SheetIndex } from '@/services/sheetIndex'
|
||||
import { bundledSheetProvider, type SheetProvider } from './provider'
|
||||
|
||||
/**
|
||||
* The reference sheet of a species for the current session, loaded once
|
||||
* through the provider and indexed. `none` means the build carries no sheet
|
||||
* (production bundle without SHEET_BUNDLE=draft) or no sheet for the species.
|
||||
*/
|
||||
|
||||
export type SheetState =
|
||||
| { status: 'loading' }
|
||||
| { status: 'none' }
|
||||
| { status: 'ready'; index: SheetIndex }
|
||||
|
||||
let provider: SheetProvider = bundledSheetProvider
|
||||
const cache = new Map<string, Promise<SheetIndex | null>>()
|
||||
|
||||
/** Test seam: swap the provider and forget loaded sheets. */
|
||||
export function setSheetProvider(next: SheetProvider): void {
|
||||
provider = next
|
||||
cache.clear()
|
||||
}
|
||||
|
||||
export function loadSheetIndex(speciesId: string): Promise<SheetIndex | null> {
|
||||
let pending = cache.get(speciesId)
|
||||
if (!pending) {
|
||||
pending = provider
|
||||
.getReferenceSheet(speciesId)
|
||||
.then((sheet) => (sheet ? buildSheetIndex(sheet) : null))
|
||||
cache.set(speciesId, pending)
|
||||
}
|
||||
return pending
|
||||
}
|
||||
|
||||
export function useSheet(speciesId: string | undefined): SheetState {
|
||||
const [state, setState] = useState<SheetState>({ status: 'loading' })
|
||||
useEffect(() => {
|
||||
let cancelled = false
|
||||
if (!speciesId) {
|
||||
setState({ status: 'none' })
|
||||
return
|
||||
}
|
||||
setState({ status: 'loading' })
|
||||
loadSheetIndex(speciesId).then((index) => {
|
||||
if (cancelled) return
|
||||
setState(index ? { status: 'ready', index } : { status: 'none' })
|
||||
})
|
||||
return () => {
|
||||
cancelled = true
|
||||
}
|
||||
}, [speciesId])
|
||||
return state
|
||||
}
|
||||
+3
@@ -0,0 +1,3 @@
|
||||
declare module 'virtual:faunosteo-sheet' {
|
||||
export const bundledSheet: import('./provider').BundledSheetData | null
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
import {
|
||||
readReportDocument,
|
||||
type Report,
|
||||
type ReportMigrationMap,
|
||||
} from '@faunosteo/domain'
|
||||
|
||||
/**
|
||||
* Where the report document lives between renders. One implementation today
|
||||
* (the per-tab sessionStorage draft, migrated from v2 on read); the Supabase
|
||||
* and outbox adapters of later steps implement the same interface.
|
||||
*/
|
||||
|
||||
export interface ReportPersistence {
|
||||
load(map: ReportMigrationMap): Report | null
|
||||
save(report: Report | null): void
|
||||
}
|
||||
|
||||
export const DRAFT_KEY = 'osteo:draft'
|
||||
|
||||
function storage(): Storage | null {
|
||||
return typeof sessionStorage === 'undefined' ? null : sessionStorage
|
||||
}
|
||||
|
||||
export const sessionStoragePersistence: ReportPersistence = {
|
||||
load(map) {
|
||||
const raw = storage()?.getItem(DRAFT_KEY)
|
||||
if (!raw) return null
|
||||
try {
|
||||
return readReportDocument(JSON.parse(raw), map).report
|
||||
} catch (err) {
|
||||
if (import.meta.env.DEV) console.warn('osteo:draft ignored', err)
|
||||
return null
|
||||
}
|
||||
},
|
||||
save(report) {
|
||||
const store = storage()
|
||||
if (!store) return
|
||||
if (report) store.setItem(DRAFT_KEY, JSON.stringify(report))
|
||||
else store.removeItem(DRAFT_KEY)
|
||||
},
|
||||
}
|
||||
@@ -1,7 +1,4 @@
|
||||
import {
|
||||
PractitionerSchema,
|
||||
type Practitioner,
|
||||
} from '@/domain/schema/practitioner'
|
||||
import { PractitionerSchema, type Practitioner } from '@faunosteo/domain'
|
||||
|
||||
const STORAGE_KEY = 'osteo:lastPractitioner'
|
||||
|
||||
|
||||
+141
-121
@@ -1,16 +1,42 @@
|
||||
import { create } from 'zustand'
|
||||
import { ReportSchema, type Report } from '@/domain/schema/report'
|
||||
import type { Observation } from '@/domain/schema/observation'
|
||||
import type { Practitioner } from '@/domain/schema/practitioner'
|
||||
import type { Animal, Owner } from '@/domain/schema/animal'
|
||||
import {
|
||||
REPORT_VERSION,
|
||||
type Animal,
|
||||
type NextAppointment,
|
||||
type Observation,
|
||||
type Owner,
|
||||
type Practitioner,
|
||||
type Report,
|
||||
type ReportMigrationMap,
|
||||
type SheetRef,
|
||||
} from '@faunosteo/domain'
|
||||
import { generateId } from '@/lib/id'
|
||||
import { nowIso } from '@/lib/dates'
|
||||
import {
|
||||
sessionStoragePersistence,
|
||||
type ReportPersistence,
|
||||
} from './persistence'
|
||||
|
||||
/**
|
||||
* In-memory report document (v3) and its editing actions. Observation-level
|
||||
* zone rules live in services/zoneInteraction; the store only replaces
|
||||
* documents. The per-tab draft is mirrored through the persistence adapter
|
||||
* and restored once the sheet (and its migration map) is known.
|
||||
*/
|
||||
|
||||
/** What a new report needs before the store stamps version, id and dates. */
|
||||
export type NewReportDraft = Omit<
|
||||
Report,
|
||||
'version' | 'id' | 'createdAt' | 'sheet' | 'localAnnotations'
|
||||
>
|
||||
|
||||
export interface ReportStore {
|
||||
report: Report | null
|
||||
activeObservationIndex: number
|
||||
initReport: (draft: Omit<Report, 'id' | 'createdAt' | 'version'>) => void
|
||||
initReport: (draft: NewReportDraft, sheet: SheetRef) => void
|
||||
hydrateReport: (report: Report) => void
|
||||
/** Restores the per-tab draft; a no-op when a report is already open. */
|
||||
restoreDraft: (map: ReportMigrationMap) => void
|
||||
addObservation: () => void
|
||||
removeObservation: (index: number) => void
|
||||
moveObservationUp: (index: number) => void
|
||||
@@ -22,11 +48,11 @@ export interface ReportStore {
|
||||
setOwner: (next: Owner) => void
|
||||
setConclusion: (text: string) => void
|
||||
setRecommendations: (text: string) => void
|
||||
setNextAppointment: (next: Report['nextAppointment']) => void
|
||||
setNextAppointment: (next: NextAppointment | undefined) => void
|
||||
reset: () => void
|
||||
}
|
||||
|
||||
function emptyObservation(): Observation {
|
||||
export function emptyObservation(): Observation {
|
||||
return {
|
||||
id: generateId(),
|
||||
zones: [],
|
||||
@@ -36,131 +62,125 @@ function emptyObservation(): Observation {
|
||||
}
|
||||
}
|
||||
|
||||
const DRAFT_KEY = 'osteo:draft'
|
||||
|
||||
/** Reads the auto-saved draft back from sessionStorage (null if absent/invalid). */
|
||||
export function readPersistedDraft(): Report | null {
|
||||
if (typeof sessionStorage === 'undefined') return null
|
||||
const raw = sessionStorage.getItem(DRAFT_KEY)
|
||||
if (!raw) return null
|
||||
try {
|
||||
const parsed = ReportSchema.safeParse(JSON.parse(raw))
|
||||
return parsed.success ? parsed.data : null
|
||||
} catch {
|
||||
return null
|
||||
}
|
||||
function swapped(list: Observation[], i: number, j: number): Observation[] {
|
||||
const next = [...list]
|
||||
;[next[i], next[j]] = [next[j]!, next[i]!]
|
||||
return next
|
||||
}
|
||||
|
||||
export const useReportStore = create<ReportStore>((set) => ({
|
||||
// Restore the per-tab draft so a page refresh never loses the session.
|
||||
report: readPersistedDraft(),
|
||||
activeObservationIndex: 0,
|
||||
type Patch = Partial<Pick<ReportStore, 'report' | 'activeObservationIndex'>>
|
||||
type Setter = (fn: (s: ReportStore) => Patch | ReportStore) => void
|
||||
|
||||
initReport: (draft) =>
|
||||
set({
|
||||
report: {
|
||||
...draft,
|
||||
version: 2,
|
||||
id: generateId(),
|
||||
createdAt: nowIso(),
|
||||
observations:
|
||||
draft.observations.length === 0
|
||||
? [emptyObservation()]
|
||||
: draft.observations,
|
||||
},
|
||||
activeObservationIndex: 0,
|
||||
}),
|
||||
function onReport(set: Setter, update: (r: Report, s: ReportStore) => Patch) {
|
||||
set((s) => (s.report ? update(s.report, s) : s))
|
||||
}
|
||||
|
||||
hydrateReport: (report) => set({ report, activeObservationIndex: 0 }),
|
||||
export function createReportStore(persistence: ReportPersistence) {
|
||||
const store = create<ReportStore>((set) => ({
|
||||
report: null,
|
||||
activeObservationIndex: 0,
|
||||
|
||||
addObservation: () =>
|
||||
set((s) => {
|
||||
if (!s.report) return s
|
||||
const obs = emptyObservation()
|
||||
const observations = [...s.report.observations, obs]
|
||||
return {
|
||||
report: { ...s.report, observations },
|
||||
activeObservationIndex: observations.length - 1,
|
||||
}
|
||||
}),
|
||||
initReport: (draft, sheet) =>
|
||||
set({
|
||||
report: {
|
||||
...draft,
|
||||
version: REPORT_VERSION,
|
||||
id: generateId(),
|
||||
createdAt: nowIso(),
|
||||
sheet,
|
||||
observations:
|
||||
draft.observations.length === 0
|
||||
? [emptyObservation()]
|
||||
: draft.observations,
|
||||
localAnnotations: [],
|
||||
},
|
||||
activeObservationIndex: 0,
|
||||
}),
|
||||
|
||||
removeObservation: (index) =>
|
||||
set((s) => {
|
||||
if (!s.report) return s
|
||||
const observations = s.report.observations.filter((_, i) => i !== index)
|
||||
const active = Math.min(
|
||||
s.activeObservationIndex,
|
||||
Math.max(0, observations.length - 1),
|
||||
)
|
||||
return {
|
||||
report: { ...s.report, observations },
|
||||
activeObservationIndex: active,
|
||||
}
|
||||
}),
|
||||
hydrateReport: (report) => set({ report, activeObservationIndex: 0 }),
|
||||
|
||||
moveObservationUp: (index) =>
|
||||
set((s) => {
|
||||
if (!s.report || index <= 0) return s
|
||||
const observations = [...s.report.observations]
|
||||
;[observations[index - 1], observations[index]] = [
|
||||
observations[index],
|
||||
observations[index - 1],
|
||||
]
|
||||
return { report: { ...s.report, observations } }
|
||||
}),
|
||||
restoreDraft: (map) =>
|
||||
set((s) => {
|
||||
if (s.report) return s
|
||||
const report = persistence.load(map)
|
||||
return report ? { report, activeObservationIndex: 0 } : s
|
||||
}),
|
||||
|
||||
moveObservationDown: (index) =>
|
||||
set((s) => {
|
||||
if (!s.report || index >= s.report.observations.length - 1) return s
|
||||
const observations = [...s.report.observations]
|
||||
;[observations[index], observations[index + 1]] = [
|
||||
observations[index + 1],
|
||||
observations[index],
|
||||
]
|
||||
return { report: { ...s.report, observations } }
|
||||
}),
|
||||
addObservation: () =>
|
||||
onReport(set, (r) => {
|
||||
const observations = [...r.observations, emptyObservation()]
|
||||
return {
|
||||
report: { ...r, observations },
|
||||
activeObservationIndex: observations.length - 1,
|
||||
}
|
||||
}),
|
||||
|
||||
updateObservation: (index, obs) =>
|
||||
set((s) => {
|
||||
if (!s.report) return s
|
||||
const observations = s.report.observations.map((o, i) =>
|
||||
i === index ? obs : o,
|
||||
)
|
||||
return { report: { ...s.report, observations } }
|
||||
}),
|
||||
removeObservation: (index) =>
|
||||
onReport(set, (r, s) => {
|
||||
const observations = r.observations.filter((_, i) => i !== index)
|
||||
const active = Math.min(
|
||||
s.activeObservationIndex,
|
||||
Math.max(0, observations.length - 1),
|
||||
)
|
||||
return {
|
||||
report: { ...r, observations },
|
||||
activeObservationIndex: active,
|
||||
}
|
||||
}),
|
||||
|
||||
setActiveObservation: (index) => set({ activeObservationIndex: index }),
|
||||
moveObservationUp: (index) =>
|
||||
onReport(set, (r) =>
|
||||
index <= 0
|
||||
? {}
|
||||
: {
|
||||
report: {
|
||||
...r,
|
||||
observations: swapped(r.observations, index - 1, index),
|
||||
},
|
||||
},
|
||||
),
|
||||
|
||||
setPractitioner: (next) =>
|
||||
set((s) => (s.report ? { report: { ...s.report, practitioner: next } } : s)),
|
||||
moveObservationDown: (index) =>
|
||||
onReport(set, (r) =>
|
||||
index >= r.observations.length - 1
|
||||
? {}
|
||||
: {
|
||||
report: {
|
||||
...r,
|
||||
observations: swapped(r.observations, index, index + 1),
|
||||
},
|
||||
},
|
||||
),
|
||||
|
||||
setAnimal: (next) =>
|
||||
set((s) => (s.report ? { report: { ...s.report, animal: next } } : s)),
|
||||
updateObservation: (index, obs) =>
|
||||
onReport(set, (r) => ({
|
||||
report: {
|
||||
...r,
|
||||
observations: r.observations.map((o, i) => (i === index ? obs : o)),
|
||||
},
|
||||
})),
|
||||
|
||||
setOwner: (next) =>
|
||||
set((s) => (s.report ? { report: { ...s.report, owner: next } } : s)),
|
||||
setActiveObservation: (index) => set({ activeObservationIndex: index }),
|
||||
setPractitioner: (next) =>
|
||||
onReport(set, (r) => ({ report: { ...r, practitioner: next } })),
|
||||
setAnimal: (next) =>
|
||||
onReport(set, (r) => ({ report: { ...r, animal: next } })),
|
||||
setOwner: (next) =>
|
||||
onReport(set, (r) => ({ report: { ...r, owner: next } })),
|
||||
setConclusion: (text) =>
|
||||
onReport(set, (r) => ({ report: { ...r, conclusion: text } })),
|
||||
setRecommendations: (text) =>
|
||||
onReport(set, (r) => ({ report: { ...r, recommendations: text } })),
|
||||
setNextAppointment: (next) =>
|
||||
onReport(set, (r) => {
|
||||
const rest = { ...r }
|
||||
delete rest.nextAppointment
|
||||
return { report: next ? { ...rest, nextAppointment: next } : rest }
|
||||
}),
|
||||
reset: () => set({ report: null, activeObservationIndex: 0 }),
|
||||
}))
|
||||
store.subscribe((state) => persistence.save(state.report))
|
||||
return store
|
||||
}
|
||||
|
||||
setConclusion: (text) =>
|
||||
set((s) => (s.report ? { report: { ...s.report, conclusion: text } } : s)),
|
||||
|
||||
setRecommendations: (text) =>
|
||||
set((s) =>
|
||||
s.report ? { report: { ...s.report, recommendations: text } } : s,
|
||||
),
|
||||
|
||||
setNextAppointment: (next) =>
|
||||
set((s) =>
|
||||
s.report ? { report: { ...s.report, nextAppointment: next } } : s,
|
||||
),
|
||||
|
||||
reset: () => set({ report: null, activeObservationIndex: 0 }),
|
||||
}))
|
||||
|
||||
useReportStore.subscribe((state) => {
|
||||
if (typeof sessionStorage === 'undefined') return
|
||||
if (state.report) {
|
||||
sessionStorage.setItem(DRAFT_KEY, JSON.stringify(state.report))
|
||||
} else {
|
||||
sessionStorage.removeItem(DRAFT_KEY)
|
||||
}
|
||||
})
|
||||
export const useReportStore = createReportStore(sessionStoragePersistence)
|
||||
@@ -1,528 +0,0 @@
|
||||
.svg-editor-root {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
flex: 1;
|
||||
min-height: 0;
|
||||
overflow: hidden;
|
||||
font-family: var(--font-sans);
|
||||
color: var(--color-ink);
|
||||
background: var(--color-bg);
|
||||
}
|
||||
|
||||
@media (min-width: 768px) {
|
||||
.svg-editor-root {
|
||||
flex-direction: row;
|
||||
}
|
||||
}
|
||||
|
||||
.svg-editor-root * { box-sizing: border-box; margin: 0; padding: 0; }
|
||||
|
||||
.svg-editor-canvas {
|
||||
flex: 1;
|
||||
position: relative;
|
||||
background: var(--color-surface);
|
||||
overflow: hidden;
|
||||
padding: 10px;
|
||||
min-height: 40vh;
|
||||
}
|
||||
|
||||
@media (min-width: 768px) {
|
||||
.svg-editor-canvas {
|
||||
min-height: 0;
|
||||
}
|
||||
}
|
||||
.svg-editor-canvas-inner {
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
overflow: auto;
|
||||
position: relative;
|
||||
}
|
||||
.svg-editor-canvas-inner svg {
|
||||
display: block;
|
||||
max-width: 100%;
|
||||
max-height: 100%;
|
||||
width: auto;
|
||||
height: auto;
|
||||
}
|
||||
|
||||
.svg-editor-canvas.mode-point svg,
|
||||
.svg-editor-canvas.mode-polygon svg { cursor: crosshair; }
|
||||
.svg-editor-canvas.mode-select svg { cursor: default; }
|
||||
|
||||
.svg-editor-root [data-anno-id] { transition: filter 0.1s; }
|
||||
.svg-editor-root [data-anno-id]:hover {
|
||||
filter: brightness(1.3) drop-shadow(0 0 4px rgba(184, 90, 63, 0.7));
|
||||
}
|
||||
.svg-editor-root [data-anno-id].selected {
|
||||
filter: drop-shadow(0 0 12px var(--color-accent)) drop-shadow(0 0 6px var(--color-accent)) brightness(1.15);
|
||||
stroke: var(--color-accent) !important;
|
||||
stroke-width: 4 !important;
|
||||
stroke-opacity: 1 !important;
|
||||
}
|
||||
|
||||
.svg-editor-root .polygon-handle {
|
||||
cursor: move;
|
||||
fill: #ffd54f;
|
||||
stroke: var(--color-accent);
|
||||
stroke-width: 2;
|
||||
transition: r 0.1s;
|
||||
}
|
||||
.svg-editor-root .polygon-handle:hover {
|
||||
fill: #ffe082;
|
||||
stroke-width: 3;
|
||||
}
|
||||
.svg-editor-root .polygon-midhandle {
|
||||
cursor: copy;
|
||||
fill: var(--color-surface);
|
||||
stroke: var(--color-accent);
|
||||
stroke-width: 1.5;
|
||||
fill-opacity: 0.7;
|
||||
}
|
||||
.svg-editor-root .polygon-midhandle:hover {
|
||||
fill: #ffd54f;
|
||||
fill-opacity: 1;
|
||||
}
|
||||
|
||||
@keyframes svg-editor-flash-pulse {
|
||||
0%, 100% {
|
||||
stroke-width: 4;
|
||||
stroke: var(--color-accent);
|
||||
filter: drop-shadow(0 0 12px var(--color-accent)) brightness(1.15);
|
||||
}
|
||||
50% {
|
||||
stroke-width: 10;
|
||||
stroke: #ffd54f;
|
||||
filter: drop-shadow(0 0 24px #ffd54f) drop-shadow(0 0 12px var(--color-accent)) brightness(1.4);
|
||||
}
|
||||
}
|
||||
|
||||
.svg-editor-root [data-anno-id].flashing {
|
||||
animation: svg-editor-flash-pulse 0.6s ease-in-out 2;
|
||||
}
|
||||
|
||||
.svg-editor-root .polygon-preview {
|
||||
fill: rgba(184, 90, 63, 0.2);
|
||||
stroke: var(--color-accent);
|
||||
stroke-width: 2;
|
||||
stroke-dasharray: 5,3;
|
||||
}
|
||||
.svg-editor-root .polygon-preview-pt { fill: var(--color-accent); }
|
||||
|
||||
.svg-editor-sidebar {
|
||||
width: 100%;
|
||||
background: var(--color-surface);
|
||||
border-top: 1px solid var(--color-border);
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
overflow: hidden;
|
||||
max-height: 50vh;
|
||||
}
|
||||
|
||||
@media (min-width: 768px) {
|
||||
.svg-editor-sidebar {
|
||||
width: 380px;
|
||||
max-height: none;
|
||||
border-top: none;
|
||||
border-left: 1px solid var(--color-border);
|
||||
}
|
||||
}
|
||||
.svg-editor-sidebar header {
|
||||
padding: 14px 16px;
|
||||
background: var(--color-accent);
|
||||
color: white;
|
||||
}
|
||||
.svg-editor-sidebar header h1 { font-size: 16px; font-weight: 600; }
|
||||
.svg-editor-sidebar header .sub { font-size: 11px; opacity: 0.8; margin-top: 4px; }
|
||||
|
||||
.svg-editor-sidebar-content {
|
||||
flex: 1;
|
||||
overflow-y: auto;
|
||||
padding: 14px 16px;
|
||||
}
|
||||
|
||||
.svg-editor-root .section { margin-bottom: 20px; }
|
||||
.svg-editor-root .section h3 {
|
||||
font-size: 11px;
|
||||
text-transform: uppercase;
|
||||
color: var(--color-ink-muted);
|
||||
margin-bottom: 8px;
|
||||
letter-spacing: 0.5px;
|
||||
}
|
||||
|
||||
.svg-editor-root button,
|
||||
.svg-editor-root .btn {
|
||||
display: block;
|
||||
width: 100%;
|
||||
padding: 9px 12px;
|
||||
margin-bottom: 6px;
|
||||
background: var(--color-surface-strong);
|
||||
border: 1px solid var(--color-border);
|
||||
border-radius: 6px;
|
||||
cursor: pointer;
|
||||
font-size: 13px;
|
||||
text-align: left;
|
||||
transition: all 0.1s;
|
||||
font-family: inherit;
|
||||
color: var(--color-ink);
|
||||
}
|
||||
.svg-editor-root button:hover { background: var(--color-border); }
|
||||
.svg-editor-root button.active {
|
||||
background: var(--color-accent);
|
||||
color: white;
|
||||
border-color: var(--color-accent);
|
||||
}
|
||||
.svg-editor-root button.danger {
|
||||
background: #fef2f2;
|
||||
border-color: #fecaca;
|
||||
color: var(--color-danger);
|
||||
}
|
||||
.svg-editor-root button.danger:hover { background: #fee2e2; }
|
||||
.svg-editor-root button.primary {
|
||||
background: var(--color-accent);
|
||||
color: white;
|
||||
border-color: var(--color-accent);
|
||||
}
|
||||
.svg-editor-root button.primary:hover { background: var(--color-accent-strong); }
|
||||
|
||||
.svg-editor-root input,
|
||||
.svg-editor-root select {
|
||||
display: block;
|
||||
width: 100%;
|
||||
padding: 8px 10px;
|
||||
margin-bottom: 6px;
|
||||
border: 1px solid var(--color-border);
|
||||
border-radius: 6px;
|
||||
font-size: 13px;
|
||||
background: var(--color-surface);
|
||||
font-family: inherit;
|
||||
color: var(--color-ink);
|
||||
}
|
||||
.svg-editor-root input[type="color"] { padding: 2px; height: 32px; cursor: pointer; }
|
||||
.svg-editor-root input[type="file"] { background: var(--color-surface-strong); cursor: pointer; }
|
||||
.svg-editor-root label {
|
||||
font-size: 11px;
|
||||
color: var(--color-ink-muted);
|
||||
margin-bottom: 2px;
|
||||
display: block;
|
||||
margin-top: 8px;
|
||||
}
|
||||
|
||||
.svg-editor-root .element-list {
|
||||
max-height: 280px;
|
||||
overflow-y: auto;
|
||||
border: 1px solid var(--color-border);
|
||||
border-radius: 6px;
|
||||
background: var(--color-bg);
|
||||
}
|
||||
.svg-editor-root .element-item {
|
||||
padding: 6px 10px;
|
||||
border-bottom: 1px solid var(--color-border);
|
||||
cursor: pointer;
|
||||
font-size: 12px;
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 8px;
|
||||
}
|
||||
.svg-editor-root .element-item:last-child { border-bottom: none; }
|
||||
.svg-editor-root .element-item:hover { background: var(--color-surface-strong); }
|
||||
.svg-editor-root .element-item.selected {
|
||||
background: color-mix(in srgb, var(--color-accent) 12%, transparent);
|
||||
color: var(--color-accent-strong);
|
||||
font-weight: 600;
|
||||
}
|
||||
.svg-editor-root .element-item .swatch {
|
||||
width: 12px;
|
||||
height: 12px;
|
||||
border-radius: 3px;
|
||||
border: 1px solid rgba(0,0,0,0.15);
|
||||
flex-shrink: 0;
|
||||
}
|
||||
.svg-editor-root .element-item .name {
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
white-space: nowrap;
|
||||
}
|
||||
.svg-editor-root .element-item .cat {
|
||||
font-size: 10px;
|
||||
color: var(--color-ink-muted);
|
||||
margin-left: auto;
|
||||
padding: 1px 6px;
|
||||
background: var(--color-surface-strong);
|
||||
border-radius: 8px;
|
||||
flex-shrink: 0;
|
||||
}
|
||||
|
||||
.svg-editor-root .coords {
|
||||
font-family: monospace;
|
||||
font-size: 11px;
|
||||
color: var(--color-ink-muted);
|
||||
padding: 4px 8px;
|
||||
background: var(--color-bg);
|
||||
border-radius: 4px;
|
||||
margin-bottom: 8px;
|
||||
}
|
||||
|
||||
.svg-editor-zoom-controls {
|
||||
position: absolute;
|
||||
bottom: 20px;
|
||||
left: 20px;
|
||||
background: var(--color-surface);
|
||||
border: 1px solid var(--color-border);
|
||||
border-radius: 6px;
|
||||
padding: 4px;
|
||||
display: flex;
|
||||
gap: 4px;
|
||||
box-shadow: 0 2px 8px rgba(0,0,0,0.08);
|
||||
}
|
||||
.svg-editor-zoom-controls button {
|
||||
width: 40px;
|
||||
height: 40px;
|
||||
padding: 0;
|
||||
margin: 0;
|
||||
font-size: 18px;
|
||||
display: flex;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
}
|
||||
|
||||
@media (min-width: 768px) {
|
||||
.svg-editor-zoom-controls button {
|
||||
width: 32px;
|
||||
height: 32px;
|
||||
font-size: 16px;
|
||||
}
|
||||
}
|
||||
|
||||
.svg-editor-root input[type="checkbox"] { width: auto; display: inline; margin: 0 6px 0 0; }
|
||||
|
||||
.svg-editor-root .cat-row {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 6px;
|
||||
padding: 6px 4px;
|
||||
background: var(--color-bg);
|
||||
border-radius: 6px;
|
||||
margin-bottom: 4px;
|
||||
border: 1px solid var(--color-border);
|
||||
}
|
||||
.svg-editor-root .cat-row input[type="color"] { width: 32px; height: 28px; padding: 0; margin: 0; flex-shrink: 0; }
|
||||
.svg-editor-root .cat-row input[type="checkbox"] { margin: 0 4px 0 4px; flex-shrink: 0; }
|
||||
.svg-editor-root .cat-row .name {
|
||||
flex: 1;
|
||||
font-size: 13px;
|
||||
overflow: hidden;
|
||||
text-overflow: ellipsis;
|
||||
white-space: nowrap;
|
||||
}
|
||||
.svg-editor-root .cat-row .count {
|
||||
font-size: 10px;
|
||||
color: var(--color-ink-muted);
|
||||
padding: 1px 5px;
|
||||
background: var(--color-surface-strong);
|
||||
border-radius: 8px;
|
||||
}
|
||||
.svg-editor-root .cat-row .delete {
|
||||
width: 28px;
|
||||
height: 28px;
|
||||
padding: 0;
|
||||
margin: 0;
|
||||
font-size: 13px;
|
||||
display: flex;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
background: transparent;
|
||||
border: none;
|
||||
cursor: pointer;
|
||||
}
|
||||
.svg-editor-root .cat-row .delete:hover { background: #fef2f2; color: var(--color-danger); }
|
||||
.svg-editor-root .cat-row .special-btn {
|
||||
width: 28px;
|
||||
height: 28px;
|
||||
padding: 0;
|
||||
margin: 0;
|
||||
font-size: 13px;
|
||||
display: flex;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
background: transparent;
|
||||
border: none;
|
||||
cursor: pointer;
|
||||
color: var(--color-ink-muted);
|
||||
}
|
||||
.svg-editor-root .cat-row .special-btn:hover { background: #fff8e1; color: #d97706; }
|
||||
.svg-editor-root .cat-row .special-btn.has-value { color: #d97706; }
|
||||
.svg-editor-root .cat-row .special-badge {
|
||||
font-size: 10px;
|
||||
padding: 1px 6px;
|
||||
background: #fff8e1;
|
||||
color: #92400e;
|
||||
border: 1px solid #ffd54f;
|
||||
border-radius: 8px;
|
||||
flex-shrink: 0;
|
||||
}
|
||||
|
||||
.svg-editor-root .add-cat { display: flex; gap: 6px; margin-top: 8px; }
|
||||
.svg-editor-root .add-cat input { margin: 0; }
|
||||
.svg-editor-root .add-cat input[type="color"] { width: 36px; flex-shrink: 0; }
|
||||
.svg-editor-root .add-cat input[type="text"] { flex: 1; }
|
||||
.svg-editor-root .add-cat button { width: auto; padding: 6px 12px; margin: 0; flex-shrink: 0; }
|
||||
|
||||
.svg-editor-root .slider-row {
|
||||
display: flex;
|
||||
gap: 8px;
|
||||
align-items: center;
|
||||
margin-bottom: 6px;
|
||||
}
|
||||
.svg-editor-root .slider-row input[type="range"] {
|
||||
flex: 1;
|
||||
margin: 0;
|
||||
padding: 0;
|
||||
height: 28px;
|
||||
cursor: pointer;
|
||||
accent-color: var(--color-accent);
|
||||
}
|
||||
.svg-editor-root .slider-row input[type="number"] {
|
||||
width: 60px;
|
||||
margin: 0;
|
||||
padding: 6px 4px;
|
||||
text-align: center;
|
||||
font-variant-numeric: tabular-nums;
|
||||
}
|
||||
|
||||
.svg-editor-root .detail-toggle {
|
||||
margin-top: 4px;
|
||||
padding: 8px 10px;
|
||||
background: #fff8e1;
|
||||
border: 1px solid #ffd54f;
|
||||
border-radius: 6px;
|
||||
font-size: 13px;
|
||||
}
|
||||
.svg-editor-root .detail-toggle label { margin: 0; color: #92400e; font-size: 13px; }
|
||||
.svg-editor-root .detail-toggle input[type="text"] { margin-top: 4px; margin-bottom: 0; }
|
||||
|
||||
.svg-editor-root .element-item .detail-badge {
|
||||
background: #ffd54f;
|
||||
color: #6b4500;
|
||||
font-size: 10px;
|
||||
padding: 1px 6px;
|
||||
border-radius: 8px;
|
||||
font-weight: 600;
|
||||
margin-left: 4px;
|
||||
flex-shrink: 0;
|
||||
}
|
||||
|
||||
.svg-editor-root [data-anno-opens-detail] { stroke-dasharray: 8,4; }
|
||||
.svg-editor-root .detail-zone { cursor: pointer; }
|
||||
|
||||
.svg-editor-root .welcome {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
min-height: 100%;
|
||||
text-align: center;
|
||||
color: var(--color-ink-muted);
|
||||
padding: 60px 20px;
|
||||
}
|
||||
.svg-editor-root .welcome-icon { font-size: 80px; margin-bottom: 20px; opacity: 0.7; }
|
||||
.svg-editor-root .welcome h2 {
|
||||
color: var(--color-accent);
|
||||
margin-bottom: 16px;
|
||||
font-size: 24px;
|
||||
font-family: var(--font-serif);
|
||||
}
|
||||
.svg-editor-root .welcome p {
|
||||
max-width: 480px;
|
||||
margin-bottom: 30px;
|
||||
line-height: 1.5;
|
||||
font-size: 14px;
|
||||
}
|
||||
.svg-editor-root .welcome p code {
|
||||
background: var(--color-surface-strong);
|
||||
padding: 2px 6px;
|
||||
border-radius: 3px;
|
||||
font-size: 90%;
|
||||
font-family: monospace;
|
||||
}
|
||||
.svg-editor-root .welcome-btn {
|
||||
width: auto !important;
|
||||
padding: 14px 28px !important;
|
||||
font-size: 15px !important;
|
||||
margin: 0 !important;
|
||||
}
|
||||
.svg-editor-root .welcome-hint {
|
||||
margin-top: 16px;
|
||||
color: var(--color-ink-muted);
|
||||
font-size: 13px;
|
||||
}
|
||||
|
||||
.svg-editor-root .welcome-tabs {
|
||||
display: flex;
|
||||
gap: 0;
|
||||
margin-bottom: 20px;
|
||||
border-radius: 6px;
|
||||
overflow: hidden;
|
||||
border: 1px solid var(--color-border);
|
||||
}
|
||||
.svg-editor-root .welcome-tab {
|
||||
padding: 8px 20px;
|
||||
font-size: 13px;
|
||||
background: var(--color-surface);
|
||||
color: var(--color-ink-muted);
|
||||
border: none;
|
||||
cursor: pointer;
|
||||
transition: background 0.15s, color 0.15s;
|
||||
}
|
||||
.svg-editor-root .welcome-tab:not(:last-child) {
|
||||
border-right: 1px solid var(--color-border);
|
||||
}
|
||||
.svg-editor-root .welcome-tab.active {
|
||||
background: var(--color-accent);
|
||||
color: #fff;
|
||||
}
|
||||
.svg-editor-root .welcome-tab-content {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
align-items: center;
|
||||
gap: 10px;
|
||||
min-width: 260px;
|
||||
}
|
||||
.svg-editor-root .welcome-tab-content label {
|
||||
font-size: 12px;
|
||||
color: var(--color-ink-muted);
|
||||
align-self: flex-start;
|
||||
}
|
||||
.svg-editor-root .welcome-tab-content select {
|
||||
width: 100%;
|
||||
padding: 8px 10px;
|
||||
border-radius: 5px;
|
||||
border: 1px solid var(--color-border);
|
||||
background: var(--color-surface);
|
||||
color: var(--color-ink);
|
||||
font-size: 13px;
|
||||
}
|
||||
|
||||
.svg-editor-canvas.dragging-over { background: color-mix(in srgb, var(--color-accent) 8%, var(--color-surface)); }
|
||||
.svg-editor-canvas.dragging-over .welcome { color: var(--color-accent); }
|
||||
.svg-editor-canvas.dragging-over::after {
|
||||
content: attr(data-drop-label);
|
||||
position: absolute;
|
||||
inset: 10px;
|
||||
display: flex;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
font-size: 32px;
|
||||
color: var(--color-accent);
|
||||
background: color-mix(in srgb, var(--color-accent) 8%, transparent 15%);
|
||||
border: 4px dashed var(--color-accent);
|
||||
border-radius: 8px;
|
||||
pointer-events: none;
|
||||
z-index: 10;
|
||||
}
|
||||
|
||||
.svg-editor-root .hide-articulation [data-anno-category="articulation"],
|
||||
.svg-editor-root .hide-charniere [data-anno-category="charniere"],
|
||||
.svg-editor-root .hide-cadran-crane [data-anno-category="cadran-crane"],
|
||||
.svg-editor-root .hide-os-overlay [data-anno-category="os-overlay"],
|
||||
.svg-editor-root .hide-spine-zone [data-anno-category="spine-zone"],
|
||||
.svg-editor-root .hide-custom [data-anno-category="custom"] { display: none; }
|
||||
@@ -0,0 +1,39 @@
|
||||
import {
|
||||
REPORT_VERSION,
|
||||
type Observation,
|
||||
type Report,
|
||||
} from '@faunosteo/domain'
|
||||
import { loadSheetIndex } from '@/sheets/useSheet'
|
||||
import type { SheetIndex } from '@/services/sheetIndex'
|
||||
|
||||
/** The bundled reference draft (vitest runs the sheet-bundle plugin in draft mode). */
|
||||
export async function loadTestSheet(): Promise<SheetIndex> {
|
||||
const index = await loadSheetIndex('equine')
|
||||
if (!index) throw new Error('bundled sheet missing: run pnpm import:equine')
|
||||
return index
|
||||
}
|
||||
|
||||
export function emptyObservation(id = 'obs-1'): Observation {
|
||||
return { id, zones: [], findings: [], freeTextFindings: [], comment: '' }
|
||||
}
|
||||
|
||||
export function minimalReport(
|
||||
sheet: SheetIndex,
|
||||
patch: Partial<Report> = {},
|
||||
): Report {
|
||||
return {
|
||||
version: REPORT_VERSION,
|
||||
id: 'r1',
|
||||
createdAt: '2026-10-10T10:00:00Z',
|
||||
date: '2026-10-10',
|
||||
practitioner: { name: 'Dr. Dupont' },
|
||||
animal: { speciesId: 'equine', name: 'Mistral' },
|
||||
owner: { name: 'Jean Martin' },
|
||||
sheet: sheet.sheet.ref,
|
||||
observations: [],
|
||||
conclusion: '',
|
||||
recommendations: '',
|
||||
localAnnotations: [],
|
||||
...patch,
|
||||
}
|
||||
}
|
||||
@@ -1,72 +0,0 @@
|
||||
import { describe, it, expect } from 'vitest'
|
||||
import { readFileSync } from 'node:fs'
|
||||
import { fileURLToPath } from 'node:url'
|
||||
import { dirname, resolve } from 'node:path'
|
||||
|
||||
import { parseSvgBones } from '@/anatomy/svgConvention'
|
||||
|
||||
const HERE = dirname(fileURLToPath(import.meta.url))
|
||||
const HORSE_PATH = resolve(HERE, '../../public/species/equine/Horse.svg')
|
||||
const HEAD_PATH = resolve(HERE, '../../public/species/equine/Horse_head.svg')
|
||||
|
||||
function loadSvg(path: string): SVGSVGElement {
|
||||
const raw = readFileSync(path, 'utf8')
|
||||
const doc = new DOMParser().parseFromString(raw, 'image/svg+xml')
|
||||
return doc.documentElement as unknown as SVGSVGElement
|
||||
}
|
||||
|
||||
describe('real Horse.svg', () => {
|
||||
const map = parseSvgBones(loadSvg(HORSE_PATH))
|
||||
|
||||
it('parses 18 unique annotations', () => {
|
||||
expect(map.size).toBe(18)
|
||||
})
|
||||
|
||||
it('contains 5 zone-colonne annotations (cervical / thoracic / lumbar / sacral / caudal)', () => {
|
||||
const spine = [...map.values()].filter(
|
||||
(b) => b.category === 'zone-colonne',
|
||||
)
|
||||
expect(spine.length).toBe(5)
|
||||
})
|
||||
|
||||
it('contains exactly one opens-detail trigger pointing at the head SVG', () => {
|
||||
const triggers = [...map.values()].filter((b) => b.opensDetail === 'head')
|
||||
expect(triggers.length).toBe(1)
|
||||
})
|
||||
|
||||
it('contains 9 articulations', () => {
|
||||
const arts = [...map.values()].filter(
|
||||
(b) => b.category === 'articulations',
|
||||
)
|
||||
expect(arts.length).toBe(9)
|
||||
})
|
||||
|
||||
it('contains 3 vertebral hinges', () => {
|
||||
const ch = [...map.values()].filter(
|
||||
(b) => b.category === 'charni-res-vert-brales',
|
||||
)
|
||||
expect(ch.length).toBe(3)
|
||||
})
|
||||
})
|
||||
|
||||
describe('real Horse_head.svg', () => {
|
||||
const map = parseSvgBones(loadSvg(HEAD_PATH))
|
||||
|
||||
it('parses 9 unique annotations', () => {
|
||||
expect(map.size).toBe(9)
|
||||
})
|
||||
|
||||
it('contains 5 cadrans-du-cr-ne annotations', () => {
|
||||
const cadrans = [...map.values()].filter(
|
||||
(b) => b.category === 'cadrans-du-cr-ne',
|
||||
)
|
||||
expect(cadrans.length).toBe(5)
|
||||
})
|
||||
|
||||
it('contains 2 articulations (ATM + SSB equivalents)', () => {
|
||||
const arts = [...map.values()].filter(
|
||||
(b) => b.category === 'articulations',
|
||||
)
|
||||
expect(arts.length).toBe(2)
|
||||
})
|
||||
})
|
||||
@@ -1,99 +0,0 @@
|
||||
import { describe, it, expect } from 'vitest'
|
||||
import {
|
||||
parseSvgBones,
|
||||
getBoneIdFromEvent,
|
||||
} from '@/anatomy/svgConvention'
|
||||
import { SvgConventionError } from '@/anatomy/types'
|
||||
|
||||
function svgFromString(s: string): SVGSVGElement {
|
||||
const doc = new DOMParser().parseFromString(s, 'image/svg+xml')
|
||||
return doc.documentElement as unknown as SVGSVGElement
|
||||
}
|
||||
|
||||
const FIXTURE = `
|
||||
<svg xmlns="http://www.w3.org/2000/svg">
|
||||
<circle data-anno-id="point-shoulder" data-anno-name-fr="Épaule" data-anno-name-en="Shoulder"
|
||||
data-anno-category="articulations" />
|
||||
<circle data-anno-id="point-shoulder" data-anno-name-fr="Épaule" data-anno-name-en="Shoulder"
|
||||
data-anno-category="articulations" />
|
||||
<polygon data-anno-id="zone-cervical" data-anno-name-fr="Vertèbres cervicales"
|
||||
data-anno-name-en="Cervical Vertebrae" data-anno-category="zone-colonne"
|
||||
data-anno-special="vertebral-precision" />
|
||||
<polygon data-anno-id="zone-head" data-anno-category="os" data-anno-opens-detail="head" />
|
||||
<polygon data-anno-id="zone-future" data-anno-name-fr="Catégorie inédite"
|
||||
data-anno-category="something-new-the-parser-has-never-seen" />
|
||||
<circle data-anno-id="point-knee" data-anno-name-fr="Genou" data-anno-name-en="Knee"
|
||||
data-anno-category="articulations" data-anno-lateral="bilateral" />
|
||||
</svg>`
|
||||
|
||||
describe('parseSvgBones', () => {
|
||||
it('groups multiple elements sharing the same data-anno-id', () => {
|
||||
const map = parseSvgBones(svgFromString(FIXTURE))
|
||||
const shoulder = map.get('point-shoulder')
|
||||
expect(shoulder).toBeDefined()
|
||||
expect(shoulder?.fr).toBe('Épaule')
|
||||
expect(shoulder?.en).toBe('Shoulder')
|
||||
expect(shoulder?.category).toBe('articulations')
|
||||
expect(shoulder?.els.length).toBe(2)
|
||||
})
|
||||
|
||||
it('captures opensDetail when present', () => {
|
||||
const map = parseSvgBones(svgFromString(FIXTURE))
|
||||
expect(map.get('zone-head')?.opensDetail).toBe('head')
|
||||
})
|
||||
|
||||
it('captures data-anno-special when present', () => {
|
||||
const map = parseSvgBones(svgFromString(FIXTURE))
|
||||
expect(map.get('zone-cervical')?.special).toBe('vertebral-precision')
|
||||
expect(map.get('point-shoulder')?.special).toBeUndefined()
|
||||
})
|
||||
|
||||
it('allows annotations without data-anno-name-fr/en (trigger-only zones)', () => {
|
||||
const map = parseSvgBones(svgFromString(FIXTURE))
|
||||
const trigger = map.get('zone-head')
|
||||
expect(trigger?.fr).toBe('')
|
||||
expect(trigger?.en).toBe('')
|
||||
})
|
||||
|
||||
it('accepts any string as data-anno-category (no hardcoded enum)', () => {
|
||||
const map = parseSvgBones(svgFromString(FIXTURE))
|
||||
expect(map.get('zone-future')?.category).toBe(
|
||||
'something-new-the-parser-has-never-seen',
|
||||
)
|
||||
})
|
||||
|
||||
it('captures data-anno-lateral when present', () => {
|
||||
const map = parseSvgBones(svgFromString(FIXTURE))
|
||||
expect(map.get('point-knee')?.lateral).toBe('bilateral')
|
||||
})
|
||||
|
||||
it('leaves lateral undefined when attribute absent', () => {
|
||||
const map = parseSvgBones(svgFromString(FIXTURE))
|
||||
expect(map.get('point-shoulder')?.lateral).toBeUndefined()
|
||||
})
|
||||
})
|
||||
|
||||
describe('parseSvgBones validation', () => {
|
||||
it('throws on missing data-anno-category', () => {
|
||||
const bad = `<svg xmlns="http://www.w3.org/2000/svg">
|
||||
<circle data-anno-id="x" />
|
||||
</svg>`
|
||||
expect(() => parseSvgBones(svgFromString(bad))).toThrow(SvgConventionError)
|
||||
})
|
||||
|
||||
it('throws on empty data-anno-id', () => {
|
||||
const bad = `<svg xmlns="http://www.w3.org/2000/svg">
|
||||
<circle data-anno-id="" data-anno-category="anything" />
|
||||
</svg>`
|
||||
expect(() => parseSvgBones(svgFromString(bad))).toThrow(SvgConventionError)
|
||||
})
|
||||
})
|
||||
|
||||
describe('getBoneIdFromEvent', () => {
|
||||
it('returns null when no anno in ancestry', () => {
|
||||
const div = document.createElement('div')
|
||||
const evt = new Event('click')
|
||||
Object.defineProperty(evt, 'target', { value: div })
|
||||
expect(getBoneIdFromEvent(evt)).toBeNull()
|
||||
})
|
||||
})
|
||||
@@ -1,23 +0,0 @@
|
||||
import { describe, it, expect, vi, beforeEach } from 'vitest'
|
||||
import { loadSvg } from '@/anatomy/svgLoader'
|
||||
|
||||
const SVG = '<svg xmlns="http://www.w3.org/2000/svg"><g data-anno-id="x"/></svg>'
|
||||
|
||||
describe('loadSvg', () => {
|
||||
beforeEach(() => {
|
||||
vi.stubGlobal('fetch', vi.fn(async () => ({
|
||||
ok: true,
|
||||
text: async () => SVG,
|
||||
})) as unknown as typeof fetch)
|
||||
})
|
||||
|
||||
it('returns an SVGSVGElement', async () => {
|
||||
const root = await loadSvg('/whatever.svg')
|
||||
expect(root.tagName.toLowerCase()).toBe('svg')
|
||||
})
|
||||
|
||||
it('throws on non-ok response', async () => {
|
||||
vi.stubGlobal('fetch', vi.fn(async () => ({ ok: false, status: 404, text: async () => '' })) as unknown as typeof fetch)
|
||||
await expect(loadSvg('/missing.svg')).rejects.toThrow()
|
||||
})
|
||||
})
|
||||
@@ -1,169 +0,0 @@
|
||||
/**
|
||||
* Characterisation (Step 1): the equine findings catalog as it exists today.
|
||||
* Pins the facts of docs/faunosteo-audit/05-findings-editor.md §2.4 so that
|
||||
* the future legacy importer (plan Step 4) can be checked against them, and
|
||||
* so that any deliberate business correction shows up as a test change.
|
||||
*
|
||||
* Reads the files directly (no Zod) to count what is really on disk.
|
||||
*/
|
||||
import { describe, it, expect } from 'vitest'
|
||||
import { readFileSync } from 'node:fs'
|
||||
import { createHash } from 'node:crypto'
|
||||
import { fileURLToPath } from 'node:url'
|
||||
import { dirname, resolve } from 'node:path'
|
||||
import { SpeciesFindingsSchema } from '@/domain/schema/findings'
|
||||
|
||||
const HERE = dirname(fileURLToPath(import.meta.url))
|
||||
const SRC_PATH = resolve(HERE, '../../src/domain/species/equine/pathologies.json')
|
||||
const PUBLIC_PATH = resolve(HERE, '../../public/species/equine/pathologies.json')
|
||||
|
||||
interface RawNode {
|
||||
id: string
|
||||
name_fr?: string
|
||||
name_en?: string
|
||||
description_fr?: string
|
||||
description_en?: string
|
||||
requires_vet_referral?: boolean
|
||||
sources?: unknown[]
|
||||
children?: RawNode[]
|
||||
}
|
||||
interface RawZone { id: string; name_fr: string; name_en: string; categories: RawNode[] }
|
||||
interface RawCatalog {
|
||||
schema_version: string
|
||||
scope_disclaimer: string
|
||||
species: { id: string; name_fr: string; name_en: string }
|
||||
zones: Record<string, RawZone>
|
||||
}
|
||||
|
||||
const srcText = readFileSync(SRC_PATH, 'utf8')
|
||||
const catalog = JSON.parse(srcText) as RawCatalog
|
||||
const zoneKeys = Object.keys(catalog.zones)
|
||||
|
||||
function walk(nodes: RawNode[], depth: number, visit: (n: RawNode, depth: number) => void) {
|
||||
for (const n of nodes) {
|
||||
visit(n, depth)
|
||||
if (n.children) walk(n.children, depth + 1, visit)
|
||||
}
|
||||
}
|
||||
|
||||
function allNodes(): Array<{ node: RawNode; depth: number; zone: string }> {
|
||||
const out: Array<{ node: RawNode; depth: number; zone: string }> = []
|
||||
for (const key of zoneKeys) {
|
||||
walk(catalog.zones[key].categories, 1, (node, depth) => out.push({ node, depth, zone: key }))
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
const isLeaf = (n: RawNode) => !n.children || n.children.length === 0
|
||||
|
||||
describe('catalog copies (src vs public)', () => {
|
||||
it('the two pathologies.json copies are byte-identical (manual sync, no script)', () => {
|
||||
const publicText = readFileSync(PUBLIC_PATH, 'utf8')
|
||||
const md5 = (s: string) => createHash('md5').update(s).digest('hex')
|
||||
expect(md5(publicText)).toBe(md5(srcText))
|
||||
})
|
||||
|
||||
it('the bundled copy passes the Zod schema (boot-time contract)', () => {
|
||||
expect(() => SpeciesFindingsSchema.parse(catalog)).not.toThrow()
|
||||
})
|
||||
})
|
||||
|
||||
describe('catalog shape (audit 05 §2.4)', () => {
|
||||
it('declares schema_version "2.0" and species equine / Cheval / Horse', () => {
|
||||
expect(catalog.schema_version).toBe('2.0')
|
||||
expect(catalog.species).toEqual({ id: 'equine', name_fr: 'Cheval', name_en: 'Horse' })
|
||||
expect(catalog.scope_disclaimer.length).toBeGreaterThan(50)
|
||||
})
|
||||
|
||||
it('has exactly 26 zones in cranio-caudal insertion order', () => {
|
||||
expect(zoneKeys).toEqual([
|
||||
'parietal', 'frontal', 'sphenoid', 'temporal', 'occipital', 'ssb', 'atm', 'hyoid',
|
||||
'c0-c1', 'cervical', 'c7-t1', 'shoulder', 'elbow', 'fore-fetlock', 'fore-sesamoids',
|
||||
'thoracic', 't18-l1', 'lumbar', 'l6-s1', 'sacral', 'sacroiliac', 'hip', 'stifle',
|
||||
'hock', 'hind-fetlock', 'caudal',
|
||||
])
|
||||
})
|
||||
|
||||
it('every zone.id equals its record key (convention, not enforced by Zod)', () => {
|
||||
for (const key of zoneKeys) expect(catalog.zones[key].id).toBe(key)
|
||||
})
|
||||
|
||||
it('every zone has exactly 3 root categories, the third always "anamnesis"', () => {
|
||||
for (const key of zoneKeys) {
|
||||
const cats = catalog.zones[key].categories
|
||||
expect(cats, key).toHaveLength(3)
|
||||
expect(cats[2].id, key).toBe('anamnesis')
|
||||
}
|
||||
})
|
||||
|
||||
it('root category ids follow <zone>-dysfunctions / <zone>-observations, except the known sphenoid anomaly', () => {
|
||||
const anomalies: string[] = []
|
||||
for (const key of zoneKeys) {
|
||||
const [dys, obs] = catalog.zones[key].categories
|
||||
if (dys.id !== `${key}-dysfunctions`) anomalies.push(`${key}:${dys.id}`)
|
||||
if (obs.id !== `${key}-observations`) anomalies.push(`${key}:${obs.id}`)
|
||||
}
|
||||
// KNOWN: sphenoid reuses the ssb category id (audit 05 §2.4). The business
|
||||
// correction is deferred to the editor before the first official version
|
||||
// (OPEN_QUESTIONS Q9); the importer must NOT silently fix it.
|
||||
expect(anomalies).toEqual(['sphenoid:ssb-dysfunctions'])
|
||||
})
|
||||
|
||||
it('counts 792 nodes, 612 leaves, max depth 3, 228 leaves at depth 2 and 384 at depth 3', () => {
|
||||
const nodes = allNodes()
|
||||
expect(nodes).toHaveLength(792)
|
||||
const leaves = nodes.filter((n) => isLeaf(n.node))
|
||||
expect(leaves).toHaveLength(612)
|
||||
expect(Math.max(...nodes.map((n) => n.depth))).toBe(3)
|
||||
expect(leaves.filter((n) => n.depth === 2)).toHaveLength(228)
|
||||
expect(leaves.filter((n) => n.depth === 3)).toHaveLength(384)
|
||||
})
|
||||
|
||||
it('flags 41 vet-referral nodes, all of them leaves', () => {
|
||||
const flagged = allNodes().filter((n) => n.node.requires_vet_referral === true)
|
||||
expect(flagged).toHaveLength(41)
|
||||
expect(flagged.every((n) => isLeaf(n.node))).toBe(true)
|
||||
})
|
||||
|
||||
it('carries 62 description_fr, 0 description_en, 0 sources (CLAUDE.md "≥1 source" rule not met)', () => {
|
||||
const nodes = allNodes()
|
||||
expect(nodes.filter((n) => typeof n.node.description_fr === 'string')).toHaveLength(62)
|
||||
expect(nodes.filter((n) => typeof n.node.description_en === 'string')).toHaveLength(0)
|
||||
expect(nodes.filter((n) => Array.isArray(n.node.sources))).toHaveLength(0)
|
||||
})
|
||||
|
||||
it('every node has non-empty name_fr and name_en', () => {
|
||||
for (const { node, zone } of allNodes()) {
|
||||
expect(node.name_fr, `${zone}/${node.id}`).toBeTruthy()
|
||||
expect(node.name_en, `${zone}/${node.id}`).toBeTruthy()
|
||||
}
|
||||
})
|
||||
|
||||
it('node ids are unique among siblings only (same id reused across zones)', () => {
|
||||
const idCount = new Map<string, number>()
|
||||
for (const { node } of allNodes()) idCount.set(node.id, (idCount.get(node.id) ?? 0) + 1)
|
||||
expect(idCount.get('anamnesis')).toBe(26)
|
||||
expect(idCount.get('trauma-direct')).toBe(26)
|
||||
expect(idCount.get('no-identified-cause')).toBe(26)
|
||||
expect(idCount.get('amplitude-asymmetry')).toBe(11)
|
||||
// sibling uniqueness holds everywhere
|
||||
const checkSiblings = (nodes: RawNode[], where: string) => {
|
||||
const ids = nodes.map((n) => n.id)
|
||||
expect(new Set(ids).size, where).toBe(ids.length)
|
||||
for (const n of nodes) if (n.children) checkSiblings(n.children, `${where}/${n.id}`)
|
||||
}
|
||||
for (const key of zoneKeys) checkSiblings(catalog.zones[key].categories, key)
|
||||
})
|
||||
|
||||
it('anamnesis exists in exactly three content variants (vertebral / appendicular / head)', () => {
|
||||
const variants = new Map<string, string[]>()
|
||||
for (const key of zoneKeys) {
|
||||
const anam = catalog.zones[key].categories[2]
|
||||
const sig = (anam.children ?? []).map((c) => c.id).join(',')
|
||||
variants.set(sig, [...(variants.get(sig) ?? []), key])
|
||||
}
|
||||
expect(variants.size).toBe(3)
|
||||
const groups = [...variants.values()].map((g) => g.length).sort((a, b) => a - b)
|
||||
expect(groups).toEqual([8, 9, 9])
|
||||
})
|
||||
})
|
||||
@@ -1,293 +0,0 @@
|
||||
/**
|
||||
* Characterisation (Step 1): the zone-click chain of EditorRoute
|
||||
* (onZoneClick → detail / fallback / spine / bilateral / toggle), the
|
||||
* disclaimer-once-per-session rule, the zone removal and the pickers'
|
||||
* integration with the store. Exercised through the rendered route on the
|
||||
* real Horse.svg / Horse_head.svg, with loadSvg mocked to read the files.
|
||||
*
|
||||
* Limitation: the chain lives inside the route component (audit 13 §4, no
|
||||
* unit seam). These tests go through the DOM; plan Step 5 extracts the
|
||||
* chain into a service and will replace them with unit tests one-to-one.
|
||||
*/
|
||||
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
|
||||
import { render, screen, waitFor, within, cleanup } from '@testing-library/react'
|
||||
import userEvent from '@testing-library/user-event'
|
||||
import { MemoryRouter } from 'react-router-dom'
|
||||
import { readFileSync } from 'node:fs'
|
||||
import { fileURLToPath } from 'node:url'
|
||||
import { dirname, resolve } from 'node:path'
|
||||
import EditorRoute from '@/app/routes/EditorRoute'
|
||||
import { useReportStore } from '@/state/reportStore'
|
||||
import { useLocaleStore } from '@/state/localeStore'
|
||||
import { fr } from '@/i18n/fr'
|
||||
import minimal from '../fixtures/report-v2.minimal.json'
|
||||
import type { Report } from '@/domain/schema/report'
|
||||
|
||||
const HERE = dirname(fileURLToPath(import.meta.url))
|
||||
const FILES: Record<string, string> = {
|
||||
'/species/equine/Horse.svg': readFileSync(resolve(HERE, '../../public/species/equine/Horse.svg'), 'utf8'),
|
||||
'/species/equine/Horse_head.svg': readFileSync(resolve(HERE, '../../public/species/equine/Horse_head.svg'), 'utf8'),
|
||||
}
|
||||
|
||||
vi.mock('@/anatomy/svgLoader', () => ({
|
||||
loadSvg: vi.fn(async (path: string) => {
|
||||
const text = FILES[path]
|
||||
if (!text) throw new Error(`unexpected path ${path}`)
|
||||
const doc = new DOMParser().parseFromString(text, 'image/svg+xml')
|
||||
return doc.documentElement as unknown as SVGSVGElement
|
||||
}),
|
||||
}))
|
||||
|
||||
const HINGE = 'point-mpbwyyc9' // Charnière C7-T1, plain point
|
||||
const HIP = 'point-mpbwtst0' // bilateral
|
||||
const CERVICAL = 'zone-mpbx5hx2' // vertebral-precision
|
||||
const TRIGGER = 'zone-mpby55kd' // opens-detail=head
|
||||
const ATM = 'point-mpbyo7zq' // in Horse_head.svg
|
||||
|
||||
const DISCLAIMER_FLAG = 'osteo:disclaimer-shown'
|
||||
|
||||
function seedReport(observations: Report['observations'] = []) {
|
||||
useReportStore.setState({ report: null, activeObservationIndex: 0 })
|
||||
useReportStore.getState().initReport({
|
||||
...(minimal as Report),
|
||||
observations,
|
||||
} as Omit<Report, 'id' | 'createdAt' | 'version'>)
|
||||
}
|
||||
|
||||
const zonesOf = (i = 0) => useReportStore.getState().report!.observations[i].zones
|
||||
const activeIndex = () => useReportStore.getState().activeObservationIndex
|
||||
|
||||
async function mount() {
|
||||
const utils = render(
|
||||
<MemoryRouter initialEntries={['/editor']}>
|
||||
<EditorRoute />
|
||||
</MemoryRouter>,
|
||||
)
|
||||
// Main SVG rendered and parsed (bones map ready once the trigger exists).
|
||||
await waitFor(() => expect(document.querySelector(`[data-anno-id="${TRIGGER}"]`)).not.toBeNull())
|
||||
// Give the bones state effect a tick so onZoneClick resolves ids.
|
||||
await waitFor(() => expect(screen.queryByRole('dialog', { name: fr['editor.disclaimer_title'] })).toBeNull())
|
||||
return utils
|
||||
}
|
||||
|
||||
function clickZone(id: string, scope: ParentNode = document) {
|
||||
const els = scope.querySelectorAll(`[data-anno-id="${id}"]`)
|
||||
expect(els.length, id).toBeGreaterThan(0)
|
||||
els[0].dispatchEvent(new Event('click', { bubbles: true }))
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
useLocaleStore.setState({ locale: 'fr' })
|
||||
sessionStorage.clear()
|
||||
sessionStorage.setItem(DISCLAIMER_FLAG, '1')
|
||||
window.scrollTo = vi.fn() as unknown as typeof window.scrollTo
|
||||
seedReport()
|
||||
})
|
||||
|
||||
afterEach(() => {
|
||||
cleanup()
|
||||
vi.restoreAllMocks()
|
||||
})
|
||||
|
||||
describe('disclaimer', () => {
|
||||
it('shows the catalog scope_disclaimer once per session and records the flag', async () => {
|
||||
sessionStorage.removeItem(DISCLAIMER_FLAG)
|
||||
render(
|
||||
<MemoryRouter initialEntries={['/editor']}>
|
||||
<EditorRoute />
|
||||
</MemoryRouter>,
|
||||
)
|
||||
const dialog = await screen.findByRole('dialog', { name: fr['editor.disclaimer_title'] })
|
||||
expect(dialog.textContent).toContain('Aucun diagnostic médical')
|
||||
await userEvent.click(within(dialog).getByRole('button', { name: fr['common.understood'] }))
|
||||
expect(sessionStorage.getItem(DISCLAIMER_FLAG)).toBe('1')
|
||||
await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull())
|
||||
})
|
||||
})
|
||||
|
||||
describe('plain zone (toggle)', () => {
|
||||
it('adds the zone on first click and removes it on second click', async () => {
|
||||
await mount()
|
||||
clickZone(HINGE)
|
||||
await waitFor(() => expect(zonesOf()).toEqual([{ boneId: HINGE }]))
|
||||
clickZone(HINGE)
|
||||
await waitFor(() => expect(zonesOf()).toEqual([]))
|
||||
})
|
||||
|
||||
it('highlights the zone of the active observation with data-state="current"', async () => {
|
||||
await mount()
|
||||
clickZone(HINGE)
|
||||
await waitFor(() =>
|
||||
expect(document.querySelector(`[data-anno-id="${HINGE}"]`)?.getAttribute('data-state')).toBe('current'),
|
||||
)
|
||||
})
|
||||
})
|
||||
|
||||
describe('no active observation (fallback)', () => {
|
||||
it('re-activates the last observation and drops the click (user must click again)', async () => {
|
||||
await mount()
|
||||
// Collapse the only card through the UI (sets activeObservationIndex to -1).
|
||||
await userEvent.click(screen.getByRole('button', { name: `${fr['observation.collapse_aria']} 1` }))
|
||||
await waitFor(() => expect(activeIndex()).toBe(-1))
|
||||
clickZone(HINGE)
|
||||
await waitFor(() => expect(activeIndex()).toBe(0))
|
||||
expect(zonesOf()).toEqual([])
|
||||
clickZone(HINGE)
|
||||
await waitFor(() => expect(zonesOf()).toEqual([{ boneId: HINGE }]))
|
||||
})
|
||||
})
|
||||
|
||||
describe('detail trigger', () => {
|
||||
it('opens the detail modal, never adds the trigger as a zone, and zones clicked inside carry detailSourceId', async () => {
|
||||
await mount()
|
||||
clickZone(TRIGGER)
|
||||
const dialog = await screen.findByRole('dialog', { name: `${fr['editor.detail_title_prefix']}head` })
|
||||
expect(zonesOf()).toEqual([])
|
||||
await waitFor(() => expect(dialog.querySelector(`[data-anno-id="${ATM}"]`)).not.toBeNull())
|
||||
clickZone(ATM, dialog)
|
||||
await waitFor(() => expect(zonesOf()).toEqual([{ boneId: ATM, detailSourceId: 'head' }]))
|
||||
// Toggle off from inside the modal uses the same (boneId, detailSourceId) identity.
|
||||
clickZone(ATM, dialog)
|
||||
await waitFor(() => expect(zonesOf()).toEqual([]))
|
||||
})
|
||||
})
|
||||
|
||||
describe('spine zone (vertebral-precision)', () => {
|
||||
it('adds the zone, opens the picker on the matching region, and never toggles off on re-click', async () => {
|
||||
await mount()
|
||||
clickZone(CERVICAL)
|
||||
const dialog = await screen.findByRole('dialog', { name: /Préciser les vertèbres/ })
|
||||
expect(zonesOf()).toEqual([{ boneId: CERVICAL }])
|
||||
expect(within(dialog).getByRole('tab', { name: fr['vertebra.region.C'] })).toHaveAttribute('aria-selected', 'true')
|
||||
await userEvent.click(within(dialog).getByRole('button', { name: 'C3' }))
|
||||
await userEvent.click(within(dialog).getByRole('button', { name: fr['common.confirm'] }))
|
||||
await waitFor(() => expect(zonesOf()).toEqual([{ boneId: CERVICAL, vertebrae: [{ region: 'C', index: 3 }] }]))
|
||||
|
||||
clickZone(CERVICAL)
|
||||
await screen.findByRole('dialog', { name: /Préciser les vertèbres/ })
|
||||
expect(zonesOf()).toHaveLength(1)
|
||||
})
|
||||
|
||||
it('cancelling the picker leaves a spine zone without vertebrae', async () => {
|
||||
await mount()
|
||||
clickZone(CERVICAL)
|
||||
const dialog = await screen.findByRole('dialog', { name: /Préciser les vertèbres/ })
|
||||
await userEvent.click(within(dialog).getByRole('button', { name: fr['common.cancel'] }))
|
||||
await waitFor(() => expect(screen.queryByRole('dialog')).toBeNull())
|
||||
expect(zonesOf()).toEqual([{ boneId: CERVICAL }])
|
||||
})
|
||||
|
||||
it('picking another region in the picker spawns that region zone and pruning to zero removes a zone', async () => {
|
||||
await mount()
|
||||
clickZone(CERVICAL)
|
||||
let dialog = await screen.findByRole('dialog', { name: /Préciser les vertèbres/ })
|
||||
await userEvent.click(within(dialog).getByRole('button', { name: 'C3' }))
|
||||
await userEvent.click(within(dialog).getByRole('tab', { name: fr['vertebra.region.L'] }))
|
||||
await userEvent.click(within(dialog).getByRole('button', { name: 'L2' }))
|
||||
await userEvent.click(within(dialog).getByRole('button', { name: fr['common.confirm'] }))
|
||||
await waitFor(() =>
|
||||
expect(zonesOf()).toEqual([
|
||||
{ boneId: CERVICAL, vertebrae: [{ region: 'C', index: 3 }] },
|
||||
{ boneId: 'zone-mpbx1rm9', vertebrae: [{ region: 'L', index: 2 }] },
|
||||
]),
|
||||
)
|
||||
clickZone(CERVICAL)
|
||||
dialog = await screen.findByRole('dialog', { name: /Préciser les vertèbres/ })
|
||||
await userEvent.click(within(dialog).getByRole('button', { name: 'C3' })) // uncheck
|
||||
await userEvent.click(within(dialog).getByRole('button', { name: fr['common.confirm'] }))
|
||||
await waitFor(() => expect(zonesOf()).toEqual([{ boneId: 'zone-mpbx1rm9', vertebrae: [{ region: 'L', index: 2 }] }]))
|
||||
})
|
||||
})
|
||||
|
||||
describe('bilateral zone', () => {
|
||||
it('asks for a side, adds one zone per side, and clears both when both are present', async () => {
|
||||
await mount()
|
||||
clickZone(HIP)
|
||||
let dialog = await screen.findByRole('dialog', { name: 'Hanche (coxo-fémorale)' })
|
||||
await userEvent.click(within(dialog).getByRole('button', { name: fr['lateral.left'] }))
|
||||
await waitFor(() => expect(zonesOf()).toEqual([{ boneId: HIP, side: 'left' }]))
|
||||
|
||||
clickZone(HIP)
|
||||
dialog = await screen.findByRole('dialog', { name: 'Hanche (coxo-fémorale)' })
|
||||
expect(within(dialog).getByRole('button', { name: fr['lateral.left'] })).toBeDisabled()
|
||||
await userEvent.click(within(dialog).getByRole('button', { name: fr['lateral.right'] }))
|
||||
await waitFor(() =>
|
||||
expect(zonesOf()).toEqual([
|
||||
{ boneId: HIP, side: 'left' },
|
||||
{ boneId: HIP, side: 'right' },
|
||||
]),
|
||||
)
|
||||
|
||||
clickZone(HIP)
|
||||
await waitFor(() => expect(zonesOf()).toEqual([]))
|
||||
expect(screen.queryByRole('dialog')).toBeNull()
|
||||
})
|
||||
|
||||
it('"both" adds the missing sides only', async () => {
|
||||
await mount()
|
||||
clickZone(HIP)
|
||||
const dialog = await screen.findByRole('dialog', { name: 'Hanche (coxo-fémorale)' })
|
||||
await userEvent.click(within(dialog).getByRole('button', { name: fr['lateral.both'] }))
|
||||
await waitFor(() =>
|
||||
expect(zonesOf()).toEqual([
|
||||
{ boneId: HIP, side: 'left' },
|
||||
{ boneId: HIP, side: 'right' },
|
||||
]),
|
||||
)
|
||||
})
|
||||
})
|
||||
|
||||
describe('zone removal and orphan findings', () => {
|
||||
it('KNOWN: removing a zone via ✕ keeps the findings attached to its catalog zone', async () => {
|
||||
seedReport([
|
||||
{
|
||||
id: 'obs-a',
|
||||
zones: [{ boneId: HINGE }],
|
||||
findings: [
|
||||
{
|
||||
zoneId: 'c7-t1',
|
||||
path: ['c7-t1-dysfunctions', 'segmental', 'fixation'],
|
||||
labelFrSnapshot: 'Fixation de la charnière',
|
||||
labelEnSnapshot: 'Junction fixation',
|
||||
},
|
||||
],
|
||||
freeTextFindings: [],
|
||||
comment: '',
|
||||
},
|
||||
])
|
||||
await mount()
|
||||
const remove = await screen.findByRole('button', {
|
||||
name: `${fr['observation.remove_zone']} Charnière C7-T1 (cervico-thoracique)`,
|
||||
})
|
||||
await userEvent.click(remove)
|
||||
await waitFor(() => expect(zonesOf()).toEqual([]))
|
||||
expect(useReportStore.getState().report!.observations[0].findings).toHaveLength(1)
|
||||
})
|
||||
|
||||
it('shows one findings picker per (catalog zone, side) resolved by label match', async () => {
|
||||
seedReport([
|
||||
{
|
||||
id: 'obs-b',
|
||||
zones: [
|
||||
{ boneId: HIP, side: 'left' },
|
||||
{ boneId: HIP, side: 'right' },
|
||||
{ boneId: HINGE },
|
||||
{ boneId: TRIGGER },
|
||||
],
|
||||
findings: [],
|
||||
freeTextFindings: [],
|
||||
comment: '',
|
||||
},
|
||||
])
|
||||
await mount()
|
||||
await screen.findByRole('button', { name: /Hanche \(coxo-fémorale\) \(Gauche\)/ })
|
||||
screen.getByRole('button', { name: /Hanche \(coxo-fémorale\) \(Droite\)/ })
|
||||
screen.getByRole('button', { name: /^Charnière C7-T1 \(cervico-thoracique\)$/ })
|
||||
// The trigger has no label and no catalog zone: exactly 3 pickers, and its
|
||||
// badge falls back to the raw boneId.
|
||||
expect(document.querySelectorAll('[aria-controls^="findings-zone-"]')).toHaveLength(3)
|
||||
expect(
|
||||
screen.getByRole('button', { name: `${fr['observation.remove_zone']} ${TRIGGER}` }),
|
||||
).toBeInTheDocument()
|
||||
})
|
||||
})
|
||||
@@ -1,127 +0,0 @@
|
||||
/**
|
||||
* Characterisation (Step 1): dictionary keys the runtime builds dynamically
|
||||
* (severity.<fr value>, vertebra.region.<code>, import error kinds, PDF
|
||||
* section labels), label fallbacks, the species registry and the
|
||||
* scaffold script quirks (audit 12 §1).
|
||||
*/
|
||||
import { describe, it, expect, beforeEach } from 'vitest'
|
||||
import { render, screen } from '@testing-library/react'
|
||||
import { MemoryRouter } from 'react-router-dom'
|
||||
import { readFileSync } from 'node:fs'
|
||||
import { fileURLToPath } from 'node:url'
|
||||
import { dirname, resolve } from 'node:path'
|
||||
import { fr } from '@/i18n/fr'
|
||||
import { en } from '@/i18n/en'
|
||||
import { pickLocaleLabel } from '@/i18n/pickLocaleLabel'
|
||||
import { boneLabel } from '@/anatomy/labels'
|
||||
import { SeveritySchema, VertebralRegionSchema } from '@/domain/schema/observation'
|
||||
import { getAllSpecies, getSpecies, speciesLabel } from '@/domain/species/registry'
|
||||
import { EQUINE_VERTEBRAL_FORMULA } from '@/domain/species/equine/vertebrae'
|
||||
import NewReportRoute from '@/app/routes/NewReportRoute'
|
||||
import { useLocaleStore } from '@/state/localeStore'
|
||||
|
||||
const HERE = dirname(fileURLToPath(import.meta.url))
|
||||
|
||||
describe('dynamic dictionary keys', () => {
|
||||
it('has a severity.* key for every stored severity value, in both dicts', () => {
|
||||
for (const s of SeveritySchema.options) {
|
||||
expect(fr[`severity.${s}`]).toBeTruthy()
|
||||
expect(en[`severity.${s}`]).toBeTruthy()
|
||||
}
|
||||
})
|
||||
|
||||
it('has a vertebra.region.* key for every region code', () => {
|
||||
for (const r of VertebralRegionSchema.options) {
|
||||
expect(fr[`vertebra.region.${r}`]).toBeTruthy()
|
||||
expect(en[`vertebra.region.${r}`]).toBeTruthy()
|
||||
}
|
||||
})
|
||||
|
||||
it('has one message per ImportError kind plus a generic one, with a {version} placeholder', () => {
|
||||
for (const k of ['invalid_pdf', 'no_attachment', 'incompatible_version', 'generic']) {
|
||||
expect(fr[`home.import.error_${k}`]).toBeTruthy()
|
||||
expect(en[`home.import.error_${k}`]).toBeTruthy()
|
||||
}
|
||||
expect(fr['home.import.error_incompatible_version']).toContain('{version}')
|
||||
expect(en['home.import.error_incompatible_version']).toContain('{version}')
|
||||
})
|
||||
|
||||
it('exposes the PDF section and view labels used by the renderer', () => {
|
||||
for (const k of [
|
||||
'pdf.section.zones', 'pdf.section.findings_prefix', 'pdf.section.free_findings',
|
||||
'pdf.section.severity', 'pdf.section.comment', 'pdf.section.conclusion',
|
||||
'pdf.section.recommendations', 'pdf.section.next_appointment', 'pdf.view.general',
|
||||
'pdf.view.detail_prefix', 'pdf.empty', 'pdf.title.suffix.bilan', 'pdf.subject',
|
||||
]) {
|
||||
expect(fr[k], k).toBeTruthy()
|
||||
expect(en[k], k).toBeTruthy()
|
||||
}
|
||||
expect(fr['pdf.section.findings_prefix']).toBe('CONSTATS — ')
|
||||
})
|
||||
|
||||
it('carries 71 svg_editor.* keys that die with the SVG editor', () => {
|
||||
expect(Object.keys(fr).filter((k) => k.startsWith('svg_editor.'))).toHaveLength(71)
|
||||
})
|
||||
})
|
||||
|
||||
describe('label fallbacks', () => {
|
||||
it('pickLocaleLabel falls back to the other language, then to the fallback', () => {
|
||||
expect(pickLocaleLabel('FR', 'EN', 'fr')).toBe('FR')
|
||||
expect(pickLocaleLabel('', 'EN', 'fr')).toBe('EN')
|
||||
expect(pickLocaleLabel('FR', '', 'en')).toBe('FR')
|
||||
expect(pickLocaleLabel('', '', 'en', 'id')).toBe('id')
|
||||
expect(pickLocaleLabel(undefined, undefined, 'fr')).toBe('')
|
||||
})
|
||||
|
||||
it('boneLabel returns the raw fallback for an unknown bone', () => {
|
||||
expect(boneLabel(undefined, 'fr', 'point-x')).toBe('point-x')
|
||||
})
|
||||
})
|
||||
|
||||
describe('species registry', () => {
|
||||
it('registers exactly one species, equine, with the committed manifest values', () => {
|
||||
expect(getAllSpecies().map((s) => s.id)).toEqual(['equine'])
|
||||
const eq = getSpecies('equine')!
|
||||
expect(speciesLabel(eq, 'fr')).toBe('Cheval')
|
||||
expect(speciesLabel(eq, 'en')).toBe('Horse')
|
||||
expect(eq.vertebralFormula).toEqual({ C: 7, T: 18, L: 6, S: 5, Cd: 18 })
|
||||
expect(EQUINE_VERTEBRAL_FORMULA).toEqual(eq.vertebralFormula)
|
||||
})
|
||||
|
||||
it('the catalog loader resolves the same species id as the manifest', async () => {
|
||||
const m = await getSpecies('equine')!.findings()
|
||||
expect(m.default.species.id).toBe('equine')
|
||||
})
|
||||
|
||||
it('NewReportRoute defaults the species select to equine', () => {
|
||||
useLocaleStore.setState({ locale: 'fr' })
|
||||
render(
|
||||
<MemoryRouter>
|
||||
<NewReportRoute />
|
||||
</MemoryRouter>,
|
||||
)
|
||||
const select = screen.getByRole('combobox') as HTMLSelectElement
|
||||
expect(select.value).toBe('equine')
|
||||
expect(select.options).toHaveLength(1)
|
||||
})
|
||||
})
|
||||
|
||||
describe('scaffold script quirks (audit 12 §1, kept as-is, script slated for removal)', () => {
|
||||
const src = readFileSync(resolve(HERE, '../../scripts/scaffold-species.mjs'), 'utf8')
|
||||
|
||||
it("writes schema_version '1.1' while the horse catalog is at '2.0'", () => {
|
||||
expect(src).toContain("schema_version: '1.1'")
|
||||
})
|
||||
|
||||
it('defaults the vertebral formula to C7 T13 L6 S5 Cd18 (mixed canine/equine)', () => {
|
||||
expect(src).toMatch(/askPositiveInt\('\s*cervical \(C\)', 7\)/)
|
||||
expect(src).toMatch(/askPositiveInt\('\s*thoracic \(T\)', 13\)/)
|
||||
expect(src).toMatch(/askPositiveInt\('\s*lumbar \(L\)', 6\)/)
|
||||
expect(src).toMatch(/askPositiveInt\('\s*sacral \(S\)', 5\)/)
|
||||
expect(src).toMatch(/askPositiveInt\('\s*caudal \(Cd\)', 18\)/)
|
||||
})
|
||||
})
|
||||
|
||||
beforeEach(() => {
|
||||
useLocaleStore.setState({ locale: 'fr' })
|
||||
})
|
||||
@@ -1,146 +0,0 @@
|
||||
/**
|
||||
* Characterisation (Step 1): public/pathology-editor.html, the standalone
|
||||
* findings editor. Its JavaScript is extracted by text and evaluated so that
|
||||
* the inline matcher, id generator, translations and species config are
|
||||
* pinned without touching the file (BDR-020/021, LRN-026).
|
||||
*
|
||||
* Limitation: the DOM-editing behaviour (tree add/edit/delete, dirty flag,
|
||||
* download) is not executed here; it is described in
|
||||
* docs/faunosteo-audit/05-findings-editor.md §3.5 and will be re-specified
|
||||
* as tests of the merged editor (plan Step 17).
|
||||
*/
|
||||
import { describe, it, expect } from 'vitest'
|
||||
import { existsSync, readFileSync } from 'node:fs'
|
||||
import { fileURLToPath } from 'node:url'
|
||||
import { dirname, resolve } from 'node:path'
|
||||
import { parseSvgBones } from '@/anatomy/svgConvention'
|
||||
import { matchZoneFindings, normalizeLabel, scorePair } from '@/lib/zoneMatch'
|
||||
import FINDINGS from '@/domain/species/equine/pathologies'
|
||||
import { fr } from '@/i18n/fr'
|
||||
|
||||
const HERE = dirname(fileURLToPath(import.meta.url))
|
||||
const ROOT = resolve(HERE, '../..')
|
||||
const HTML = readFileSync(resolve(ROOT, 'public/pathology-editor.html'), 'utf8')
|
||||
|
||||
function slice(from: string, to: string): string {
|
||||
const a = HTML.indexOf(from)
|
||||
const b = HTML.indexOf(to, a)
|
||||
if (a < 0 || b < 0) throw new Error(`markers not found: ${from} … ${to}`)
|
||||
return HTML.slice(a, b)
|
||||
}
|
||||
|
||||
type Zone = { id: string; name_fr: string; name_en: string }
|
||||
interface InlineApi {
|
||||
normalizeLabel: (s: string) => string
|
||||
scorePair: (a: string, b: string) => number
|
||||
matchZone: (fr: string, en: string, zones: Zone[]) => Zone | null
|
||||
generateId: (en: string, fr: string, existing: string[]) => string
|
||||
}
|
||||
|
||||
const matcherSrc = slice('function normalizeLabel(s)', '// ── Node stats ──')
|
||||
const inline = new Function(
|
||||
`${matcherSrc}; return { normalizeLabel, scorePair, matchZone, generateId };`,
|
||||
)() as InlineApi
|
||||
|
||||
const translationsSrc = slice('var TRANSLATIONS = ', '\n };') + '\n };'
|
||||
const TRANSLATIONS = new Function(`${translationsSrc} return TRANSLATIONS;`)() as {
|
||||
fr: Record<string, string>
|
||||
en: Record<string, string>
|
||||
}
|
||||
|
||||
const configSrc = slice('var SPECIES_CONFIG = ', '\n ];') + '\n ];'
|
||||
const SPECIES_CONFIG = new Function(`${configSrc} return SPECIES_CONFIG;`)() as Array<{
|
||||
id: string
|
||||
labelKey: string
|
||||
jsonPath: string
|
||||
views: Array<{ labelKey: string; svgPath: string }>
|
||||
}>
|
||||
|
||||
function bones(file: string) {
|
||||
const text = readFileSync(resolve(ROOT, 'public/species/equine', file), 'utf8')
|
||||
const doc = new DOMParser().parseFromString(text, 'image/svg+xml')
|
||||
return parseSvgBones(doc.documentElement as unknown as SVGSVGElement)
|
||||
}
|
||||
|
||||
const zones = Object.values(FINDINGS.zones)
|
||||
|
||||
describe('inline matcher parity with src/lib/zoneMatch.ts', () => {
|
||||
const labels: Array<{ fr: string; en: string }> = [
|
||||
...[...bones('Horse.svg').values(), ...bones('Horse_head.svg').values()].map((b) => ({ fr: b.fr, en: b.en })),
|
||||
{ fr: 'Hanche', en: 'Hip' },
|
||||
{ fr: 'ATM', en: 'TMJ' },
|
||||
{ fr: 'Sphenoide', en: 'Sphenoidd' },
|
||||
{ fr: 'Vertèbres sacrales', en: '' },
|
||||
{ fr: '', en: '' },
|
||||
{ fr: 'Boulet ant. (métacarpo-phalangien)', en: 'Fore fetlok' },
|
||||
]
|
||||
|
||||
it('returns the same zone for every real annotation and edge label', () => {
|
||||
for (const l of labels) {
|
||||
const app = matchZoneFindings(l, zones)?.id
|
||||
const editor = inline.matchZone(l.fr, l.en, zones)?.id
|
||||
expect(editor ?? undefined, `${l.fr} / ${l.en}`).toBe(app)
|
||||
}
|
||||
})
|
||||
|
||||
it('normalizes and scores identically', () => {
|
||||
for (const s of ['Sphénoïde', 'Charnière C0-C1 (occipito-atloïdienne)', 'Temporomandibular Joint (TMJ)', '']) {
|
||||
expect(inline.normalizeLabel(s)).toBe(normalizeLabel(s))
|
||||
}
|
||||
expect(inline.scorePair('Hip', 'Hip joint')).toBe(scorePair('Hip', 'Hip joint'))
|
||||
expect(inline.scorePair('Sphenoidd', 'Sphenoid')).toBe(scorePair('Sphenoidd', 'Sphenoid'))
|
||||
expect(inline.scorePair('', 'x')).toBe(scorePair('', 'x'))
|
||||
})
|
||||
})
|
||||
|
||||
describe('inline id generator', () => {
|
||||
it('slugs name_en first, then name_fr, strips accents, suffixes -2 on sibling collision', () => {
|
||||
expect(inline.generateId('Flexion restriction', 'Restriction en flexion', [])).toBe('flexion-restriction')
|
||||
expect(inline.generateId('', 'Tension du splénius', [])).toBe('tension-du-splenius')
|
||||
expect(inline.generateId('Hip', '', ['hip'])).toBe('hip-2')
|
||||
expect(inline.generateId('Hip', '', ['hip', 'hip-2'])).toBe('hip-3')
|
||||
expect(inline.generateId('', '', [])).toBe('node')
|
||||
expect(inline.generateId(' -- ', '', [])).toBe('node')
|
||||
})
|
||||
})
|
||||
|
||||
describe('inline translations and config', () => {
|
||||
it('fr and en share the same key set (76 keys), independent from the app dictionary', () => {
|
||||
const frKeys = Object.keys(TRANSLATIONS.fr).sort()
|
||||
const enKeys = Object.keys(TRANSLATIONS.en).sort()
|
||||
expect(frKeys).toEqual(enKeys)
|
||||
expect(frKeys).toHaveLength(76)
|
||||
// No shared key space with src/i18n (different naming scheme)
|
||||
expect(frKeys.filter((k) => k in fr)).toEqual([])
|
||||
})
|
||||
|
||||
it('shares only the locale storage key with the app', () => {
|
||||
expect(HTML).toContain("localStorage.getItem('osteo:locale')")
|
||||
expect(HTML).toContain("localStorage.setItem('osteo:locale'")
|
||||
})
|
||||
|
||||
it('hard-codes a single species (equine) with two views and the public JSON copy', () => {
|
||||
expect(SPECIES_CONFIG).toHaveLength(1)
|
||||
const [equine] = SPECIES_CONFIG
|
||||
expect(equine.id).toBe('equine')
|
||||
expect(equine.jsonPath).toBe('/species/equine/pathologies.json')
|
||||
expect(equine.views.map((v) => v.svgPath)).toEqual([
|
||||
'/species/equine/Horse.svg',
|
||||
'/species/equine/Horse_head.svg',
|
||||
])
|
||||
for (const p of [equine.jsonPath, ...equine.views.map((v) => v.svgPath)]) {
|
||||
expect(existsSync(resolve(ROOT, 'public', p.slice(1))), p).toBe(true)
|
||||
}
|
||||
})
|
||||
|
||||
it('imports nothing from src/ and declares noindex', () => {
|
||||
expect(HTML).not.toMatch(/from\s+['"]\.\.?\/src/)
|
||||
expect(HTML).not.toMatch(/<script[^>]+src=/)
|
||||
expect(HTML).toMatch(/name="robots"\s+content="noindex,\s*nofollow"/)
|
||||
})
|
||||
|
||||
it('validates only three top-level keys of the loaded JSON (no Zod)', () => {
|
||||
expect(HTML).toMatch(/schema_version/)
|
||||
expect(HTML).not.toMatch(/zod/i)
|
||||
})
|
||||
})
|
||||
@@ -1,250 +0,0 @@
|
||||
/**
|
||||
* Characterisation (Step 1): the full PDF pipeline on the golden fixture
|
||||
* (every zone kind, findings with vet flag and side, free text, severity,
|
||||
* comment, conclusion, next appointment): page count, drawn text, attachment
|
||||
* roundtrip, import error kinds, and the attachment fallback path.
|
||||
*
|
||||
* Text is captured by spying on PDFPage.drawText (pdf-lib has no text
|
||||
* extraction). Rasterization is replaced by a 1×1 PNG: happy-dom has no
|
||||
* canvas. SVG fetches are served from the committed files; logo fetches 404
|
||||
* on purpose to pin the "PDF without logos" degradation.
|
||||
*/
|
||||
import { describe, it, expect, vi, beforeAll, afterAll, beforeEach } from 'vitest'
|
||||
import { AFRelationship, PDFDocument, PDFPage } from 'pdf-lib'
|
||||
import { readFileSync } from 'node:fs'
|
||||
import { fileURLToPath } from 'node:url'
|
||||
import { dirname, resolve } from 'node:path'
|
||||
import { exportReportToPdf } from '@/pdf/export'
|
||||
import { importReportFromPdf, ImportError } from '@/pdf/import'
|
||||
import { fr } from '@/i18n/fr'
|
||||
import { en } from '@/i18n/en'
|
||||
import full from '../fixtures/report-v2.full.json'
|
||||
import type { Report } from '@/domain/schema/report'
|
||||
|
||||
const ONE_PX_PNG = Uint8Array.from(
|
||||
Buffer.from(
|
||||
'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==',
|
||||
'base64',
|
||||
),
|
||||
)
|
||||
vi.mock('@/pdf/render/svgToPng', () => ({ rasterizeSvg: vi.fn(async () => ONE_PX_PNG) }))
|
||||
|
||||
const HERE = dirname(fileURLToPath(import.meta.url))
|
||||
const FILES: Record<string, string> = {
|
||||
'/species/equine/Horse.svg': readFileSync(resolve(HERE, '../../public/species/equine/Horse.svg'), 'utf8'),
|
||||
'/species/equine/Horse_head.svg': readFileSync(resolve(HERE, '../../public/species/equine/Horse_head.svg'), 'utf8'),
|
||||
}
|
||||
const fetched: string[] = []
|
||||
const realFetch = globalThis.fetch
|
||||
|
||||
beforeAll(() => {
|
||||
globalThis.fetch = (async (input: RequestInfo | URL) => {
|
||||
const url = String(input)
|
||||
fetched.push(url)
|
||||
const text = FILES[url]
|
||||
if (text) return new Response(text, { status: 200, headers: { 'content-type': 'image/svg+xml' } })
|
||||
return new Response('not found', { status: 404 })
|
||||
}) as typeof fetch
|
||||
vi.spyOn(console, 'warn').mockImplementation(() => undefined)
|
||||
})
|
||||
afterAll(() => {
|
||||
globalThis.fetch = realFetch
|
||||
})
|
||||
|
||||
const report = full as Report
|
||||
let drawn: string[] = []
|
||||
|
||||
beforeEach(() => {
|
||||
drawn = []
|
||||
fetched.length = 0
|
||||
vi.spyOn(PDFPage.prototype, 'drawText').mockImplementation(function (this: PDFPage, text: string) {
|
||||
drawn.push(text)
|
||||
} as never)
|
||||
})
|
||||
|
||||
/** Rebuilds wrapped values: lines are drawn one by one, joined by a space. */
|
||||
const joined = () => drawn.join(' ').replace(/\s+/g, ' ')
|
||||
|
||||
describe('export on the full fixture (FR)', () => {
|
||||
it('produces one page per observation plus a conclusion page', async () => {
|
||||
const bytes = await exportReportToPdf(report, { locale: 'fr' })
|
||||
const doc = await PDFDocument.load(bytes)
|
||||
expect(doc.getPageCount()).toBe(report.observations.length + 1)
|
||||
expect(doc.getTitle()).toBe(`${fr['pdf.title.suffix.bilan']}Mistral`)
|
||||
expect(doc.getAuthor()).toBe('Dr. Claire Dupont')
|
||||
})
|
||||
|
||||
it('re-fetches the SVGs from public/ and the logos at export time (external dependencies)', async () => {
|
||||
await exportReportToPdf(report, { locale: 'fr' })
|
||||
const svgFetches = fetched.filter((u) => u.endsWith('.svg') && u.includes('/species/'))
|
||||
// buildZoneLabels (2) + one colorized view per rendered image (general ×2, head ×1)
|
||||
expect(svgFetches.filter((u) => u.endsWith('Horse.svg')).length).toBeGreaterThanOrEqual(3)
|
||||
expect(svgFetches.filter((u) => u.endsWith('Horse_head.svg')).length).toBeGreaterThanOrEqual(2)
|
||||
expect(fetched.some((u) => u.includes('/assets/') && u.endsWith('.png'))).toBe(true)
|
||||
})
|
||||
|
||||
it('draws the ZONES section as bullet rows with vertebrae and side suffixes', async () => {
|
||||
await exportReportToPdf(report, { locale: 'fr' })
|
||||
expect(drawn).toContain(fr['pdf.section.zones'])
|
||||
const zonesIdx = drawn.indexOf(fr['pdf.section.zones'])
|
||||
// The ' · ' joined value is split back into one row per zone with a bullet glyph.
|
||||
expect(drawn.slice(zonesIdx + 1, zonesIdx + 6)).toEqual([
|
||||
'Charnière C7-T1 (cervico-thoracique)',
|
||||
'•',
|
||||
'Hanche (coxo-fémorale) (Gauche)',
|
||||
'•',
|
||||
'Hanche (coxo-fémorale) (Droite)',
|
||||
])
|
||||
expect(drawn).toContain('Vertèbres cervicales (C3, C4)')
|
||||
expect(drawn).toContain('Articulation Temporo-Mandibulaire (ATM)')
|
||||
})
|
||||
|
||||
it('draws one CONSTATS section per (catalog zone, side) with snapshot labels and the (!) vet marker', async () => {
|
||||
await exportReportToPdf(report, { locale: 'fr' })
|
||||
const prefix = fr['pdf.section.findings_prefix']
|
||||
expect(drawn).toContain(`${prefix}CHARNIÈRE C7-T1 (CERVICO-THORACIQUE)`)
|
||||
expect(drawn).toContain(`${prefix}HANCHE (COXO-FÉMORALE) (GAUCHE)`)
|
||||
expect(drawn).toContain(`${prefix}VERTÈBRES CERVICALES`)
|
||||
expect(drawn).toContain(`${prefix}ARTICULATION TEMPORO-MANDIBULAIRE (ATM)`)
|
||||
expect(drawn).toContain('Fixation de la charnière')
|
||||
expect(drawn).toContain('Restriction en flexion')
|
||||
expect(drawn.some((l) => l.startsWith('(!) Trébuchements'))).toBe(true)
|
||||
expect(drawn).toContain('(!) Headshaking (secouement de tête)')
|
||||
})
|
||||
|
||||
it('draws free findings, severity, comment, and the view captions', async () => {
|
||||
await exportReportToPdf(report, { locale: 'fr' })
|
||||
expect(drawn).toContain(fr['pdf.section.free_findings'])
|
||||
expect(drawn).toContain('Sensibilité au garrot')
|
||||
expect(drawn).toContain(fr['pdf.section.severity'])
|
||||
expect(drawn).toContain(fr['severity.modérée'])
|
||||
expect(drawn).toContain(fr['severity.sévère'])
|
||||
expect(drawn).toContain(fr['pdf.section.comment'])
|
||||
expect(drawn).toContain('Réagit à la palpation du garrot.')
|
||||
expect(drawn.filter((l) => l === fr['pdf.view.general'])).toHaveLength(2)
|
||||
expect(drawn).toContain(`${fr['pdf.view.detail_prefix']}HEAD`)
|
||||
})
|
||||
|
||||
it('draws the conclusion page and the header identity on every page', async () => {
|
||||
await exportReportToPdf(report, { locale: 'fr' })
|
||||
expect(drawn).toContain(fr['pdf.section.conclusion'])
|
||||
expect(drawn).toContain(fr['pdf.section.recommendations'])
|
||||
expect(drawn).toContain(fr['pdf.section.next_appointment'])
|
||||
expect(joined()).toContain('Dysfonction cervico-thoracique avec compensation du bassin.')
|
||||
expect(drawn.filter((l) => l === 'Dr. Claire Dupont').length).toBe(4)
|
||||
expect(drawn.filter((l) => l.includes('12345678901234')).length).toBe(4)
|
||||
})
|
||||
|
||||
it('uses the EN snapshots and dictionary when locale=en, same attachment bytes', async () => {
|
||||
const frBytes = await exportReportToPdf(report, { locale: 'fr' })
|
||||
const frDrawn = [...drawn]
|
||||
drawn = []
|
||||
const enBytes = await exportReportToPdf(report, { locale: 'en' })
|
||||
expect(drawn).toContain(en['pdf.section.zones'])
|
||||
expect(drawn).toContain(`${en['pdf.section.findings_prefix']}HIP JOINT (LEFT)`)
|
||||
expect(drawn).toContain('Junction fixation')
|
||||
expect(drawn).toContain('(!) Headshaking')
|
||||
expect(frDrawn).not.toContain('Junction fixation')
|
||||
const a = await importReportFromPdf(frBytes)
|
||||
const b = await importReportFromPdf(enBytes)
|
||||
expect(a).toEqual(b)
|
||||
})
|
||||
})
|
||||
|
||||
describe('roundtrip and import', () => {
|
||||
it('re-imports the full fixture unchanged (deep equality)', async () => {
|
||||
const bytes = await exportReportToPdf(report, { locale: 'fr' })
|
||||
const imported = await importReportFromPdf(bytes)
|
||||
expect(imported).toEqual(report)
|
||||
})
|
||||
|
||||
it('attaches osteo-report.json as a Flate EmbeddedFile, AFRelationship Data, description "Faunosteo state v2"', async () => {
|
||||
const bytes = await exportReportToPdf(report, { locale: 'fr' })
|
||||
const doc = await PDFDocument.load(bytes)
|
||||
const objects = [...doc.context.enumerateIndirectObjects()].map(([, o]) => String(o))
|
||||
const filespec = objects.find((s) => s.includes('/Type /Filespec'))!
|
||||
expect(filespec).toContain('/F (osteo-report.json)')
|
||||
expect(filespec).toContain('/AFRelationship /Data')
|
||||
// /Desc is a UTF-16BE hex string: "Faunosteo state v2"
|
||||
expect(filespec).toContain('/Desc <FEFF004600610075006E006F007300740065006F002000730074006100740065002000760032>')
|
||||
const embedded = objects.find((s) => s.includes('/Type /EmbeddedFile'))!
|
||||
expect(embedded).toContain('/Subtype /application#2Fjson')
|
||||
expect(embedded).toContain('/Filter /FlateDecode')
|
||||
expect(objects.some((s) => s.includes('/EmbeddedFiles'))).toBe(true)
|
||||
})
|
||||
|
||||
it('pdf-lib 1.17.1 has no getAttachments: the object-traversal fallback IS the import path', async () => {
|
||||
expect(typeof (PDFDocument.prototype as unknown as { getAttachments?: unknown }).getAttachments).toBe('undefined')
|
||||
})
|
||||
|
||||
it('reports incompatible_version with the found version for a v3 attachment', async () => {
|
||||
const doc = await PDFDocument.create()
|
||||
doc.addPage()
|
||||
await doc.attach(new TextEncoder().encode(JSON.stringify({ ...report, version: 3 })), 'osteo-report.json', {
|
||||
mimeType: 'application/json',
|
||||
afRelationship: AFRelationship.Data,
|
||||
})
|
||||
const err = await importReportFromPdf(await doc.save()).catch((e) => e)
|
||||
expect(err).toBeInstanceOf(ImportError)
|
||||
expect((err as ImportError).kind).toBe('incompatible_version')
|
||||
expect((err as ImportError).foundVersion).toBe(3)
|
||||
})
|
||||
|
||||
it('KNOWN: a foreign JSON attachment is picked up by the traversal and fails as no_attachment', async () => {
|
||||
const doc = await PDFDocument.create()
|
||||
doc.addPage()
|
||||
await doc.attach(new TextEncoder().encode('{"hello":1}'), 'other.json', {
|
||||
mimeType: 'application/json',
|
||||
afRelationship: AFRelationship.Data,
|
||||
})
|
||||
const err = await importReportFromPdf(await doc.save()).catch((e) => e)
|
||||
expect(err).toBeInstanceOf(ImportError)
|
||||
expect((err as ImportError).kind).toBe('no_attachment')
|
||||
})
|
||||
|
||||
it('KNOWN: a Zod-invalid report attachment is also reported as no_attachment (cause lost)', async () => {
|
||||
const doc = await PDFDocument.create()
|
||||
doc.addPage()
|
||||
const broken = { ...report, practitioner: { name: '' } }
|
||||
await doc.attach(new TextEncoder().encode(JSON.stringify(broken)), 'osteo-report.json', {
|
||||
mimeType: 'application/json',
|
||||
afRelationship: AFRelationship.Data,
|
||||
})
|
||||
const err = await importReportFromPdf(await doc.save()).catch((e) => e)
|
||||
expect((err as ImportError).kind).toBe('no_attachment')
|
||||
})
|
||||
|
||||
it('an orphan finding (zone removed) is still printed under its catalog zone', async () => {
|
||||
const orphaned: Report = {
|
||||
...report,
|
||||
observations: [{ ...report.observations[0], zones: [] }],
|
||||
}
|
||||
await exportReportToPdf(orphaned, { locale: 'fr' })
|
||||
expect(drawn).toContain(`${fr['pdf.section.findings_prefix']}CHARNIÈRE C7-T1 (CERVICO-THORACIQUE)`)
|
||||
expect(drawn).toContain(fr['pdf.empty'])
|
||||
})
|
||||
|
||||
it('an unknown boneId is printed raw and an unknown zoneId is printed raw', async () => {
|
||||
const stale: Report = {
|
||||
...report,
|
||||
observations: [
|
||||
{
|
||||
...report.observations[0],
|
||||
zones: [{ boneId: 'point-gone' }],
|
||||
findings: [
|
||||
{
|
||||
zoneId: 'zone-gone',
|
||||
path: ['x'],
|
||||
labelFrSnapshot: 'Snapshot FR',
|
||||
labelEnSnapshot: 'Snapshot EN',
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
}
|
||||
await exportReportToPdf(stale, { locale: 'fr' })
|
||||
expect(drawn).toContain('point-gone')
|
||||
expect(drawn).toContain(`${fr['pdf.section.findings_prefix']}ZONE-GONE`)
|
||||
expect(drawn).toContain('Snapshot FR')
|
||||
})
|
||||
})
|
||||
@@ -1,115 +0,0 @@
|
||||
/**
|
||||
* Characterisation (Step 1): what the Report v2 schema accepts or rejects,
|
||||
* what the browser persistence keeps, and the storage keys the SaaS
|
||||
* migration must read (plan Step 14 one-time draft import).
|
||||
*/
|
||||
import { describe, it, expect, beforeEach } from 'vitest'
|
||||
import { ReportSchema } from '@/domain/schema/report'
|
||||
import { ObservationSchema, VertebraSchema, SeveritySchema } from '@/domain/schema/observation'
|
||||
import { readPersistedDraft, useReportStore } from '@/state/reportStore'
|
||||
import { readCachedPractitioner, writeCachedPractitioner } from '@/state/practitionerCache'
|
||||
import { useLocaleStore } from '@/state/localeStore'
|
||||
import full from '../fixtures/report-v2.full.json'
|
||||
import minimal from '../fixtures/report-v2.minimal.json'
|
||||
import type { Report } from '@/domain/schema/report'
|
||||
|
||||
describe('Report v2 schema on the golden fixtures', () => {
|
||||
it('accepts both fixtures unchanged', () => {
|
||||
expect(ReportSchema.parse(full)).toEqual(full)
|
||||
expect(ReportSchema.parse(minimal)).toEqual(minimal)
|
||||
})
|
||||
|
||||
it('strips unknown keys silently (forward-compat fields are lost on reimport)', () => {
|
||||
const parsed = ReportSchema.parse({ ...minimal, futureField: 1, animal: { ...minimal.animal, chip: 'x' } })
|
||||
expect(parsed).toEqual(minimal)
|
||||
})
|
||||
|
||||
it('rejects version 1 and 3, accepts only the literal 2', () => {
|
||||
expect(ReportSchema.safeParse({ ...minimal, version: 1 }).success).toBe(false)
|
||||
expect(ReportSchema.safeParse({ ...minimal, version: 3 }).success).toBe(false)
|
||||
})
|
||||
|
||||
it('does not bound vertebra indexes by the species formula (C99 accepted)', () => {
|
||||
expect(VertebraSchema.safeParse({ region: 'C', index: 99 }).success).toBe(true)
|
||||
expect(VertebraSchema.safeParse({ region: 'X', index: 1 }).success).toBe(false)
|
||||
expect(VertebraSchema.safeParse({ region: 'C', index: 0 }).success).toBe(false)
|
||||
})
|
||||
|
||||
it('stores severities as French enum values', () => {
|
||||
expect(SeveritySchema.options).toEqual(['légère', 'modérée', 'sévère'])
|
||||
})
|
||||
|
||||
it('accepts findings whose zoneId matches no zone of the observation (orphans)', () => {
|
||||
const obs = { ...full.observations[0], zones: [] }
|
||||
expect(ObservationSchema.safeParse(obs).success).toBe(true)
|
||||
})
|
||||
|
||||
it('accepts a speciesId that no manifest registers (checked only at render time)', () => {
|
||||
expect(ReportSchema.safeParse({ ...minimal, animal: { speciesId: 'dragon', name: 'X' } }).success).toBe(true)
|
||||
})
|
||||
|
||||
it('accepts two zones with the same boneId and different sides, and the same boneId from main and detail', () => {
|
||||
const obs = {
|
||||
...minimal,
|
||||
observations: [
|
||||
{
|
||||
id: 'o',
|
||||
zones: [
|
||||
{ boneId: 'a', side: 'left' },
|
||||
{ boneId: 'a', side: 'right' },
|
||||
{ boneId: 'a', detailSourceId: 'head' },
|
||||
],
|
||||
findings: [],
|
||||
freeTextFindings: [],
|
||||
comment: '',
|
||||
},
|
||||
],
|
||||
}
|
||||
expect(ReportSchema.safeParse(obs).success).toBe(true)
|
||||
})
|
||||
})
|
||||
|
||||
describe('browser persistence', () => {
|
||||
beforeEach(() => {
|
||||
sessionStorage.clear()
|
||||
localStorage.clear()
|
||||
useReportStore.setState({ report: null, activeObservationIndex: 0 })
|
||||
})
|
||||
|
||||
it('mirrors the full fixture to sessionStorage["osteo:draft"] and restores it unchanged', () => {
|
||||
useReportStore.getState().hydrateReport(full as Report)
|
||||
const raw = sessionStorage.getItem('osteo:draft')
|
||||
expect(raw).not.toBeNull()
|
||||
expect(JSON.parse(raw!)).toEqual(full)
|
||||
expect(readPersistedDraft()).toEqual(full)
|
||||
})
|
||||
|
||||
it('hydrateReport does not revalidate (an invalid report can enter the store, the draft is then unreadable)', () => {
|
||||
const broken = { ...(minimal as Report), version: 7 } as unknown as Report
|
||||
useReportStore.getState().hydrateReport(broken)
|
||||
expect(useReportStore.getState().report?.version).toBe(7)
|
||||
expect(readPersistedDraft()).toBeNull()
|
||||
})
|
||||
|
||||
it('initReport creates one empty observation, a uuid id and version 2', () => {
|
||||
const { observations, ...draft } = minimal as Report
|
||||
void observations
|
||||
useReportStore.getState().initReport({ ...draft, observations: [] } as never)
|
||||
const r = useReportStore.getState().report!
|
||||
expect(r.version).toBe(2)
|
||||
expect(r.id).toMatch(/^[0-9a-f-]{36}$/)
|
||||
expect(r.observations).toHaveLength(1)
|
||||
expect(r.observations[0]).toMatchObject({ zones: [], findings: [], freeTextFindings: [], comment: '' })
|
||||
})
|
||||
|
||||
it('caches the practitioner block under localStorage["osteo:lastPractitioner"]', () => {
|
||||
writeCachedPractitioner(full.practitioner)
|
||||
expect(JSON.parse(localStorage.getItem('osteo:lastPractitioner')!)).toEqual(full.practitioner)
|
||||
expect(readCachedPractitioner()).toEqual(full.practitioner)
|
||||
})
|
||||
|
||||
it('persists the locale under localStorage["osteo:locale"] (shared with pathology-editor.html)', () => {
|
||||
useLocaleStore.getState().setLocale('en')
|
||||
expect(localStorage.getItem('osteo:locale')).toBe('en')
|
||||
})
|
||||
})
|
||||
@@ -1,222 +0,0 @@
|
||||
/**
|
||||
* Characterisation (Step 1): the real SVG assets, their attributes, the
|
||||
* SVG ↔ catalog link computed by zoneMatch, the opens-detail ↔ manifest
|
||||
* contract and the spine helpers on the real Horse.svg.
|
||||
* Oracle: docs/faunosteo-audit/06-svg-findings-link.md §4 (full table).
|
||||
*/
|
||||
import { describe, it, expect } from 'vitest'
|
||||
import { readFileSync } from 'node:fs'
|
||||
import { fileURLToPath } from 'node:url'
|
||||
import { dirname, resolve } from 'node:path'
|
||||
import { parseSvgBones } from '@/anatomy/svgConvention'
|
||||
import { matchZoneFindings, scorePair, levenshtein, normalizeLabel } from '@/lib/zoneMatch'
|
||||
import {
|
||||
regionFromLabel,
|
||||
findSpineZoneId,
|
||||
collectSpineVertebrae,
|
||||
syncSpineZones,
|
||||
} from '@/lib/spineZones'
|
||||
import { getSpecies } from '@/domain/species/registry'
|
||||
import FINDINGS from '@/domain/species/equine/pathologies'
|
||||
import type { Bone } from '@/anatomy/types'
|
||||
|
||||
const HERE = dirname(fileURLToPath(import.meta.url))
|
||||
const HORSE_TEXT = readFileSync(resolve(HERE, '../../public/species/equine/Horse.svg'), 'utf8')
|
||||
const HEAD_TEXT = readFileSync(resolve(HERE, '../../public/species/equine/Horse_head.svg'), 'utf8')
|
||||
|
||||
function parse(text: string): Map<string, Bone> {
|
||||
const doc = new DOMParser().parseFromString(text, 'image/svg+xml')
|
||||
return parseSvgBones(doc.documentElement as unknown as SVGSVGElement)
|
||||
}
|
||||
|
||||
const horse = parse(HORSE_TEXT)
|
||||
const head = parse(HEAD_TEXT)
|
||||
const zones = Object.values(FINDINGS.zones)
|
||||
|
||||
/** Expected mapping, audit 06 §4. Trigger zone-mpby55kd is intentionally absent. */
|
||||
const EXPECTED: Record<string, string> = {
|
||||
'point-mpbwrkp0': 'hind-fetlock',
|
||||
'point-mpbwsi9q': 'hock',
|
||||
'point-mpbwt4fa': 'stifle',
|
||||
'point-mpbwtst0': 'hip',
|
||||
'point-mpbwugty': 'sacroiliac',
|
||||
'point-mpbwv4xy': 'shoulder',
|
||||
'point-mpbwvpvt': 'elbow',
|
||||
'point-mpbwwaru': 'fore-fetlock',
|
||||
'point-mpbwwxvn': 'fore-sesamoids',
|
||||
'point-mpbwxnb4': 'l6-s1',
|
||||
'point-mpbwyd9i': 't18-l1',
|
||||
'point-mpbwyyc9': 'c7-t1',
|
||||
'zone-mpbx00jq': 'caudal',
|
||||
'zone-mpbx0xnp': 'sacral',
|
||||
'zone-mpbx1rm9': 'lumbar',
|
||||
'zone-mpbx2rpe': 'thoracic',
|
||||
'zone-mpbx5hx2': 'cervical',
|
||||
'point-mpbykomv': 'parietal',
|
||||
'point-mpbylh35': 'frontal',
|
||||
'point-mpbymcln': 'sphenoid',
|
||||
'point-mpbyn2k3': 'temporal',
|
||||
'point-mpbynls5': 'occipital',
|
||||
'point-mpbyo7zq': 'atm',
|
||||
'point-mpbyphay': 'ssb',
|
||||
'point-mpbyq841': 'hyoid',
|
||||
'point-mpbyqxbg': 'c0-c1',
|
||||
}
|
||||
|
||||
describe('SVG attribute census (raw text, audit 03 §10.H)', () => {
|
||||
const count = (attr: string) =>
|
||||
(HORSE_TEXT.match(new RegExp(`${attr}="`, 'g')) ?? []).length +
|
||||
(HEAD_TEXT.match(new RegExp(`${attr}="`, 'g')) ?? []).length
|
||||
|
||||
it('counts data-anno-* attributes across both files', () => {
|
||||
expect(count('data-anno-id')).toBe(48)
|
||||
expect(count('data-anno-category')).toBe(48)
|
||||
expect(count('data-anno-category-name')).toBe(18)
|
||||
expect(count('data-anno-name-fr')).toBe(47)
|
||||
expect(count('data-anno-name-en')).toBe(47)
|
||||
expect(count('data-anno-lateral')).toBe(18)
|
||||
expect(count('data-anno-special')).toBe(5)
|
||||
expect(count('data-anno-opens-detail')).toBe(1)
|
||||
})
|
||||
|
||||
it('uses only five category slugs, two of them with degraded accents', () => {
|
||||
const cats = new Set([...horse.values(), ...head.values()].map((b) => b.category))
|
||||
expect([...cats].sort()).toEqual([
|
||||
'articulations', 'cadrans-du-cr-ne', 'charni-res-vert-brales', 'os', 'zone-colonne',
|
||||
])
|
||||
})
|
||||
|
||||
it('lateral is always "bilateral", special always "vertebral-precision"', () => {
|
||||
const all = [...horse.values(), ...head.values()]
|
||||
expect(all.filter((b) => b.lateral).every((b) => b.lateral === 'bilateral')).toBe(true)
|
||||
expect(all.filter((b) => b.lateral)).toHaveLength(9)
|
||||
expect(all.filter((b) => b.special).every((b) => b.special === 'vertebral-precision')).toBe(true)
|
||||
expect(all.filter((b) => b.special)).toHaveLength(5)
|
||||
})
|
||||
|
||||
it('main and detail id spaces do not overlap (27 distinct ids)', () => {
|
||||
const ids = new Set([...horse.keys(), ...head.keys()])
|
||||
expect(ids.size).toBe(horse.size + head.size)
|
||||
expect(ids.size).toBe(27)
|
||||
})
|
||||
|
||||
it('Horse_head.svg is the same drawing as Horse.svg with a different viewBox', () => {
|
||||
expect(HORSE_TEXT).toMatch(/viewBox="0 0 2073\.4 1629\.4"/)
|
||||
expect(HEAD_TEXT).toMatch(/viewBox="60 100 500 380"/)
|
||||
const body = (t: string) => t.split('\n').slice(2, 703).join('\n')
|
||||
expect(body(HEAD_TEXT)).toBe(body(HORSE_TEXT))
|
||||
})
|
||||
})
|
||||
|
||||
describe('SVG ↔ catalog link (audit 06 §4)', () => {
|
||||
it('maps the 26 named annotations to their catalog zone, exact EN and FR match', () => {
|
||||
const all = new Map([...horse, ...head])
|
||||
for (const [id, zoneId] of Object.entries(EXPECTED)) {
|
||||
const bone = all.get(id)
|
||||
expect(bone, id).toBeDefined()
|
||||
const tree = matchZoneFindings({ fr: bone!.fr, en: bone!.en }, zones)
|
||||
expect(tree?.id, id).toBe(zoneId)
|
||||
expect(scorePair(bone!.en, tree!.name_en), `${id} EN`).toBe(0)
|
||||
expect(scorePair(bone!.fr, tree!.name_fr), `${id} FR`).toBe(0)
|
||||
}
|
||||
})
|
||||
|
||||
it('leaves the detail trigger unmatched (no FR/EN name)', () => {
|
||||
const trigger = horse.get('zone-mpby55kd')!
|
||||
expect(trigger.fr).toBe('')
|
||||
expect(trigger.en).toBe('')
|
||||
expect(trigger.opensDetail).toBe('head')
|
||||
expect(trigger.category).toBe('articulations')
|
||||
expect(matchZoneFindings({ fr: trigger.fr, en: trigger.en }, zones)).toBeUndefined()
|
||||
})
|
||||
|
||||
it('leaves no catalog zone orphaned', () => {
|
||||
const matched = new Set(Object.values(EXPECTED))
|
||||
expect(matched.size).toBe(26)
|
||||
expect(zones.map((z) => z.id).filter((id) => !matched.has(id))).toEqual([])
|
||||
})
|
||||
|
||||
it('no normalized EN or FR zone name is a substring of another (substring rule unreachable today)', () => {
|
||||
for (const lang of ['name_en', 'name_fr'] as const) {
|
||||
const norms = zones.map((z) => normalizeLabel(z[lang]))
|
||||
for (let i = 0; i < norms.length; i += 1)
|
||||
for (let j = 0; j < norms.length; j += 1)
|
||||
if (i !== j) expect(norms[i].includes(norms[j]), `${lang} ${zones[i].id} ⊃ ${zones[j].id}`).toBe(false)
|
||||
}
|
||||
})
|
||||
|
||||
it('KNOWN: two FR pairs are within the fuzzy tolerance and would collide if EN ever diverged', () => {
|
||||
const d = (a: string, b: string) => levenshtein(normalizeLabel(a), normalizeLabel(b))
|
||||
const fetlock = d('Boulet ant. (métacarpo-phalangien)', 'Boulet post. (métatarso-phalangien)')
|
||||
const spine = d('Vertèbres sacrales', 'Vertèbres caudales')
|
||||
expect(fetlock).toBe(5)
|
||||
expect(spine).toBe(3)
|
||||
expect(scorePair('Boulet ant. (métacarpo-phalangien)', 'Boulet post. (métatarso-phalangien)')).toBe(2 + 5)
|
||||
expect(scorePair('Vertèbres sacrales', 'Vertèbres caudales')).toBe(2 + 3)
|
||||
})
|
||||
})
|
||||
|
||||
describe('opens-detail ↔ species manifest', () => {
|
||||
const species = getSpecies('equine')!
|
||||
|
||||
it('every opens-detail value is a key of species.details, and every key has one trigger', () => {
|
||||
const triggers = [...horse.values()].filter((b) => b.opensDetail).map((b) => b.opensDetail!)
|
||||
expect(triggers).toEqual(['head'])
|
||||
for (const key of triggers) expect(species.details[key]).toBeDefined()
|
||||
expect(Object.keys(species.details)).toEqual(['head'])
|
||||
})
|
||||
|
||||
it('the detail SVG carries no trigger of its own (one level of detail)', () => {
|
||||
expect([...head.values()].some((b) => b.opensDetail)).toBe(false)
|
||||
})
|
||||
|
||||
it('manifest paths point at the two committed files', () => {
|
||||
expect(species.mainSvg).toBe('/species/equine/Horse.svg')
|
||||
expect(species.details.head).toBe('/species/equine/Horse_head.svg')
|
||||
})
|
||||
})
|
||||
|
||||
describe('spine helpers on the real Horse.svg', () => {
|
||||
it('resolves each region to its zone-colonne polygon by label', () => {
|
||||
expect(findSpineZoneId('C', horse)).toBe('zone-mpbx5hx2')
|
||||
expect(findSpineZoneId('T', horse)).toBe('zone-mpbx2rpe')
|
||||
expect(findSpineZoneId('L', horse)).toBe('zone-mpbx1rm9')
|
||||
expect(findSpineZoneId('S', horse)).toBe('zone-mpbx0xnp')
|
||||
expect(findSpineZoneId('Cd', horse)).toBe('zone-mpbx00jq')
|
||||
})
|
||||
|
||||
it('KNOWN: hinge labels also resolve to a region, but hinges have no special so it is never used', () => {
|
||||
expect(regionFromLabel(horse.get('point-mpbwyyc9')!.fr)).toBe('C')
|
||||
expect(horse.get('point-mpbwyyc9')!.special).toBeUndefined()
|
||||
})
|
||||
|
||||
it('spawns a lumbar zone from scratch and keeps a joint zone untouched', () => {
|
||||
const next = syncSpineZones([{ boneId: 'point-mpbwtst0', side: 'left' }], [{ region: 'L', index: 2 }], horse)
|
||||
expect(next).toEqual([
|
||||
{ boneId: 'point-mpbwtst0', side: 'left' },
|
||||
{ boneId: 'zone-mpbx1rm9', vertebrae: [{ region: 'L', index: 2 }] },
|
||||
])
|
||||
})
|
||||
|
||||
it('collects vertebrae across spine zones with the clicked zone first', () => {
|
||||
const zonesSel = [
|
||||
{ boneId: 'zone-mpbx5hx2', vertebrae: [{ region: 'C' as const, index: 3 }] },
|
||||
{ boneId: 'zone-mpbx1rm9', vertebrae: [{ region: 'L' as const, index: 1 }] },
|
||||
]
|
||||
expect(collectSpineVertebrae(zonesSel, horse, 'zone-mpbx1rm9')).toEqual([
|
||||
{ region: 'L', index: 1 },
|
||||
{ region: 'C', index: 3 },
|
||||
])
|
||||
})
|
||||
|
||||
it('detail-sourced zones never count as spine zones', () => {
|
||||
const next = syncSpineZones(
|
||||
[{ boneId: 'zone-mpbx5hx2', detailSourceId: 'head' }],
|
||||
[{ region: 'C', index: 1 }],
|
||||
horse,
|
||||
)
|
||||
// passes through untouched, then a fresh cervical zone is spawned
|
||||
expect(next[0]).toEqual({ boneId: 'zone-mpbx5hx2', detailSourceId: 'head' })
|
||||
expect(next[1]).toEqual({ boneId: 'zone-mpbx5hx2', vertebrae: [{ region: 'C', index: 1 }] })
|
||||
})
|
||||
})
|
||||
@@ -1,39 +1,110 @@
|
||||
import { describe, it, expect, vi, beforeEach } from 'vitest'
|
||||
import { render, screen, waitFor } from '@testing-library/react'
|
||||
import { beforeAll, describe, expect, it, vi, afterEach } from 'vitest'
|
||||
import { cleanup, render, waitFor } from '@testing-library/react'
|
||||
import AnatomyCanvas from '@/components/canvas/AnatomyCanvas'
|
||||
import { buildViewSvg, parseDrawing, sanitizeSvg } from '@/anatomy/drawing'
|
||||
import type { SheetIndex } from '@/services/sheetIndex'
|
||||
import { loadTestSheet } from '../helpers/sheet'
|
||||
|
||||
vi.mock('@/anatomy/svgLoader', () => ({
|
||||
loadSvg: vi.fn(async () => {
|
||||
const doc = new DOMParser().parseFromString(
|
||||
`<svg xmlns="http://www.w3.org/2000/svg">
|
||||
<circle data-anno-id="epaule" data-anno-name-fr="Épaule" data-anno-name-en="Shoulder"
|
||||
data-anno-category="articulation" class="bone osteo articulation hitbox bone-epaule" />
|
||||
<circle data-anno-id="epaule" data-anno-name-fr="Épaule" data-anno-name-en="Shoulder"
|
||||
data-anno-category="articulation" class="bone osteo articulation visible bone-epaule" />
|
||||
</svg>`,
|
||||
'image/svg+xml',
|
||||
)
|
||||
return doc.documentElement as unknown as SVGSVGElement
|
||||
}),
|
||||
}))
|
||||
let sheet: SheetIndex
|
||||
beforeAll(async () => {
|
||||
sheet = await loadTestSheet()
|
||||
})
|
||||
afterEach(cleanup)
|
||||
|
||||
beforeEach(() => vi.clearAllMocks())
|
||||
|
||||
describe('AnatomyCanvas', () => {
|
||||
it('renders the loaded SVG inline', async () => {
|
||||
render(<AnatomyCanvas src="/x.svg" boneStates={new Map()} onZoneClick={() => {}} />)
|
||||
await waitFor(() =>
|
||||
expect(document.querySelector('[data-anno-id="epaule"]')).not.toBeNull(),
|
||||
describe('buildViewSvg', () => {
|
||||
it('frames the main view on the asset box and the head view on its crop of the same drawing', () => {
|
||||
const main = buildViewSvg(sheet, 'main', new Map())
|
||||
const head = buildViewSvg(sheet, 'head', new Map())
|
||||
expect(main.getAttribute('viewBox')).toBe('0 0 2073.4 1629.4')
|
||||
expect(head.getAttribute('viewBox')).toBe('60 100 500 380')
|
||||
expect(main.querySelectorAll('path').length).toBe(
|
||||
head.querySelectorAll('path').length,
|
||||
)
|
||||
expect(main.querySelectorAll('[data-layer="annotations"]')).toHaveLength(1)
|
||||
expect(main.querySelectorAll('[data-anno-id="hip"]')).toHaveLength(2)
|
||||
expect(head.querySelectorAll('[data-anno-id="hip"]')).toHaveLength(0)
|
||||
expect(head.querySelectorAll('[data-anno-id="atm"]')).toHaveLength(2)
|
||||
expect(main.hasAttribute('width')).toBe(false)
|
||||
})
|
||||
|
||||
it('calls onZoneClick with the clicked bone id', async () => {
|
||||
const onZoneClick = vi.fn()
|
||||
render(<AnatomyCanvas src="/x.svg" boneStates={new Map()} onZoneClick={onZoneClick} />)
|
||||
await waitFor(() => screen.getByTestId('anatomy-canvas'))
|
||||
;(document.querySelector('[data-anno-id="epaule"]') as Element).dispatchEvent(
|
||||
new Event('click', { bubbles: true }),
|
||||
it('applies states as data-state on the generated markers', () => {
|
||||
const svg = buildViewSvg(sheet, 'main', new Map([['stifle', 'current']]))
|
||||
const marked = Array.from(
|
||||
svg.querySelectorAll('[data-state="current"]'),
|
||||
).map((el) => el.getAttribute('data-anno-id'))
|
||||
expect(marked).toEqual(['stifle', 'stifle'])
|
||||
})
|
||||
|
||||
it('sanitises scripts, embedded documents and handlers out of an asset', () => {
|
||||
const root = parseDrawing(
|
||||
'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1 1"><script>alert(1)</script><g onclick="x()"><a href="javascript:void(0)"><path d="M0 0"/></a></g><foreignObject/></svg>',
|
||||
)
|
||||
await waitFor(() => expect(onZoneClick).toHaveBeenCalledWith('epaule'))
|
||||
sanitizeSvg(root)
|
||||
expect(root.querySelector('script')).toBeNull()
|
||||
expect(root.querySelector('foreignObject')).toBeNull()
|
||||
expect(root.querySelector('g')!.hasAttribute('onclick')).toBe(false)
|
||||
expect(root.querySelector('a')!.hasAttribute('href')).toBe(false)
|
||||
expect(root.querySelector('path')).not.toBeNull()
|
||||
expect(() => parseDrawing('<not svg')).toThrow()
|
||||
})
|
||||
})
|
||||
|
||||
describe('AnatomyCanvas', () => {
|
||||
it('renders the view and delegates clicks on the generated markers to onZoneClick with the view id', async () => {
|
||||
const onZoneClick = vi.fn()
|
||||
const { container } = render(
|
||||
<AnatomyCanvas
|
||||
index={sheet}
|
||||
viewId="main"
|
||||
states={new Map()}
|
||||
onZoneClick={onZoneClick}
|
||||
/>,
|
||||
)
|
||||
await waitFor(() =>
|
||||
expect(
|
||||
container.querySelector('[data-anno-id="head-trigger"]'),
|
||||
).not.toBeNull(),
|
||||
)
|
||||
const hip = container.querySelector('circle[data-anno-id="hip"]')!
|
||||
hip.dispatchEvent(new Event('click', { bubbles: true }))
|
||||
expect(onZoneClick).toHaveBeenCalledWith('hip', 'main')
|
||||
container
|
||||
.querySelector('path')!
|
||||
.dispatchEvent(new Event('click', { bubbles: true }))
|
||||
expect(onZoneClick).toHaveBeenCalledTimes(1)
|
||||
})
|
||||
|
||||
it('restyles in place when the states change', async () => {
|
||||
const { container, rerender } = render(
|
||||
<AnatomyCanvas
|
||||
index={sheet}
|
||||
viewId="main"
|
||||
states={new Map()}
|
||||
onZoneClick={() => undefined}
|
||||
/>,
|
||||
)
|
||||
await waitFor(() =>
|
||||
expect(container.querySelector('[data-anno-id="hip"]')).not.toBeNull(),
|
||||
)
|
||||
rerender(
|
||||
<AnatomyCanvas
|
||||
index={sheet}
|
||||
viewId="main"
|
||||
states={new Map([['hip', 'current']])}
|
||||
onZoneClick={() => undefined}
|
||||
/>,
|
||||
)
|
||||
expect(
|
||||
container.querySelectorAll('[data-anno-id="hip"][data-state="current"]'),
|
||||
).toHaveLength(2)
|
||||
rerender(
|
||||
<AnatomyCanvas
|
||||
index={sheet}
|
||||
viewId="main"
|
||||
states={new Map()}
|
||||
onZoneClick={() => undefined}
|
||||
/>,
|
||||
)
|
||||
expect(container.querySelectorAll('[data-state="current"]')).toHaveLength(0)
|
||||
})
|
||||
})
|
||||
@@ -1,298 +1,112 @@
|
||||
import { describe, it, expect, vi, beforeEach } from 'vitest'
|
||||
import { render, screen } from '@testing-library/react'
|
||||
import {
|
||||
beforeAll,
|
||||
describe,
|
||||
expect,
|
||||
it,
|
||||
vi,
|
||||
afterEach,
|
||||
beforeEach,
|
||||
} from 'vitest'
|
||||
import { cleanup, render, screen } from '@testing-library/react'
|
||||
import userEvent from '@testing-library/user-event'
|
||||
import type { Finding } from '@faunosteo/domain'
|
||||
import FindingsTreePicker from '@/components/observation/FindingsTreePicker'
|
||||
import type { ZoneFindings } from '@/domain/schema/findings'
|
||||
import type { Finding } from '@/domain/schema/observation'
|
||||
import { useLocaleStore } from '@/state/localeStore'
|
||||
import type { SheetIndex } from '@/services/sheetIndex'
|
||||
import { loadTestSheet } from '../helpers/sheet'
|
||||
|
||||
beforeEach(() => {
|
||||
// Navigator-detected default may land on EN in happy-dom; force FR so the
|
||||
// FR-label assertions in this file remain stable regardless of the runner's
|
||||
// navigator.language.
|
||||
useLocaleStore.setState({ locale: 'fr' })
|
||||
let sheet: SheetIndex
|
||||
beforeAll(async () => {
|
||||
sheet = await loadTestSheet()
|
||||
})
|
||||
beforeEach(() => useLocaleStore.setState({ locale: 'fr' }))
|
||||
afterEach(cleanup)
|
||||
|
||||
const TREE: ZoneFindings = {
|
||||
id: 'sphenoid',
|
||||
name_fr: 'Sphénoïde',
|
||||
name_en: 'Sphenoid',
|
||||
categories: [
|
||||
{
|
||||
id: 'dysfunctions',
|
||||
name_fr: 'Dysfonctions',
|
||||
name_en: 'Dysfunctions',
|
||||
children: [
|
||||
{
|
||||
id: 'flexion',
|
||||
name_fr: 'Flexion',
|
||||
name_en: 'Flexion',
|
||||
description_fr: 'Description test',
|
||||
},
|
||||
{
|
||||
id: 'extension',
|
||||
name_fr: 'Extension',
|
||||
name_en: 'Extension',
|
||||
requires_vet_referral: true,
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
}
|
||||
|
||||
describe('FindingsTreePicker', () => {
|
||||
it('renders the zone name in the initial breadcrumb', () => {
|
||||
describe('FindingsTreePicker on a sheet finding zone', () => {
|
||||
it('drills down the hip zone and selects a leaf as a v3 finding with snapshots and side', async () => {
|
||||
const user = userEvent.setup()
|
||||
const onChange = vi.fn()
|
||||
render(
|
||||
<FindingsTreePicker
|
||||
zoneId="sphenoid"
|
||||
tree={TREE}
|
||||
selected={[]}
|
||||
onChange={() => {}}
|
||||
/>,
|
||||
)
|
||||
expect(screen.getByText('Sphénoïde')).toBeInTheDocument()
|
||||
})
|
||||
|
||||
it('drills into a category and shows leaves', async () => {
|
||||
render(
|
||||
<FindingsTreePicker
|
||||
zoneId="sphenoid"
|
||||
tree={TREE}
|
||||
selected={[]}
|
||||
onChange={() => {}}
|
||||
/>,
|
||||
)
|
||||
await userEvent.click(screen.getByLabelText('Ouvrir Dysfonctions'))
|
||||
expect(screen.getByLabelText('Flexion')).toBeInTheDocument()
|
||||
expect(screen.getByLabelText('Extension')).toBeInTheDocument()
|
||||
})
|
||||
|
||||
it('emits a Finding with snapshot labels on leaf select', async () => {
|
||||
const onChange = vi.fn<(next: Finding[]) => void>()
|
||||
render(
|
||||
<FindingsTreePicker
|
||||
zoneId="sphenoid"
|
||||
tree={TREE}
|
||||
zone={sheet.findingZone('hip')!}
|
||||
side="left"
|
||||
selected={[]}
|
||||
onChange={onChange}
|
||||
/>,
|
||||
)
|
||||
await userEvent.click(screen.getByLabelText('Ouvrir Dysfonctions'))
|
||||
await userEvent.click(screen.getByLabelText('Flexion'))
|
||||
expect(onChange).toHaveBeenCalledTimes(1)
|
||||
expect(onChange.mock.calls[0][0]).toEqual([
|
||||
expect(screen.getByText('Hanche (coxo-fémorale)')).toBeInTheDocument()
|
||||
await user.click(
|
||||
screen.getByRole('button', {
|
||||
name: 'Ouvrir Dysfonctions ostéopathiques',
|
||||
}),
|
||||
)
|
||||
await user.click(
|
||||
screen.getByRole('button', {
|
||||
name: 'Ouvrir Restrictions de mobilité articulaire',
|
||||
}),
|
||||
)
|
||||
await user.click(
|
||||
screen.getByRole('checkbox', { name: 'Restriction en flexion' }),
|
||||
)
|
||||
expect(onChange).toHaveBeenCalledWith([
|
||||
{
|
||||
zoneId: 'sphenoid',
|
||||
path: ['dysfunctions', 'flexion'],
|
||||
labelFrSnapshot: 'Flexion',
|
||||
labelEnSnapshot: 'Flexion',
|
||||
findingZoneId: 'hip',
|
||||
path: ['hip-dysfunctions', 'articular', 'restriction-flexion'],
|
||||
labelFrSnapshot: 'Restriction en flexion',
|
||||
labelEnSnapshot: 'Flexion restriction',
|
||||
side: 'left',
|
||||
},
|
||||
])
|
||||
})
|
||||
|
||||
it('flags vet-referral leaves with requiresVetReferral on selection', async () => {
|
||||
const onChange = vi.fn<(next: Finding[]) => void>()
|
||||
render(
|
||||
<FindingsTreePicker
|
||||
zoneId="sphenoid"
|
||||
tree={TREE}
|
||||
selected={[]}
|
||||
onChange={onChange}
|
||||
/>,
|
||||
)
|
||||
await userEvent.click(screen.getByLabelText('Ouvrir Dysfonctions'))
|
||||
await userEvent.click(screen.getByLabelText('Extension'))
|
||||
expect(onChange.mock.calls[0][0][0].requiresVetReferral).toBe(true)
|
||||
})
|
||||
|
||||
it('deselects a previously selected leaf', async () => {
|
||||
const onChange = vi.fn<(next: Finding[]) => void>()
|
||||
it('shows descriptions in the active locale, the vet marker, counts, and unselects', async () => {
|
||||
const user = userEvent.setup()
|
||||
useLocaleStore.setState({ locale: 'en' })
|
||||
const selected: Finding[] = [
|
||||
{
|
||||
zoneId: 'sphenoid',
|
||||
path: ['dysfunctions', 'flexion'],
|
||||
labelFrSnapshot: 'Flexion',
|
||||
labelEnSnapshot: 'Flexion',
|
||||
findingZoneId: 'hip',
|
||||
path: ['hip-dysfunctions', 'articular', 'hypermobility'],
|
||||
labelFrSnapshot: 'x',
|
||||
labelEnSnapshot: 'x',
|
||||
requiresVetReferral: true,
|
||||
},
|
||||
]
|
||||
const onChange = vi.fn()
|
||||
render(
|
||||
<FindingsTreePicker
|
||||
zoneId="sphenoid"
|
||||
tree={TREE}
|
||||
zone={sheet.findingZone('hip')!}
|
||||
selected={selected}
|
||||
onChange={onChange}
|
||||
/>,
|
||||
)
|
||||
await userEvent.click(screen.getByLabelText('Ouvrir Dysfonctions'))
|
||||
await userEvent.click(screen.getByLabelText('Flexion'))
|
||||
expect(screen.getByLabelText('1 finding selected')).toBeInTheDocument()
|
||||
await user.click(
|
||||
screen.getByRole('button', { name: 'Open Osteopathic dysfunctions' }),
|
||||
)
|
||||
await user.click(
|
||||
screen.getByRole('button', {
|
||||
name: 'Open Articular mobility restrictions',
|
||||
}),
|
||||
)
|
||||
expect(
|
||||
screen.getByText(/Perceived laxity may indicate a ligament injury/),
|
||||
).toBeInTheDocument()
|
||||
expect(
|
||||
screen.getAllByLabelText('Refer to a veterinarian').length,
|
||||
).toBeGreaterThan(0)
|
||||
const box = screen.getByRole('checkbox', {
|
||||
name: 'Hypermobility / perceived laxity',
|
||||
})
|
||||
expect(box).toBeChecked()
|
||||
await user.click(box)
|
||||
expect(onChange).toHaveBeenCalledWith([])
|
||||
})
|
||||
|
||||
it('navigates back to parent via the Retour button', async () => {
|
||||
render(
|
||||
<FindingsTreePicker
|
||||
zoneId="sphenoid"
|
||||
tree={TREE}
|
||||
selected={[]}
|
||||
onChange={() => {}}
|
||||
/>,
|
||||
await user.click(
|
||||
screen.getByRole('button', { name: 'Back to previous level' }),
|
||||
)
|
||||
await userEvent.click(screen.getByLabelText('Ouvrir Dysfonctions'))
|
||||
expect(screen.getByLabelText('Flexion')).toBeInTheDocument()
|
||||
await userEvent.click(screen.getByLabelText('Retour au niveau précédent'))
|
||||
expect(screen.getByLabelText('Ouvrir Dysfonctions')).toBeInTheDocument()
|
||||
})
|
||||
})
|
||||
|
||||
const DEEP_TREE: ZoneFindings = {
|
||||
id: 'atm',
|
||||
name_fr: 'ATM',
|
||||
name_en: 'TMJ',
|
||||
categories: [
|
||||
{
|
||||
id: 'dysf',
|
||||
name_fr: 'Dysfonctions ostéopathiques de l\'ATM',
|
||||
name_en: 'Osteopathic dysfunctions of the TMJ',
|
||||
children: [
|
||||
{
|
||||
id: 'tensions',
|
||||
name_fr: 'Tensions des muscles masticateurs',
|
||||
name_en: 'Masticatory muscle tensions',
|
||||
children: [
|
||||
{
|
||||
id: 'temporal',
|
||||
name_fr: 'Tension du temporal',
|
||||
name_en: 'Temporal tension',
|
||||
},
|
||||
{
|
||||
id: 'pterygo',
|
||||
name_fr: 'Tension des ptérygoïdiens',
|
||||
name_en: 'Pterygoid tension',
|
||||
},
|
||||
{
|
||||
id: 'masseter',
|
||||
name_fr: 'Tension des masséters',
|
||||
name_en: 'Masseter tension',
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
id: 'capsule',
|
||||
name_fr: 'Dysfonction capsulaire',
|
||||
name_en: 'Capsular dysfunction',
|
||||
children: [
|
||||
{ id: 'cap-ant', name_fr: 'Antérieure', name_en: 'Anterior' },
|
||||
{ id: 'cap-post', name_fr: 'Postérieure', name_en: 'Posterior' },
|
||||
],
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
}
|
||||
|
||||
describe('FindingsTreePicker selection counts on intermediate nodes', () => {
|
||||
const selected: Finding[] = [
|
||||
{
|
||||
zoneId: 'atm',
|
||||
path: ['dysf', 'tensions', 'temporal'],
|
||||
labelFrSnapshot: 'Tension du temporal',
|
||||
labelEnSnapshot: 'Temporal tension',
|
||||
},
|
||||
{
|
||||
zoneId: 'atm',
|
||||
path: ['dysf', 'tensions', 'pterygo'],
|
||||
labelFrSnapshot: 'Tension des ptérygoïdiens',
|
||||
labelEnSnapshot: 'Pterygoid tension',
|
||||
},
|
||||
]
|
||||
|
||||
it('shows a count badge of 2 on the top-level category when two descendant leaves are selected', () => {
|
||||
render(
|
||||
<FindingsTreePicker
|
||||
zoneId="atm"
|
||||
tree={DEEP_TREE}
|
||||
selected={selected}
|
||||
onChange={() => {}}
|
||||
/>,
|
||||
)
|
||||
// Root view: only the top-level "Dysfonctions..." category is visible.
|
||||
expect(
|
||||
screen.getByLabelText('2 constats sélectionnés'),
|
||||
screen.getByRole('button', {
|
||||
name: 'Open Articular mobility restrictions',
|
||||
}),
|
||||
).toBeInTheDocument()
|
||||
})
|
||||
|
||||
it('shows a count badge of 2 on the sub-category one level deeper', async () => {
|
||||
render(
|
||||
<FindingsTreePicker
|
||||
zoneId="atm"
|
||||
tree={DEEP_TREE}
|
||||
selected={selected}
|
||||
onChange={() => {}}
|
||||
/>,
|
||||
)
|
||||
await userEvent.click(
|
||||
screen.getByLabelText('Ouvrir Dysfonctions ostéopathiques de l\'ATM'),
|
||||
)
|
||||
// Now we see "Tensions des muscles masticateurs" (2 leaves selected)
|
||||
// and "Dysfonction capsulaire" (0 leaves selected — no badge).
|
||||
expect(
|
||||
screen.getByLabelText('2 constats sélectionnés'),
|
||||
).toBeInTheDocument()
|
||||
})
|
||||
|
||||
it('does not show a badge for siblings without selected descendants', async () => {
|
||||
render(
|
||||
<FindingsTreePicker
|
||||
zoneId="atm"
|
||||
tree={DEEP_TREE}
|
||||
selected={selected}
|
||||
onChange={() => {}}
|
||||
/>,
|
||||
)
|
||||
await userEvent.click(
|
||||
screen.getByLabelText('Ouvrir Dysfonctions ostéopathiques de l\'ATM'),
|
||||
)
|
||||
// Capsular dysfunction has no selections — the button should not carry a badge label.
|
||||
const capsular = screen.getByLabelText('Ouvrir Dysfonction capsulaire')
|
||||
expect(capsular.textContent ?? '').not.toMatch(/\d/)
|
||||
})
|
||||
|
||||
it('shows a singular badge label for exactly one selection', () => {
|
||||
const oneSelected: Finding[] = [selected[0]]
|
||||
render(
|
||||
<FindingsTreePicker
|
||||
zoneId="atm"
|
||||
tree={DEEP_TREE}
|
||||
selected={oneSelected}
|
||||
onChange={() => {}}
|
||||
/>,
|
||||
)
|
||||
expect(
|
||||
screen.getByLabelText('1 constat sélectionné'),
|
||||
).toBeInTheDocument()
|
||||
})
|
||||
|
||||
it('ignores selections from other zones when counting', () => {
|
||||
const cross: Finding[] = [
|
||||
{
|
||||
zoneId: 'sphenoid',
|
||||
path: ['dysf', 'tensions', 'temporal'],
|
||||
labelFrSnapshot: 'Tension du temporal',
|
||||
labelEnSnapshot: 'Temporal tension',
|
||||
},
|
||||
]
|
||||
render(
|
||||
<FindingsTreePicker
|
||||
zoneId="atm"
|
||||
tree={DEEP_TREE}
|
||||
selected={cross}
|
||||
onChange={() => {}}
|
||||
/>,
|
||||
)
|
||||
// No badge should appear on the ATM tree — the lone selected finding
|
||||
// belongs to a different zone.
|
||||
expect(
|
||||
screen.queryByLabelText(/constat sélectionné/),
|
||||
).not.toBeInTheDocument()
|
||||
})
|
||||
})
|
||||
@@ -11,8 +11,14 @@ beforeEach(() => {
|
||||
describe('LanguageSwitcher', () => {
|
||||
it('reflects the active locale via aria-pressed', () => {
|
||||
render(<LanguageSwitcher />)
|
||||
expect(screen.getByRole('button', { name: /français/i })).toHaveAttribute('aria-pressed', 'true')
|
||||
expect(screen.getByRole('button', { name: /english/i })).toHaveAttribute('aria-pressed', 'false')
|
||||
expect(screen.getByRole('button', { name: /français/i })).toHaveAttribute(
|
||||
'aria-pressed',
|
||||
'true',
|
||||
)
|
||||
expect(screen.getByRole('button', { name: /english/i })).toHaveAttribute(
|
||||
'aria-pressed',
|
||||
'false',
|
||||
)
|
||||
})
|
||||
|
||||
it('clicking EN updates the store', async () => {
|
||||
|
||||
@@ -1,104 +1,87 @@
|
||||
import { describe, it, expect, vi, beforeEach } from 'vitest'
|
||||
import { render, screen } from '@testing-library/react'
|
||||
import {
|
||||
beforeAll,
|
||||
describe,
|
||||
expect,
|
||||
it,
|
||||
vi,
|
||||
afterEach,
|
||||
beforeEach,
|
||||
} from 'vitest'
|
||||
import { cleanup, render, screen } from '@testing-library/react'
|
||||
import userEvent from '@testing-library/user-event'
|
||||
import VertebraPicker from '@/components/observation/VertebraPicker'
|
||||
import { regionFromLabel } from '@/lib/spineZones'
|
||||
import { EQUINE_VERTEBRAL_FORMULA } from '@/domain/species/equine/vertebrae'
|
||||
import { useLocaleStore } from '@/state/localeStore'
|
||||
import type { SheetIndex } from '@/services/sheetIndex'
|
||||
import { loadTestSheet } from '../helpers/sheet'
|
||||
|
||||
beforeEach(() => {
|
||||
useLocaleStore.setState({ locale: 'fr' })
|
||||
let sheet: SheetIndex
|
||||
beforeAll(async () => {
|
||||
sheet = await loadTestSheet()
|
||||
})
|
||||
beforeEach(() => useLocaleStore.setState({ locale: 'fr' }))
|
||||
afterEach(cleanup)
|
||||
|
||||
describe('VertebraPicker', () => {
|
||||
it('renders region tabs based on the formula', () => {
|
||||
render(
|
||||
<VertebraPicker
|
||||
open
|
||||
onClose={() => {}}
|
||||
onConfirm={() => {}}
|
||||
initial={[]}
|
||||
formula={EQUINE_VERTEBRAL_FORMULA}
|
||||
title="Vertèbres cervicales"
|
||||
/>,
|
||||
)
|
||||
expect(screen.getByRole('tab', { name: /Cervicales/ })).toBeInTheDocument()
|
||||
expect(screen.getByRole('tab', { name: /Thoraciques/ })).toBeInTheDocument()
|
||||
})
|
||||
function mount(initialRegion?: string, onConfirm = vi.fn()) {
|
||||
render(
|
||||
<VertebraPicker
|
||||
open
|
||||
onClose={() => undefined}
|
||||
onConfirm={onConfirm}
|
||||
initial={[{ region: 'C', index: 3 }]}
|
||||
regions={sheet.regions()}
|
||||
title="Vertèbres"
|
||||
initialRegion={initialRegion}
|
||||
/>,
|
||||
)
|
||||
return onConfirm
|
||||
}
|
||||
|
||||
it('toggles a chip and confirms', async () => {
|
||||
const onConfirm = vi.fn()
|
||||
render(
|
||||
<VertebraPicker
|
||||
open
|
||||
onClose={() => {}}
|
||||
onConfirm={onConfirm}
|
||||
initial={[]}
|
||||
formula={EQUINE_VERTEBRAL_FORMULA}
|
||||
title="Vertèbres thoraciques"
|
||||
/>,
|
||||
)
|
||||
await userEvent.click(screen.getByRole('tab', { name: /Thoraciques/ }))
|
||||
await userEvent.click(screen.getByRole('button', { name: 'T12' }))
|
||||
await userEvent.click(screen.getByRole('button', { name: 'Valider' }))
|
||||
expect(onConfirm).toHaveBeenCalledWith([{ region: 'T', index: 12 }])
|
||||
})
|
||||
|
||||
it('preselects the tab matching initialRegion', () => {
|
||||
render(
|
||||
<VertebraPicker
|
||||
open
|
||||
onClose={() => {}}
|
||||
onConfirm={() => {}}
|
||||
initial={[]}
|
||||
formula={EQUINE_VERTEBRAL_FORMULA}
|
||||
title="Vertèbres lombaires"
|
||||
initialRegion="L"
|
||||
/>,
|
||||
)
|
||||
expect(screen.getByRole('tab', { name: /Lombaires/ })).toHaveAttribute(
|
||||
describe('VertebraPicker on the sheet regions', () => {
|
||||
it('shows one tab per region of the sheet, named from the document, opening on the asked region', () => {
|
||||
mount('L')
|
||||
const tabs = screen.getAllByRole('tab').map((t) => t.textContent)
|
||||
expect(tabs).toEqual([
|
||||
'Cervicales',
|
||||
'Thoraciques',
|
||||
'Lombaires',
|
||||
'Sacrales',
|
||||
'Caudales',
|
||||
])
|
||||
expect(screen.getByRole('tab', { name: 'Lombaires' })).toHaveAttribute(
|
||||
'aria-selected',
|
||||
'true',
|
||||
)
|
||||
expect(screen.getByText('L6')).toBeInTheDocument()
|
||||
expect(screen.queryByText('L7')).toBeNull()
|
||||
})
|
||||
|
||||
it('opens on initialRegion even when other regions are pre-selected', () => {
|
||||
render(
|
||||
<VertebraPicker
|
||||
open
|
||||
onClose={() => {}}
|
||||
onConfirm={() => {}}
|
||||
initial={[{ region: 'S', index: 2 }]}
|
||||
formula={EQUINE_VERTEBRAL_FORMULA}
|
||||
title="Vertèbres cervicales"
|
||||
initialRegion="C"
|
||||
/>,
|
||||
)
|
||||
expect(screen.getByRole('tab', { name: /Cervicales/ })).toHaveAttribute(
|
||||
'aria-selected',
|
||||
'true',
|
||||
it('shows the usual count and extends to the documented maximum (D6)', async () => {
|
||||
const user = userEvent.setup()
|
||||
mount('Cd')
|
||||
expect(screen.getByText('Cd18')).toBeInTheDocument()
|
||||
expect(screen.queryByText('Cd21')).toBeNull()
|
||||
await user.click(
|
||||
screen.getByRole('button', { name: "Afficher jusqu'à 21" }),
|
||||
)
|
||||
expect(screen.getByText('Cd21')).toBeInTheDocument()
|
||||
expect(
|
||||
screen.getByText(/Nombre usuel : 18 ; variation documentée : 15 à 21/),
|
||||
).toBeInTheDocument()
|
||||
await user.click(screen.getByRole('tab', { name: 'Cervicales' }))
|
||||
expect(screen.queryByRole('button', { name: /Afficher jusqu/ })).toBeNull()
|
||||
})
|
||||
})
|
||||
|
||||
describe('regionFromLabel', () => {
|
||||
it('matches FR roots (accent-insensitive)', () => {
|
||||
expect(regionFromLabel('Vertèbres cervicales')).toBe('C')
|
||||
expect(regionFromLabel('Vertèbres thoraciques')).toBe('T')
|
||||
expect(regionFromLabel('Vertèbres lombaires')).toBe('L')
|
||||
expect(regionFromLabel('Vertèbres sacrales')).toBe('S')
|
||||
expect(regionFromLabel('Vertèbres caudales')).toBe('Cd')
|
||||
})
|
||||
|
||||
it('matches EN roots', () => {
|
||||
expect(regionFromLabel('Cervical Vertebrae')).toBe('C')
|
||||
expect(regionFromLabel('Thoracic Vertebrae')).toBe('T')
|
||||
expect(regionFromLabel('Lumbar Vertebrae')).toBe('L')
|
||||
expect(regionFromLabel('Coccygeal Vertebrae')).toBe('Cd')
|
||||
})
|
||||
|
||||
it('returns undefined when no root matches', () => {
|
||||
expect(regionFromLabel('Épaule')).toBeUndefined()
|
||||
expect(regionFromLabel('')).toBeUndefined()
|
||||
it('toggles vertebrae and confirms the selection across regions', async () => {
|
||||
const user = userEvent.setup()
|
||||
const onConfirm = mount('C')
|
||||
await user.click(screen.getByText('C5'))
|
||||
await user.click(screen.getByRole('tab', { name: 'Thoraciques' }))
|
||||
await user.click(screen.getByText('T2'))
|
||||
await user.click(screen.getByRole('button', { name: 'Valider' }))
|
||||
expect(onConfirm).toHaveBeenCalledWith([
|
||||
{ region: 'C', index: 3 },
|
||||
{ region: 'C', index: 5 },
|
||||
{ region: 'T', index: 2 },
|
||||
])
|
||||
})
|
||||
})
|
||||
@@ -1,120 +0,0 @@
|
||||
import { describe, it, expect } from 'vitest'
|
||||
import {
|
||||
findSpineZoneId,
|
||||
collectSpineVertebrae,
|
||||
syncSpineZones,
|
||||
} from '@/lib/spineZones'
|
||||
import type { Bone } from '@/anatomy/types'
|
||||
import type { ObservationZone, Vertebra } from '@/domain/schema/observation'
|
||||
|
||||
function spine(id: string, fr: string, en: string): Bone {
|
||||
return { id, fr, en, category: 'zone-colonne', special: 'vertebral-precision', els: [] }
|
||||
}
|
||||
|
||||
const BONES = new Map<string, Bone>([
|
||||
['z-c', spine('z-c', 'Vertèbres cervicales', 'Cervical Vertebrae')],
|
||||
['z-t', spine('z-t', 'Vertèbres thoraciques', 'Thoracic Vertebrae')],
|
||||
['z-l', spine('z-l', 'Vertèbres lombaires', 'Lumbar Vertebrae')],
|
||||
['z-s', spine('z-s', 'Vertèbres sacrales', 'Sacral Vertebrae')],
|
||||
['z-cd', spine('z-cd', 'Vertèbres caudales', 'Coccygeal Vertebrae')],
|
||||
['z-shoulder', { id: 'z-shoulder', fr: 'Épaule', en: 'Shoulder', category: 'zone', els: [] }],
|
||||
])
|
||||
|
||||
const v = (region: Vertebra['region'], index: number): Vertebra => ({ region, index })
|
||||
|
||||
describe('findSpineZoneId', () => {
|
||||
it('maps each region to its spine zone', () => {
|
||||
expect(findSpineZoneId('C', BONES)).toBe('z-c')
|
||||
expect(findSpineZoneId('T', BONES)).toBe('z-t')
|
||||
expect(findSpineZoneId('L', BONES)).toBe('z-l')
|
||||
expect(findSpineZoneId('S', BONES)).toBe('z-s')
|
||||
expect(findSpineZoneId('Cd', BONES)).toBe('z-cd')
|
||||
})
|
||||
|
||||
it('returns undefined when no spine zone exists for a region', () => {
|
||||
const only = new Map([['z-l', BONES.get('z-l')!]])
|
||||
expect(findSpineZoneId('C', only)).toBeUndefined()
|
||||
})
|
||||
})
|
||||
|
||||
describe('collectSpineVertebrae', () => {
|
||||
it('unions vertebrae across all spine zones', () => {
|
||||
const zones: ObservationZone[] = [
|
||||
{ boneId: 'z-l', vertebrae: [v('L', 1), v('L', 2)] },
|
||||
{ boneId: 'z-c', vertebrae: [v('C', 3)] },
|
||||
]
|
||||
expect(collectSpineVertebrae(zones, BONES)).toEqual([v('L', 1), v('L', 2), v('C', 3)])
|
||||
})
|
||||
|
||||
it('lists the priority zone vertebrae first', () => {
|
||||
const zones: ObservationZone[] = [
|
||||
{ boneId: 'z-c', vertebrae: [v('C', 3)] },
|
||||
{ boneId: 'z-l', vertebrae: [v('L', 1)] },
|
||||
]
|
||||
expect(collectSpineVertebrae(zones, BONES, 'z-l')).toEqual([v('L', 1), v('C', 3)])
|
||||
})
|
||||
|
||||
it('ignores non-spine zones and dedups', () => {
|
||||
const zones: ObservationZone[] = [
|
||||
{ boneId: 'z-shoulder' },
|
||||
{ boneId: 'z-l', vertebrae: [v('L', 1), v('L', 1)] },
|
||||
]
|
||||
expect(collectSpineVertebrae(zones, BONES)).toEqual([v('L', 1)])
|
||||
})
|
||||
})
|
||||
|
||||
describe('syncSpineZones', () => {
|
||||
it('keeps same-region vertebrae on the existing zone', () => {
|
||||
const zones: ObservationZone[] = [{ boneId: 'z-l' }]
|
||||
const next = syncSpineZones(zones, [v('L', 1), v('L', 2)], BONES)
|
||||
expect(next).toEqual([{ boneId: 'z-l', vertebrae: [v('L', 1), v('L', 2)] }])
|
||||
})
|
||||
|
||||
it('spawns a new zone for a newly picked region', () => {
|
||||
const zones: ObservationZone[] = [{ boneId: 'z-l' }]
|
||||
const next = syncSpineZones(zones, [v('L', 1), v('C', 3)], BONES)
|
||||
expect(next).toHaveLength(2)
|
||||
expect(next[0]).toEqual({ boneId: 'z-l', vertebrae: [v('L', 1)] })
|
||||
expect(next[1]).toEqual({ boneId: 'z-c', vertebrae: [v('C', 3)] })
|
||||
})
|
||||
|
||||
it('replaces a region authoritatively (deselection sticks)', () => {
|
||||
const zones: ObservationZone[] = [
|
||||
{ boneId: 'z-l', vertebrae: [v('L', 1), v('L', 2)] },
|
||||
{ boneId: 'z-c', vertebrae: [v('C', 2), v('C', 3)] },
|
||||
]
|
||||
const next = syncSpineZones(zones, [v('L', 1), v('C', 3)], BONES)
|
||||
expect(next).toHaveLength(2)
|
||||
expect(next[0].vertebrae).toEqual([v('L', 1)])
|
||||
expect(next[1].vertebrae).toEqual([v('C', 3)])
|
||||
})
|
||||
|
||||
it('prunes a spine zone whose region dropped to zero', () => {
|
||||
const zones: ObservationZone[] = [
|
||||
{ boneId: 'z-l', vertebrae: [v('L', 1)] },
|
||||
{ boneId: 'z-c', vertebrae: [v('C', 1)] },
|
||||
]
|
||||
const next = syncSpineZones(zones, [v('C', 1)], BONES)
|
||||
expect(next).toEqual([{ boneId: 'z-c', vertebrae: [v('C', 1)] }])
|
||||
})
|
||||
|
||||
it('preserves non-spine zones untouched', () => {
|
||||
const zones: ObservationZone[] = [
|
||||
{ boneId: 'z-shoulder' },
|
||||
{ boneId: 'z-l', vertebrae: [v('L', 1)] },
|
||||
]
|
||||
const next = syncSpineZones(zones, [v('L', 2)], BONES)
|
||||
expect(next).toEqual([
|
||||
{ boneId: 'z-shoulder' },
|
||||
{ boneId: 'z-l', vertebrae: [v('L', 2)] },
|
||||
])
|
||||
})
|
||||
|
||||
it('drops vertebrae of a region with no spine zone in the SVG', () => {
|
||||
const noCervical = new Map(BONES)
|
||||
noCervical.delete('z-c')
|
||||
const zones: ObservationZone[] = [{ boneId: 'z-l', vertebrae: [v('L', 1)] }]
|
||||
const next = syncSpineZones(zones, [v('L', 1), v('C', 2)], noCervical)
|
||||
expect(next).toEqual([{ boneId: 'z-l', vertebrae: [v('L', 1)] }])
|
||||
})
|
||||
})
|
||||
@@ -1,154 +0,0 @@
|
||||
import { describe, it, expect } from 'vitest'
|
||||
import {
|
||||
normalizeLabel,
|
||||
levenshtein,
|
||||
scorePair,
|
||||
matchZoneFindings,
|
||||
} from '@/lib/zoneMatch'
|
||||
import type { ZoneFindings } from '@/domain/schema/findings'
|
||||
|
||||
const ZONES: ZoneFindings[] = [
|
||||
{
|
||||
id: 'sphenoid',
|
||||
name_fr: 'Sphénoïde',
|
||||
name_en: 'Sphenoid',
|
||||
categories: [],
|
||||
},
|
||||
{
|
||||
id: 'ssb',
|
||||
name_fr: 'Synchondrose Sphéno-Basilaire (SSB)',
|
||||
name_en: 'Spheno-Basilar Synchondrosis (SBS)',
|
||||
categories: [],
|
||||
},
|
||||
{
|
||||
id: 'atm',
|
||||
name_fr: 'Articulation Temporo-Mandibulaire (ATM)',
|
||||
name_en: 'Temporomandibular Joint (TMJ)',
|
||||
categories: [],
|
||||
},
|
||||
]
|
||||
|
||||
describe('normalizeLabel', () => {
|
||||
it('lowercases, strips accents and non-alphanumerics', () => {
|
||||
expect(normalizeLabel('Sphénoïde')).toBe('sphenoide')
|
||||
})
|
||||
|
||||
it('strips parens and whitespace', () => {
|
||||
expect(normalizeLabel('Articulation Temporo-Mandibulaire (ATM)')).toBe(
|
||||
'articulationtemporomandibulaireatm',
|
||||
)
|
||||
})
|
||||
|
||||
it('keeps short bare labels intact', () => {
|
||||
expect(normalizeLabel('(ATM)')).toBe('atm')
|
||||
})
|
||||
|
||||
it('returns empty string for nullish inputs', () => {
|
||||
expect(normalizeLabel(undefined)).toBe('')
|
||||
expect(normalizeLabel(null)).toBe('')
|
||||
expect(normalizeLabel('')).toBe('')
|
||||
})
|
||||
})
|
||||
|
||||
describe('levenshtein', () => {
|
||||
it('returns 0 for identical strings', () => {
|
||||
expect(levenshtein('abc', 'abc')).toBe(0)
|
||||
})
|
||||
|
||||
it('handles classic textbook case', () => {
|
||||
expect(levenshtein('kitten', 'sitting')).toBe(3)
|
||||
})
|
||||
|
||||
it('returns length when one string is empty', () => {
|
||||
expect(levenshtein('', 'abc')).toBe(3)
|
||||
expect(levenshtein('abc', '')).toBe(3)
|
||||
})
|
||||
|
||||
it('costs 1 per single-char typo', () => {
|
||||
expect(levenshtein('sphenoide', 'sphenoid')).toBe(1)
|
||||
expect(levenshtein('shenoide', 'sphenoide')).toBe(1)
|
||||
})
|
||||
})
|
||||
|
||||
describe('scorePair', () => {
|
||||
it('scores exact normalized matches at 0', () => {
|
||||
expect(scorePair('Sphenoid', 'Sphénoïde')).toBeGreaterThan(-1)
|
||||
expect(scorePair('Sphenoid', 'sphenoid')).toBe(0)
|
||||
})
|
||||
|
||||
it('scores substring matches at 1', () => {
|
||||
expect(scorePair('(ATM)', 'Articulation Temporo-Mandibulaire (ATM)')).toBe(1)
|
||||
})
|
||||
|
||||
it('routes a substring hit ("sphenoide" contains "sphenoid") to score 1', () => {
|
||||
expect(scorePair('sphenoide', 'sphenoid')).toBe(1)
|
||||
})
|
||||
|
||||
it('routes a pure-edit typo to Levenshtein scoring (2+d)', () => {
|
||||
expect(scorePair('shenoide', 'sphenoid')).toBeGreaterThanOrEqual(2)
|
||||
expect(scorePair('shenoide', 'sphenoid')).toBeLessThanOrEqual(5)
|
||||
})
|
||||
|
||||
it('returns infinity for unrelated strings', () => {
|
||||
expect(scorePair('Sphenoid', 'Synchondrose Sphéno-Basilaire (SSB)')).toBe(
|
||||
Number.POSITIVE_INFINITY,
|
||||
)
|
||||
})
|
||||
|
||||
it('rejects empty inputs', () => {
|
||||
expect(scorePair('', 'Sphenoid')).toBe(Number.POSITIVE_INFINITY)
|
||||
expect(scorePair('Sphenoid', '')).toBe(Number.POSITIVE_INFINITY)
|
||||
})
|
||||
})
|
||||
|
||||
describe('matchZoneFindings', () => {
|
||||
it('matches the SVG Sphenoid bone to the sphenoid zone via EN exact', () => {
|
||||
const z = matchZoneFindings({ fr: 'Sphénoïde', en: 'Sphenoid' }, ZONES)
|
||||
expect(z?.id).toBe('sphenoid')
|
||||
})
|
||||
|
||||
it('matches the SVG SSB bone to the ssb zone via EN exact', () => {
|
||||
const z = matchZoneFindings(
|
||||
{ fr: 'Synchondrose Sphéno-Basilaire (SSB)', en: 'Spheno-Basilar Synchondrosis (SBS)' },
|
||||
ZONES,
|
||||
)
|
||||
expect(z?.id).toBe('ssb')
|
||||
})
|
||||
|
||||
it('matches the SVG ATM bone to the atm zone', () => {
|
||||
const z = matchZoneFindings(
|
||||
{ fr: 'Articulation Temporo-Mandibulaire (ATM)', en: 'Temporomandibular Joint (TMJ)' },
|
||||
ZONES,
|
||||
)
|
||||
expect(z?.id).toBe('atm')
|
||||
})
|
||||
|
||||
it('matches via FR-only labels when EN is empty', () => {
|
||||
const z = matchZoneFindings({ fr: 'Sphénoïde', en: '' }, ZONES)
|
||||
expect(z?.id).toBe('sphenoid')
|
||||
})
|
||||
|
||||
it('matches abbreviation typed alone via substring', () => {
|
||||
const z = matchZoneFindings({ fr: '(ATM)', en: '' }, ZONES)
|
||||
expect(z?.id).toBe('atm')
|
||||
})
|
||||
|
||||
it('tolerates small typos via Levenshtein', () => {
|
||||
expect(matchZoneFindings({ fr: '', en: 'sphenoide' }, ZONES)?.id).toBe('sphenoid')
|
||||
expect(matchZoneFindings({ fr: '', en: 'shenoide' }, ZONES)?.id).toBe('sphenoid')
|
||||
expect(matchZoneFindings({ fr: '', en: 'sphenoi' }, ZONES)?.id).toBe('sphenoid')
|
||||
})
|
||||
|
||||
it('returns undefined for clearly unrelated zones', () => {
|
||||
expect(matchZoneFindings({ fr: 'Hanche (coxo-fémorale)', en: 'Hip joint' }, ZONES)).toBeUndefined()
|
||||
expect(matchZoneFindings({ fr: 'hyoïde', en: 'Hyoid' }, ZONES)).toBeUndefined()
|
||||
})
|
||||
|
||||
it('does not collapse Sphenoid into the SSB zone', () => {
|
||||
expect(matchZoneFindings({ fr: 'Sphénoïde', en: 'Sphenoid' }, ZONES)?.id).toBe('sphenoid')
|
||||
})
|
||||
|
||||
it('returns undefined when the catalog is empty', () => {
|
||||
expect(matchZoneFindings({ fr: 'Sphénoïde', en: 'Sphenoid' }, [])).toBeUndefined()
|
||||
})
|
||||
})
|
||||
@@ -10,7 +10,9 @@ async function deflate(data: Uint8Array): Promise<Uint8Array> {
|
||||
|
||||
describe('inflateFlate decompression cap', () => {
|
||||
it('inflates a normal-size payload', async () => {
|
||||
const payload = new TextEncoder().encode(JSON.stringify({ version: 2, hello: 'world' }))
|
||||
const payload = new TextEncoder().encode(
|
||||
JSON.stringify({ version: 2, hello: 'world' }),
|
||||
)
|
||||
const out = await inflateFlate(await deflate(payload))
|
||||
expect(out).not.toBeNull()
|
||||
expect(new TextDecoder().decode(out!)).toContain('hello')
|
||||
|
||||
@@ -1,33 +1,30 @@
|
||||
import { describe, it, expect } from 'vitest'
|
||||
import { describe, it, expect, beforeAll } from 'vitest'
|
||||
import { PDFDocument } from 'pdf-lib'
|
||||
import { attachReportJson, extractReportJson } from '@/pdf/attachment'
|
||||
import type { Report } from '@/domain/schema/report'
|
||||
import type { SheetIndex } from '@/services/sheetIndex'
|
||||
import { loadTestSheet, minimalReport } from '../helpers/sheet'
|
||||
|
||||
const report: Report = {
|
||||
version: 2,
|
||||
id: 'r1',
|
||||
createdAt: '2026-05-18T10:00:00Z',
|
||||
date: '2026-05-18',
|
||||
practitioner: { name: 'Dr. Dupont' },
|
||||
animal: { speciesId: 'equine', name: 'Mistral' },
|
||||
owner: { name: 'Jean Martin' },
|
||||
observations: [],
|
||||
conclusion: 'tout va bien',
|
||||
recommendations: 'continuer',
|
||||
}
|
||||
let sheet: SheetIndex
|
||||
beforeAll(async () => {
|
||||
sheet = await loadTestSheet()
|
||||
})
|
||||
|
||||
describe('PDF attachment roundtrip', () => {
|
||||
it('attaches and extracts the report JSON', async () => {
|
||||
it('attaches and extracts the v3 report JSON', async () => {
|
||||
const doc = await PDFDocument.create()
|
||||
doc.addPage()
|
||||
await attachReportJson(doc, report)
|
||||
await attachReportJson(
|
||||
doc,
|
||||
minimalReport(sheet, { conclusion: 'tout va bien' }),
|
||||
)
|
||||
const bytes = await doc.save()
|
||||
|
||||
const reopened = await PDFDocument.load(bytes)
|
||||
const out = await extractReportJson(reopened)
|
||||
expect(out.conclusion).toBe('tout va bien')
|
||||
expect(out.animal.name).toBe('Mistral')
|
||||
expect(out.version).toBe(2)
|
||||
const out = await extractReportJson(reopened, sheet.sheet.migrationMap)
|
||||
expect(out.report.conclusion).toBe('tout va bien')
|
||||
expect(out.report.animal.name).toBe('Mistral')
|
||||
expect(out.report.version).toBe(3)
|
||||
expect(out.migrated).toBe(false)
|
||||
})
|
||||
|
||||
it('throws on PDFs without the attachment', async () => {
|
||||
@@ -35,6 +32,8 @@ describe('PDF attachment roundtrip', () => {
|
||||
doc.addPage()
|
||||
const bytes = await doc.save()
|
||||
const reopened = await PDFDocument.load(bytes)
|
||||
await expect(extractReportJson(reopened)).rejects.toThrow()
|
||||
await expect(
|
||||
extractReportJson(reopened, sheet.sheet.migrationMap),
|
||||
).rejects.toThrow()
|
||||
})
|
||||
})
|
||||
@@ -1,112 +1,312 @@
|
||||
import { describe, it, expect, vi } from 'vitest'
|
||||
import { AFRelationship, PDFDocument } from 'pdf-lib'
|
||||
/**
|
||||
* Replaces char.pdfFull / pdf.roundtrip / pdf.zoneLabels: the v3 pipeline on
|
||||
* the bundled sheet (drawn strings from the document, attachment v3,
|
||||
* roundtrip FR/EN) and the import of the frozen v2 archive PDFs, migrated
|
||||
* without silent loss.
|
||||
*/
|
||||
import {
|
||||
describe,
|
||||
it,
|
||||
expect,
|
||||
vi,
|
||||
beforeAll,
|
||||
beforeEach,
|
||||
afterAll,
|
||||
} from 'vitest'
|
||||
import { PDFDocument, PDFPage } from 'pdf-lib'
|
||||
import { readFileSync } from 'node:fs'
|
||||
import { fileURLToPath } from 'node:url'
|
||||
import { dirname, resolve } from 'node:path'
|
||||
import type { Observation } from '@faunosteo/domain'
|
||||
import { exportReportToPdf } from '@/pdf/export'
|
||||
import { importReportFromPdf, ImportError } from '@/pdf/import'
|
||||
import { embedFonts } from '@/pdf/fonts'
|
||||
import type { Report } from '@/domain/schema/report'
|
||||
import { highlightedViewSvg } from '@/pdf/render/observationPage'
|
||||
import { fr } from '@/i18n/fr'
|
||||
import type { SheetIndex } from '@/services/sheetIndex'
|
||||
import { loadTestSheet, minimalReport } from '../helpers/sheet'
|
||||
|
||||
vi.mock('@/pdf/render/svgToPng', () => ({ rasterizeSvg: async () => new Uint8Array([137, 80, 78, 71]) }))
|
||||
const ONE_PX_PNG = Uint8Array.from(
|
||||
Buffer.from(
|
||||
'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==',
|
||||
'base64',
|
||||
),
|
||||
)
|
||||
vi.mock('@/pdf/render/svgToPng', () => ({
|
||||
rasterizeSvg: vi.fn(async () => ONE_PX_PNG),
|
||||
}))
|
||||
|
||||
const report: Report = {
|
||||
version: 2,
|
||||
id: 'r1',
|
||||
createdAt: '2026-05-18T10:00:00Z',
|
||||
date: '2026-05-18',
|
||||
practitioner: { name: 'Dr. Dupont' },
|
||||
animal: { speciesId: 'equine', name: 'Mistral' },
|
||||
owner: { name: 'Jean Martin' },
|
||||
observations: [],
|
||||
conclusion: 'ok',
|
||||
recommendations: '',
|
||||
const HERE = dirname(fileURLToPath(import.meta.url))
|
||||
const fixture = (name: string) =>
|
||||
new Uint8Array(readFileSync(resolve(HERE, '../fixtures', name)))
|
||||
|
||||
let sheet: SheetIndex
|
||||
let drawn: string[] = []
|
||||
const realFetch = globalThis.fetch
|
||||
|
||||
beforeAll(async () => {
|
||||
sheet = await loadTestSheet()
|
||||
globalThis.fetch = (async () =>
|
||||
new Response('not found', { status: 404 })) as typeof fetch
|
||||
vi.spyOn(console, 'warn').mockImplementation(() => undefined)
|
||||
})
|
||||
afterAll(() => {
|
||||
globalThis.fetch = realFetch
|
||||
})
|
||||
beforeEach(() => {
|
||||
drawn = []
|
||||
vi.spyOn(PDFPage.prototype, 'drawText').mockImplementation(function (
|
||||
this: PDFPage,
|
||||
text: string,
|
||||
) {
|
||||
drawn.push(text)
|
||||
} as never)
|
||||
})
|
||||
|
||||
/** A full v3 observation: plain zone, bilateral both sides, spine with vertebrae, head zone, findings. */
|
||||
function fullObservation(): Observation {
|
||||
return {
|
||||
id: 'obs-full',
|
||||
zones: [
|
||||
{ annotationId: 'c7-t1', viewId: 'main' },
|
||||
{ annotationId: 'hip', viewId: 'main', side: 'left' },
|
||||
{ annotationId: 'hip', viewId: 'main', side: 'right' },
|
||||
{
|
||||
annotationId: 'cervical',
|
||||
viewId: 'main',
|
||||
vertebrae: [
|
||||
{ region: 'C', index: 3 },
|
||||
{ region: 'C', index: 4 },
|
||||
],
|
||||
},
|
||||
{ annotationId: 'atm', viewId: 'head' },
|
||||
],
|
||||
findings: [
|
||||
{
|
||||
findingZoneId: 'c7-t1',
|
||||
path: ['c7-t1-dysfunctions', 'segmental', 'fixation'],
|
||||
labelFrSnapshot: 'Fixation de la charnière',
|
||||
labelEnSnapshot: 'Junction fixation',
|
||||
},
|
||||
{
|
||||
findingZoneId: 'hip',
|
||||
path: ['hip-dysfunctions', 'articular', 'restriction-flexion'],
|
||||
labelFrSnapshot: 'Restriction en flexion',
|
||||
labelEnSnapshot: 'Flexion restriction',
|
||||
side: 'left',
|
||||
},
|
||||
{
|
||||
findingZoneId: 'atm',
|
||||
path: ['atm-consultation-reasons', 'headshaking'],
|
||||
labelFrSnapshot: 'Headshaking (secouement de tête)',
|
||||
labelEnSnapshot: 'Headshaking',
|
||||
requiresVetReferral: true,
|
||||
unresolved: true,
|
||||
},
|
||||
],
|
||||
freeTextFindings: ['Sensibilité au garrot'],
|
||||
severity: 'moderate',
|
||||
comment: 'note',
|
||||
}
|
||||
}
|
||||
|
||||
describe('PDF roundtrip', () => {
|
||||
it('rejects unrelated PDF bytes with ImportError', async () => {
|
||||
const fake = new Uint8Array([37, 80, 68, 70, 45, 49, 46, 52, 10, 37, 226, 227, 207, 211, 10])
|
||||
await expect(importReportFromPdf(fake)).rejects.toThrow(ImportError)
|
||||
})
|
||||
|
||||
it('roundtrips a minimal report (no observations)', async () => {
|
||||
const bytes = await exportReportToPdf(report, { locale: 'fr' })
|
||||
const imported = await importReportFromPdf(bytes)
|
||||
expect(imported.animal.name).toBe('Mistral')
|
||||
expect(imported.version).toBe(2)
|
||||
})
|
||||
|
||||
it('roundtrips a report exported with locale=fr', async () => {
|
||||
const bytes = await exportReportToPdf(report, { locale: 'fr' })
|
||||
const imported = await importReportFromPdf(bytes)
|
||||
expect(imported.animal.name).toBe('Mistral')
|
||||
expect(imported.version).toBe(2)
|
||||
})
|
||||
|
||||
it('roundtrips a report exported with locale=en', async () => {
|
||||
const bytes = await exportReportToPdf(report, { locale: 'en' })
|
||||
const imported = await importReportFromPdf(bytes)
|
||||
expect(imported.animal.name).toBe('Mistral')
|
||||
expect(imported.version).toBe(2)
|
||||
})
|
||||
|
||||
it('FR and EN exports both produce non-empty byte streams', async () => {
|
||||
// pdf-lib subsets fonts (LRN-016), so plain-text grep over the bytes
|
||||
// is unreliable. The imported JSON is the strongest invariant — the
|
||||
// locale lives outside the Report, so both imports return the same
|
||||
// payload while the static label snapshots differ inside the PDF.
|
||||
const fr = await exportReportToPdf(report, { locale: 'fr' })
|
||||
const en = await exportReportToPdf(report, { locale: 'en' })
|
||||
expect(fr.byteLength).toBeGreaterThan(0)
|
||||
expect(en.byteLength).toBeGreaterThan(0)
|
||||
const frImported = await importReportFromPdf(fr)
|
||||
const enImported = await importReportFromPdf(en)
|
||||
expect(frImported.animal.name).toBe(enImported.animal.name)
|
||||
expect(frImported.version).toBe(enImported.version)
|
||||
})
|
||||
|
||||
it('vet-referral marker is encodable by the body font (regression: WinAnsi cannot encode U+26A0)', async () => {
|
||||
// observationPage prefixes vet-referral leaves with a marker that
|
||||
// is rendered using the WinAnsi-encoded StandardFonts.Helvetica.
|
||||
// The previous "⚠ " marker (U+26A0) threw `WinAnsi cannot encode "⚠"`
|
||||
// the moment the text-height estimator measured the leaf label.
|
||||
// Guard against re-introducing a non-WinAnsi marker by exercising
|
||||
// the same path: load the body font and measure a label that
|
||||
// carries the prefix.
|
||||
const doc = await PDFDocument.create()
|
||||
const fonts = await embedFonts(doc)
|
||||
expect(() =>
|
||||
fonts.bodyRegular.widthOfTextAtSize('(!) Difficulté de déglutition', 10),
|
||||
).not.toThrow()
|
||||
})
|
||||
|
||||
it('rejects a legacy v1 PDF with a version-specific message', async () => {
|
||||
const doc = await PDFDocument.create()
|
||||
doc.addPage()
|
||||
const legacyPayload = {
|
||||
version: 1,
|
||||
id: 'legacy',
|
||||
createdAt: '2025-12-01T00:00:00Z',
|
||||
date: '2025-12-01',
|
||||
practitioner: { name: 'Dr. Dupont' },
|
||||
animal: { speciesId: 'equine', name: 'Mistral' },
|
||||
owner: { name: 'Jean Martin' },
|
||||
observations: [],
|
||||
conclusion: '',
|
||||
recommendations: '',
|
||||
}
|
||||
const bytes = new TextEncoder().encode(JSON.stringify(legacyPayload))
|
||||
await doc.attach(bytes, 'osteo-report.json', {
|
||||
mimeType: 'application/json',
|
||||
description: 'Osteo Report state v1',
|
||||
afRelationship: AFRelationship.Data,
|
||||
describe('export on a full v3 report (FR)', () => {
|
||||
it('produces one page per observation plus the conclusion, labels from the sheet', async () => {
|
||||
const report = minimalReport(sheet, {
|
||||
observations: [fullObservation()],
|
||||
conclusion: 'ok',
|
||||
})
|
||||
const pdfBytes = await doc.save()
|
||||
try {
|
||||
await importReportFromPdf(pdfBytes)
|
||||
throw new Error('expected rejection')
|
||||
} catch (err) {
|
||||
expect(err).toBeInstanceOf(ImportError)
|
||||
const e = err as ImportError
|
||||
expect(e.kind).toBe('incompatible_version')
|
||||
expect(e.foundVersion).toBe(1)
|
||||
const bytes = await exportReportToPdf(report, sheet, { locale: 'fr' })
|
||||
const doc = await PDFDocument.load(bytes)
|
||||
expect(doc.getPageCount()).toBe(2)
|
||||
const zonesIdx = drawn.indexOf(fr['pdf.section.zones']!)
|
||||
expect(drawn.slice(zonesIdx + 1, zonesIdx + 6)).toEqual([
|
||||
'Charnière C7-T1 (cervico-thoracique)',
|
||||
'•',
|
||||
'Hanche (coxo-fémorale) (Gauche)',
|
||||
'•',
|
||||
'Hanche (coxo-fémorale) (Droite)',
|
||||
])
|
||||
expect(drawn).toContain('Vertèbres cervicales (C3, C4)')
|
||||
expect(drawn).toContain('Articulation temporo-mandibulaire (ATM)')
|
||||
const prefix = fr['pdf.section.findings_prefix']!
|
||||
expect(drawn).toContain(`${prefix}CHARNIÈRE C7-T1 (CERVICO-THORACIQUE)`)
|
||||
expect(drawn).toContain(`${prefix}HANCHE (COXO-FÉMORALE) (GAUCHE)`)
|
||||
expect(drawn).toContain('(!) Headshaking (secouement de tête)')
|
||||
expect(drawn).toContain(fr['severity.moderate']!)
|
||||
expect(drawn).toContain(fr['pdf.view.general']!)
|
||||
expect(drawn).toContain(
|
||||
`${fr['pdf.view.detail_prefix']}TÊTE (VUE LATÉRALE GAUCHE)`,
|
||||
)
|
||||
})
|
||||
|
||||
it('attaches v3 and roundtrips in both locales', async () => {
|
||||
const report = minimalReport(sheet, { observations: [fullObservation()] })
|
||||
for (const locale of ['fr', 'en'] as const) {
|
||||
const bytes = await exportReportToPdf(report, sheet, { locale })
|
||||
const out = await importReportFromPdf(bytes, sheet.sheet.migrationMap)
|
||||
expect(out.migrated).toBe(false)
|
||||
expect(out.report).toEqual(report)
|
||||
}
|
||||
})
|
||||
|
||||
it('highlights the observation zones of a view and hides the other markers', () => {
|
||||
const svg = highlightedViewSvg(sheet, 'main', fullObservation())
|
||||
expect(svg).toContain('viewBox="0 0 2073.4 1629.4"')
|
||||
expect(svg).toContain('fill="#b85a3f"')
|
||||
expect(svg).toContain('url(#osteo-halo)')
|
||||
expect(svg).toContain('display="none"')
|
||||
expect(svg).not.toContain('data-anno-id')
|
||||
const head = highlightedViewSvg(sheet, 'head', fullObservation())
|
||||
expect(head).toContain('viewBox="60 100 500 380"')
|
||||
expect(head).not.toContain('osteo-halo')
|
||||
})
|
||||
})
|
||||
|
||||
describe('import of the frozen v2 archive PDFs', () => {
|
||||
it('migrates the full v2 report: ids, views, paths, severities, unresolved findings', async () => {
|
||||
const out = await importReportFromPdf(
|
||||
fixture('report-v2.full.pdf'),
|
||||
sheet.sheet.migrationMap,
|
||||
)
|
||||
expect(out.migrated).toBe(true)
|
||||
const { report } = out
|
||||
expect(report.version).toBe(3)
|
||||
expect(report.sheet).toEqual(sheet.sheet.ref)
|
||||
expect(report.animal.name).toBe('Mistral')
|
||||
const zones = report.observations.flatMap((o) => o.zones)
|
||||
expect(
|
||||
zones.map(
|
||||
(z) => `${z.annotationId}@${z.viewId}${z.side ? ':' + z.side : ''}`,
|
||||
),
|
||||
).toEqual(
|
||||
expect.arrayContaining([
|
||||
'c7-t1@main',
|
||||
'hip@main:left',
|
||||
'hip@main:right',
|
||||
'cervical@main',
|
||||
'atm@head',
|
||||
]),
|
||||
)
|
||||
expect(zones.every((z) => !z.unresolved)).toBe(true)
|
||||
const findings = report.observations.flatMap((o) => o.findings)
|
||||
const moved = findings.find((f) =>
|
||||
f.path.includes('stumbling-proprioceptive'),
|
||||
)!
|
||||
expect(moved.path[0]).toBe('cervical-consultation-reasons')
|
||||
expect(moved.unresolved).toBeUndefined()
|
||||
const headshaking = findings.find((f) => f.path.includes('headshaking'))!
|
||||
expect(headshaking.path).toEqual([
|
||||
'atm-consultation-reasons',
|
||||
'headshaking',
|
||||
])
|
||||
expect(findings.some((f) => f.unresolved)).toBe(false)
|
||||
expect(out.unresolvedFindings).toBe(0)
|
||||
expect(report.observations.map((o) => o.severity)).toEqual(
|
||||
expect.arrayContaining(['moderate', 'severe']),
|
||||
)
|
||||
// Re-export and re-import: stable.
|
||||
const again = await importReportFromPdf(
|
||||
await exportReportToPdf(report, sheet, { locale: 'fr' }),
|
||||
sheet.sheet.migrationMap,
|
||||
)
|
||||
expect(again.report).toEqual(report)
|
||||
expect(again.migrated).toBe(false)
|
||||
})
|
||||
|
||||
it('keeps a v2 finding whose node was removed and a zone whose id is unknown, both flagged', async () => {
|
||||
const v2 = {
|
||||
...JSON.parse(
|
||||
readFileSync(
|
||||
resolve(HERE, '../fixtures/report-v2.minimal.json'),
|
||||
'utf8',
|
||||
),
|
||||
),
|
||||
observations: [
|
||||
{
|
||||
id: 'o-legacy',
|
||||
zones: [
|
||||
{ boneId: 'point-mpbyphay', detailSourceId: 'head' },
|
||||
{ boneId: 'point-gone' },
|
||||
],
|
||||
findings: [
|
||||
{
|
||||
zoneId: 'ssb',
|
||||
path: ['ssb-dysfunctions', 'sutures', 'sphenozygomatic'],
|
||||
labelFrSnapshot: 'Suture sphéno-zygomatique',
|
||||
labelEnSnapshot: 'Sphenozygomatic suture',
|
||||
},
|
||||
],
|
||||
freeTextFindings: [],
|
||||
comment: '',
|
||||
severity: 'légère',
|
||||
},
|
||||
],
|
||||
}
|
||||
const doc = await PDFDocument.create()
|
||||
doc.addPage()
|
||||
await doc.attach(
|
||||
new TextEncoder().encode(JSON.stringify(v2)),
|
||||
'osteo-report.json',
|
||||
{ mimeType: 'application/json' },
|
||||
)
|
||||
const out = await importReportFromPdf(
|
||||
await doc.save(),
|
||||
sheet.sheet.migrationMap,
|
||||
)
|
||||
const [obs] = out.report.observations
|
||||
expect(obs!.zones).toEqual([
|
||||
expect.objectContaining({
|
||||
annotationId: 'ssb',
|
||||
viewId: 'head',
|
||||
labelFrSnapshot: 'Synchondrose Sphéno-Basilaire (SSB)',
|
||||
}),
|
||||
expect.objectContaining({
|
||||
annotationId: 'point-gone',
|
||||
viewId: 'main',
|
||||
unresolved: true,
|
||||
}),
|
||||
])
|
||||
expect(obs!.findings[0]).toMatchObject({
|
||||
findingZoneId: 'ssb',
|
||||
path: ['ssb-dysfunctions', 'sutures', 'sphenozygomatic'],
|
||||
unresolved: true,
|
||||
labelFrSnapshot: 'Suture sphéno-zygomatique',
|
||||
})
|
||||
expect(obs!.severity).toBe('mild')
|
||||
expect(out.unresolvedFindings).toBe(1)
|
||||
expect(out.unresolvedZones).toBe(1)
|
||||
// The migrated document is a valid v3 document: exporting it again keeps the flags.
|
||||
const again = await importReportFromPdf(
|
||||
await exportReportToPdf(out.report, sheet, { locale: 'en' }),
|
||||
sheet.sheet.migrationMap,
|
||||
)
|
||||
expect(again.report.observations[0]!.findings[0]!.unresolved).toBe(true)
|
||||
})
|
||||
|
||||
it('migrates the minimal v2 report', async () => {
|
||||
const out = await importReportFromPdf(
|
||||
fixture('report-v2.minimal.pdf'),
|
||||
sheet.sheet.migrationMap,
|
||||
)
|
||||
expect(out.report.version).toBe(3)
|
||||
expect(out.report.observations).toEqual([])
|
||||
expect(out.unresolvedFindings + out.unresolvedZones).toBe(0)
|
||||
})
|
||||
|
||||
it('refuses unknown versions and unrelated PDFs with typed errors', async () => {
|
||||
const doc = await PDFDocument.create()
|
||||
doc.addPage()
|
||||
await doc.attach(
|
||||
new TextEncoder().encode(JSON.stringify({ version: 7 })),
|
||||
'osteo-report.json',
|
||||
{ mimeType: 'application/json' },
|
||||
)
|
||||
await expect(
|
||||
importReportFromPdf(await doc.save(), sheet.sheet.migrationMap),
|
||||
).rejects.toMatchObject({ kind: 'incompatible_version', foundVersion: 7 })
|
||||
const fake = new Uint8Array([37, 80, 68, 70, 45, 49, 46, 52, 10])
|
||||
await expect(
|
||||
importReportFromPdf(fake, sheet.sheet.migrationMap),
|
||||
).rejects.toThrow(ImportError)
|
||||
})
|
||||
})
|
||||
@@ -39,12 +39,10 @@ describe('rasterizeSvg', () => {
|
||||
canvas.toBlob = ((cb: BlobCallback) => {
|
||||
cb(new Blob([PNG_BYTES], { type: 'image/png' }))
|
||||
}) as HTMLCanvasElement['toBlob']
|
||||
vi.spyOn(document, 'createElement').mockImplementation(
|
||||
((tag: string) =>
|
||||
tag === 'canvas'
|
||||
? canvas
|
||||
: ({}) as HTMLElement) as typeof document.createElement,
|
||||
)
|
||||
vi.spyOn(document, 'createElement').mockImplementation(((tag: string) =>
|
||||
tag === 'canvas'
|
||||
? canvas
|
||||
: ({} as HTMLElement)) as typeof document.createElement)
|
||||
|
||||
const out = await rasterizeSvg(
|
||||
'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 10 10"/>',
|
||||
@@ -67,14 +65,11 @@ describe('rasterizeSvg', () => {
|
||||
cb(null)
|
||||
}) as HTMLCanvasElement['toBlob']
|
||||
canvas.toDataURL = () =>
|
||||
'data:image/png;base64,' +
|
||||
Buffer.from(PNG_BYTES).toString('base64')
|
||||
vi.spyOn(document, 'createElement').mockImplementation(
|
||||
((tag: string) =>
|
||||
tag === 'canvas'
|
||||
? canvas
|
||||
: ({}) as HTMLElement) as typeof document.createElement,
|
||||
)
|
||||
'data:image/png;base64,' + Buffer.from(PNG_BYTES).toString('base64')
|
||||
vi.spyOn(document, 'createElement').mockImplementation(((tag: string) =>
|
||||
tag === 'canvas'
|
||||
? canvas
|
||||
: ({} as HTMLElement)) as typeof document.createElement)
|
||||
|
||||
const out = await rasterizeSvg(
|
||||
'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 10 10"/>',
|
||||
|
||||
@@ -1,96 +0,0 @@
|
||||
import { describe, it, expect, beforeAll, afterAll } from 'vitest'
|
||||
import { readFileSync } from 'node:fs'
|
||||
import { fileURLToPath } from 'node:url'
|
||||
import { dirname, resolve } from 'node:path'
|
||||
import { buildZoneLabels } from '@/pdf/export'
|
||||
import type { Report } from '@/domain/schema/report'
|
||||
|
||||
const HERE = dirname(fileURLToPath(import.meta.url))
|
||||
const HORSE_SVG = readFileSync(
|
||||
resolve(HERE, '../../public/species/equine/Horse.svg'),
|
||||
'utf8',
|
||||
)
|
||||
const HEAD_SVG = readFileSync(
|
||||
resolve(HERE, '../../public/species/equine/Horse_head.svg'),
|
||||
'utf8',
|
||||
)
|
||||
|
||||
const realFetch = globalThis.fetch
|
||||
let detailFetchShouldFail = false
|
||||
|
||||
beforeAll(() => {
|
||||
globalThis.fetch = (async (input: RequestInfo | URL) => {
|
||||
const url = String(input)
|
||||
if (url.endsWith('/Horse.svg')) {
|
||||
return new Response(HORSE_SVG, {
|
||||
status: 200,
|
||||
headers: { 'content-type': 'image/svg+xml' },
|
||||
})
|
||||
}
|
||||
if (url.endsWith('/Horse_head.svg')) {
|
||||
if (detailFetchShouldFail) {
|
||||
return new Response('not found', { status: 404 })
|
||||
}
|
||||
return new Response(HEAD_SVG, {
|
||||
status: 200,
|
||||
headers: { 'content-type': 'image/svg+xml' },
|
||||
})
|
||||
}
|
||||
return new Response('not found', { status: 404 })
|
||||
}) as typeof fetch
|
||||
})
|
||||
|
||||
afterAll(() => {
|
||||
globalThis.fetch = realFetch
|
||||
})
|
||||
|
||||
const baseReport: Report = {
|
||||
version: 2,
|
||||
id: 'r1',
|
||||
createdAt: '2026-05-20T10:00:00Z',
|
||||
date: '2026-05-20',
|
||||
practitioner: { name: 'Dr. Dupont' },
|
||||
animal: { speciesId: 'equine', name: 'Mistral' },
|
||||
owner: { name: 'Jean Martin' },
|
||||
observations: [],
|
||||
conclusion: '',
|
||||
recommendations: '',
|
||||
}
|
||||
|
||||
describe('buildZoneLabels', () => {
|
||||
it('maps detail-popup boneIds to their FR + EN labels', async () => {
|
||||
detailFetchShouldFail = false
|
||||
const labels = await buildZoneLabels(baseReport)
|
||||
const atm = labels.get('point-mpbyo7zq')
|
||||
expect(atm?.fr).toBe('Articulation Temporo-Mandibulaire (ATM)')
|
||||
expect(atm?.en).toBe('Temporomandibular Joint (TMJ)')
|
||||
const sphenoid = labels.get('point-mpbymcln')
|
||||
expect(sphenoid?.fr).toBe('Sphénoïde')
|
||||
expect(sphenoid?.en).toBe('Sphenoid')
|
||||
})
|
||||
|
||||
it('maps main-SVG boneIds to their FR + EN labels', async () => {
|
||||
detailFetchShouldFail = false
|
||||
const labels = await buildZoneLabels(baseReport)
|
||||
expect(labels.size).toBeGreaterThan(0)
|
||||
const pairs = Array.from(labels.values())
|
||||
expect(pairs.some((p) => p.fr.includes('Vertèbres'))).toBe(true)
|
||||
expect(pairs.some((p) => p.en.includes('Vertebrae'))).toBe(true)
|
||||
})
|
||||
|
||||
it('keeps the main labels even when the detail SVG fetch fails', async () => {
|
||||
detailFetchShouldFail = true
|
||||
const labels = await buildZoneLabels(baseReport)
|
||||
expect(labels.get('point-mpbymcln')).toBeUndefined()
|
||||
const pairs = Array.from(labels.values())
|
||||
expect(pairs.some((p) => p.fr.includes('Vertèbres'))).toBe(true)
|
||||
})
|
||||
|
||||
it('returns an empty map for an unknown species', async () => {
|
||||
const labels = await buildZoneLabels({
|
||||
...baseReport,
|
||||
animal: { speciesId: 'cat', name: 'X' },
|
||||
})
|
||||
expect(labels.size).toBe(0)
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,198 @@
|
||||
/**
|
||||
* The editor route on the bundled sheet: the click chain end to end (DOM
|
||||
* click on a generated marker → service → store), the detail view by its
|
||||
* localized name, the sheet status line, the disclaimer once per session.
|
||||
*/
|
||||
import {
|
||||
describe,
|
||||
it,
|
||||
expect,
|
||||
vi,
|
||||
beforeAll,
|
||||
beforeEach,
|
||||
afterEach,
|
||||
} from 'vitest'
|
||||
import {
|
||||
render,
|
||||
screen,
|
||||
waitFor,
|
||||
within,
|
||||
cleanup,
|
||||
} from '@testing-library/react'
|
||||
import userEvent from '@testing-library/user-event'
|
||||
import { MemoryRouter } from 'react-router-dom'
|
||||
import EditorRoute from '@/app/routes/EditorRoute'
|
||||
import { useReportStore } from '@/state/reportStore'
|
||||
import { useLocaleStore } from '@/state/localeStore'
|
||||
import { fr } from '@/i18n/fr'
|
||||
import type { SheetIndex } from '@/services/sheetIndex'
|
||||
import { loadTestSheet, minimalReport } from '../helpers/sheet'
|
||||
|
||||
const DISCLAIMER_FLAG = 'osteo:disclaimer-shown'
|
||||
let sheet: SheetIndex
|
||||
|
||||
beforeAll(async () => {
|
||||
sheet = await loadTestSheet()
|
||||
})
|
||||
|
||||
beforeEach(() => {
|
||||
useLocaleStore.setState({ locale: 'fr' })
|
||||
sessionStorage.clear()
|
||||
sessionStorage.setItem(DISCLAIMER_FLAG, '1')
|
||||
window.scrollTo = vi.fn() as unknown as typeof window.scrollTo
|
||||
useReportStore.setState({ report: null, activeObservationIndex: 0 })
|
||||
useReportStore
|
||||
.getState()
|
||||
.hydrateReport(
|
||||
minimalReport(sheet, {
|
||||
observations: [
|
||||
{
|
||||
id: 'o1',
|
||||
zones: [],
|
||||
findings: [],
|
||||
freeTextFindings: [],
|
||||
comment: '',
|
||||
},
|
||||
],
|
||||
}),
|
||||
)
|
||||
})
|
||||
afterEach(() => {
|
||||
cleanup()
|
||||
vi.restoreAllMocks()
|
||||
})
|
||||
|
||||
const zonesOf = (i = 0) =>
|
||||
useReportStore.getState().report!.observations[i]!.zones
|
||||
|
||||
async function mount() {
|
||||
const utils = render(
|
||||
<MemoryRouter initialEntries={['/editor']}>
|
||||
<EditorRoute />
|
||||
</MemoryRouter>,
|
||||
)
|
||||
await waitFor(() =>
|
||||
expect(
|
||||
document.querySelector('[data-anno-id="head-trigger"]'),
|
||||
).not.toBeNull(),
|
||||
)
|
||||
return utils
|
||||
}
|
||||
|
||||
function clickZone(id: string, scope: ParentNode = document) {
|
||||
const els = scope.querySelectorAll(`[data-anno-id="${id}"]`)
|
||||
expect(els.length, id).toBeGreaterThan(0)
|
||||
els[0]!.dispatchEvent(new Event('click', { bubbles: true }))
|
||||
}
|
||||
|
||||
describe('EditorRoute on the canonical sheet', () => {
|
||||
it('shows the sheet status line and toggles a plain zone on the active observation', async () => {
|
||||
await mount()
|
||||
expect(screen.getByTestId('sheet-status').textContent).toBe(
|
||||
fr['sheet.status.draft'],
|
||||
)
|
||||
clickZone('c7-t1')
|
||||
expect(zonesOf()).toEqual([
|
||||
{
|
||||
annotationId: 'c7-t1',
|
||||
viewId: 'main',
|
||||
labelFrSnapshot: 'Charnière C7-T1 (cervico-thoracique)',
|
||||
labelEnSnapshot: 'C7-T1 junction (cervicothoracic)',
|
||||
},
|
||||
])
|
||||
clickZone('c7-t1')
|
||||
expect(zonesOf()).toEqual([])
|
||||
})
|
||||
|
||||
it('a click with no active observation only activates the last one', async () => {
|
||||
useReportStore.getState().setActiveObservation(-1)
|
||||
await mount()
|
||||
clickZone('c7-t1')
|
||||
expect(useReportStore.getState().activeObservationIndex).toBe(0)
|
||||
expect(zonesOf()).toEqual([])
|
||||
})
|
||||
|
||||
it('a bilateral zone opens the side picker and adds the chosen side; both sides then clear on re-click', async () => {
|
||||
const user = userEvent.setup()
|
||||
await mount()
|
||||
clickZone('hip')
|
||||
const dialog = await screen.findByRole('dialog', {
|
||||
name: 'Hanche (coxo-fémorale)',
|
||||
})
|
||||
await user.click(
|
||||
within(dialog).getByRole('button', { name: fr['lateral.both'] }),
|
||||
)
|
||||
expect(zonesOf().map((z) => z.side)).toEqual(['left', 'right'])
|
||||
clickZone('hip')
|
||||
expect(zonesOf()).toEqual([])
|
||||
})
|
||||
|
||||
it('a spine zone is added and opens the vertebra picker; confirming syncs vertebrae by region', async () => {
|
||||
const user = userEvent.setup()
|
||||
await mount()
|
||||
clickZone('cervical')
|
||||
const dialog = await screen.findByRole('dialog', {
|
||||
name: /Vertèbres cervicales/,
|
||||
})
|
||||
expect(zonesOf()[0]!.annotationId).toBe('cervical')
|
||||
expect(
|
||||
within(dialog).getByRole('tab', { name: 'Cervicales' }),
|
||||
).toHaveAttribute('aria-selected', 'true')
|
||||
await user.click(within(dialog).getByText('C3'))
|
||||
await user.click(within(dialog).getByRole('tab', { name: 'Lombaires' }))
|
||||
await user.click(within(dialog).getByText('L2'))
|
||||
await user.click(
|
||||
within(dialog).getByRole('button', { name: fr['common.confirm'] }),
|
||||
)
|
||||
expect(zonesOf().map((z) => [z.annotationId, z.vertebrae])).toEqual([
|
||||
['cervical', [{ region: 'C', index: 3 }]],
|
||||
['lumbar', [{ region: 'L', index: 2 }]],
|
||||
])
|
||||
})
|
||||
|
||||
it('the head trigger opens the detail view by its name and its zones carry the head view id', async () => {
|
||||
await mount()
|
||||
clickZone('head-trigger')
|
||||
const dialog = await screen.findByRole('dialog', {
|
||||
name: 'Tête (vue latérale gauche)',
|
||||
})
|
||||
await waitFor(() =>
|
||||
expect(dialog.querySelector('[data-anno-id="atm"]')).not.toBeNull(),
|
||||
)
|
||||
expect(dialog.querySelector('svg')!.getAttribute('viewBox')).toBe(
|
||||
'60 100 500 380',
|
||||
)
|
||||
clickZone('atm', dialog)
|
||||
expect(zonesOf()).toEqual([
|
||||
expect.objectContaining({ annotationId: 'atm', viewId: 'head' }),
|
||||
])
|
||||
expect(
|
||||
screen.getByRole('dialog', { name: 'Tête (vue latérale gauche)' }),
|
||||
).toBeInTheDocument()
|
||||
})
|
||||
|
||||
it('shows the scope disclaimer once per session, from the sheet', async () => {
|
||||
sessionStorage.removeItem(DISCLAIMER_FLAG)
|
||||
const user = userEvent.setup()
|
||||
await mount()
|
||||
const dialog = await screen.findByRole('dialog', {
|
||||
name: fr['editor.disclaimer_title'],
|
||||
})
|
||||
expect(dialog.textContent).toContain('R. 243-6')
|
||||
await user.click(
|
||||
within(dialog).getByRole('button', { name: fr['common.understood'] }),
|
||||
)
|
||||
expect(sessionStorage.getItem(DISCLAIMER_FLAG)).toBe('1')
|
||||
})
|
||||
|
||||
it('restores the per-tab draft when the store is empty, migrating a v2 one', async () => {
|
||||
const report = useReportStore.getState().report!
|
||||
useReportStore.setState({ report: null })
|
||||
sessionStorage.setItem(
|
||||
'osteo:draft',
|
||||
JSON.stringify({ ...report, version: 3 }),
|
||||
)
|
||||
await mount()
|
||||
expect(useReportStore.getState().report?.id).toBe(report.id)
|
||||
})
|
||||
})
|
||||
@@ -1,157 +0,0 @@
|
||||
import { describe, it, expect } from 'vitest'
|
||||
import {
|
||||
ObservationSchema,
|
||||
VertebraSchema,
|
||||
SeveritySchema,
|
||||
FindingSchema,
|
||||
LateralSideSchema,
|
||||
ObservationZoneSchema,
|
||||
} from '@/domain/schema/observation'
|
||||
|
||||
describe('SeveritySchema', () => {
|
||||
it('accepts the three documented values', () => {
|
||||
expect(SeveritySchema.parse('légère')).toBe('légère')
|
||||
expect(SeveritySchema.parse('modérée')).toBe('modérée')
|
||||
expect(SeveritySchema.parse('sévère')).toBe('sévère')
|
||||
})
|
||||
|
||||
it('rejects unknown severity', () => {
|
||||
expect(() => SeveritySchema.parse('critique')).toThrow()
|
||||
})
|
||||
})
|
||||
|
||||
describe('VertebraSchema', () => {
|
||||
it('accepts a region+index pair', () => {
|
||||
expect(VertebraSchema.parse({ region: 'T', index: 12 })).toEqual({
|
||||
region: 'T',
|
||||
index: 12,
|
||||
})
|
||||
})
|
||||
|
||||
it('rejects index 0', () => {
|
||||
expect(() => VertebraSchema.parse({ region: 'C', index: 0 })).toThrow()
|
||||
})
|
||||
|
||||
it('rejects unknown region', () => {
|
||||
expect(() => VertebraSchema.parse({ region: 'X', index: 1 })).toThrow()
|
||||
})
|
||||
})
|
||||
|
||||
describe('FindingSchema', () => {
|
||||
const base = {
|
||||
zoneId: 'sphenoid',
|
||||
path: ['sphenoid-dysfunctions', 'physiological', 'flexion'],
|
||||
labelFrSnapshot: 'Flexion',
|
||||
labelEnSnapshot: 'Flexion',
|
||||
}
|
||||
|
||||
it('accepts a minimal finding', () => {
|
||||
expect(() => FindingSchema.parse(base)).not.toThrow()
|
||||
})
|
||||
|
||||
it('accepts the optional vet-referral flag', () => {
|
||||
expect(() =>
|
||||
FindingSchema.parse({ ...base, requiresVetReferral: true }),
|
||||
).not.toThrow()
|
||||
})
|
||||
|
||||
it('rejects an empty path', () => {
|
||||
expect(() => FindingSchema.parse({ ...base, path: [] })).toThrow()
|
||||
})
|
||||
|
||||
it('rejects an empty zoneId', () => {
|
||||
expect(() => FindingSchema.parse({ ...base, zoneId: '' })).toThrow()
|
||||
})
|
||||
})
|
||||
|
||||
describe('LateralSideSchema', () => {
|
||||
it('accepts left and right', () => {
|
||||
expect(LateralSideSchema.parse('left')).toBe('left')
|
||||
expect(LateralSideSchema.parse('right')).toBe('right')
|
||||
})
|
||||
|
||||
it('rejects unknown side', () => {
|
||||
expect(() => LateralSideSchema.parse('both')).toThrow()
|
||||
expect(() => LateralSideSchema.parse('')).toThrow()
|
||||
})
|
||||
})
|
||||
|
||||
describe('ObservationZoneSchema with side', () => {
|
||||
it('accepts a zone without side (unpaired)', () => {
|
||||
expect(() => ObservationZoneSchema.parse({ boneId: 'sternum' })).not.toThrow()
|
||||
})
|
||||
|
||||
it('accepts a zone with side left', () => {
|
||||
const parsed = ObservationZoneSchema.parse({ boneId: 'knee', side: 'left' })
|
||||
expect(parsed.side).toBe('left')
|
||||
})
|
||||
|
||||
it('accepts a zone with side right', () => {
|
||||
const parsed = ObservationZoneSchema.parse({ boneId: 'knee', side: 'right' })
|
||||
expect(parsed.side).toBe('right')
|
||||
})
|
||||
|
||||
it('accepts two zones with same boneId but different sides', () => {
|
||||
const obs = {
|
||||
id: 'obs-1',
|
||||
zones: [
|
||||
{ boneId: 'knee', side: 'left' },
|
||||
{ boneId: 'knee', side: 'right' },
|
||||
],
|
||||
findings: [],
|
||||
freeTextFindings: [],
|
||||
comment: '',
|
||||
}
|
||||
expect(() => ObservationSchema.parse(obs)).not.toThrow()
|
||||
})
|
||||
})
|
||||
|
||||
describe('ObservationSchema', () => {
|
||||
const baseObs = {
|
||||
id: 'obs-1',
|
||||
zones: [{ boneId: 'epaule' }],
|
||||
findings: [],
|
||||
freeTextFindings: [],
|
||||
comment: '',
|
||||
}
|
||||
|
||||
it('accepts a minimal observation', () => {
|
||||
expect(() => ObservationSchema.parse(baseObs)).not.toThrow()
|
||||
})
|
||||
|
||||
it('accepts a spine-zone observation with precise vertebrae', () => {
|
||||
const obs = {
|
||||
...baseObs,
|
||||
zones: [
|
||||
{
|
||||
boneId: 'thoracic-vertebrae-spine-zone',
|
||||
vertebrae: [
|
||||
{ region: 'T', index: 12 },
|
||||
{ region: 'T', index: 13 },
|
||||
],
|
||||
},
|
||||
],
|
||||
}
|
||||
expect(() => ObservationSchema.parse(obs)).not.toThrow()
|
||||
})
|
||||
|
||||
it('accepts an observation with findings and free-text additions', () => {
|
||||
const obs = {
|
||||
...baseObs,
|
||||
findings: [
|
||||
{
|
||||
zoneId: 'sphenoid',
|
||||
path: ['sphenoid-dysfunctions', 'physiological', 'flexion'],
|
||||
labelFrSnapshot: 'Flexion',
|
||||
labelEnSnapshot: 'Flexion',
|
||||
},
|
||||
],
|
||||
freeTextFindings: ['note libre'],
|
||||
}
|
||||
expect(() => ObservationSchema.parse(obs)).not.toThrow()
|
||||
})
|
||||
|
||||
it('rejects empty id', () => {
|
||||
expect(() => ObservationSchema.parse({ ...baseObs, id: '' })).toThrow()
|
||||
})
|
||||
})
|
||||
@@ -1,53 +0,0 @@
|
||||
import { describe, it, expect } from 'vitest'
|
||||
import { ReportSchema } from '@/domain/schema/report'
|
||||
|
||||
const minimal = {
|
||||
version: 2 as const,
|
||||
id: 'r1',
|
||||
createdAt: '2026-05-18T10:00:00Z',
|
||||
date: '2026-05-18',
|
||||
practitioner: { name: 'Dr. Dupont' },
|
||||
animal: { speciesId: 'equine', name: 'Mistral' },
|
||||
owner: { name: 'Jean Martin' },
|
||||
observations: [],
|
||||
conclusion: '',
|
||||
recommendations: '',
|
||||
}
|
||||
|
||||
describe('ReportSchema', () => {
|
||||
it('accepts a minimal valid report', () => {
|
||||
expect(() => ReportSchema.parse(minimal)).not.toThrow()
|
||||
})
|
||||
|
||||
it('accepts nextAppointment kind=date', () => {
|
||||
expect(() =>
|
||||
ReportSchema.parse({
|
||||
...minimal,
|
||||
nextAppointment: { kind: 'date', date: '2026-06-08' },
|
||||
}),
|
||||
).not.toThrow()
|
||||
})
|
||||
|
||||
it('accepts nextAppointment kind=period', () => {
|
||||
expect(() =>
|
||||
ReportSchema.parse({
|
||||
...minimal,
|
||||
nextAppointment: { kind: 'period', text: 'dans 3 semaines' },
|
||||
}),
|
||||
).not.toThrow()
|
||||
})
|
||||
|
||||
it('rejects legacy v1 reports', () => {
|
||||
expect(() => ReportSchema.parse({ ...minimal, version: 1 })).toThrow()
|
||||
})
|
||||
|
||||
it('rejects unknown future versions', () => {
|
||||
expect(() => ReportSchema.parse({ ...minimal, version: 3 })).toThrow()
|
||||
})
|
||||
|
||||
it('rejects empty practitioner.name', () => {
|
||||
expect(() =>
|
||||
ReportSchema.parse({ ...minimal, practitioner: { name: '' } }),
|
||||
).toThrow()
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,214 @@
|
||||
/**
|
||||
* Replaces char.clickChain (Step 1) one-to-one: every branch of the legacy
|
||||
* zone-click chain, now decided by the pure service on the bundled sheet's
|
||||
* annotations, with outcomes in Report v3 shape.
|
||||
*/
|
||||
import { beforeAll, describe, expect, it } from 'vitest'
|
||||
import type { Annotation } from '@faunosteo/domain'
|
||||
import type { SheetIndex } from '@/services/sheetIndex'
|
||||
import {
|
||||
addSides,
|
||||
collectVertebrae,
|
||||
decideZoneClick,
|
||||
ensureZone,
|
||||
refOf,
|
||||
removeAllSides,
|
||||
removeZoneAt,
|
||||
sidesPresent,
|
||||
syncVertebrae,
|
||||
toggleZone,
|
||||
} from '@/services/zoneInteraction'
|
||||
import { emptyObservation, loadTestSheet } from '../helpers/sheet'
|
||||
|
||||
let sheet: SheetIndex
|
||||
const a = (id: string): Annotation => {
|
||||
const annotation = sheet.annotation(id)
|
||||
if (!annotation) throw new Error(`no annotation ${id}`)
|
||||
return annotation
|
||||
}
|
||||
|
||||
beforeAll(async () => {
|
||||
sheet = await loadTestSheet()
|
||||
})
|
||||
|
||||
describe('decideZoneClick', () => {
|
||||
it('opens the detail view for the trigger, even without an active observation', () => {
|
||||
expect(decideZoneClick(a('head-trigger'), undefined)).toEqual({
|
||||
kind: 'open_view',
|
||||
viewId: 'head',
|
||||
})
|
||||
expect(decideZoneClick(a('head-trigger'), emptyObservation())).toEqual({
|
||||
kind: 'open_view',
|
||||
viewId: 'head',
|
||||
})
|
||||
})
|
||||
|
||||
it('only activates a fallback observation when none is active', () => {
|
||||
expect(decideZoneClick(a('c7-t1'), undefined)).toEqual({
|
||||
kind: 'activate_fallback',
|
||||
})
|
||||
expect(decideZoneClick(undefined, emptyObservation())).toEqual({
|
||||
kind: 'ignore',
|
||||
})
|
||||
})
|
||||
|
||||
it('always opens the vertebra picker on a spine zone', () => {
|
||||
const obs = toggleZone(emptyObservation(), a('cervical'))
|
||||
expect(decideZoneClick(a('cervical'), emptyObservation())).toEqual({
|
||||
kind: 'open_vertebra_picker',
|
||||
})
|
||||
expect(decideZoneClick(a('cervical'), obs)).toEqual({
|
||||
kind: 'open_vertebra_picker',
|
||||
})
|
||||
})
|
||||
|
||||
it('routes bilateral zones through the side picker, or clears both sides', () => {
|
||||
const hip = a('hip')
|
||||
expect(decideZoneClick(hip, emptyObservation())).toEqual({
|
||||
kind: 'open_laterality_picker',
|
||||
})
|
||||
const left = addSides(emptyObservation(), hip, ['left'])
|
||||
expect(decideZoneClick(hip, left)).toEqual({
|
||||
kind: 'open_laterality_picker',
|
||||
})
|
||||
const both = addSides(left, hip, ['right'])
|
||||
expect(decideZoneClick(hip, both)).toEqual({ kind: 'remove_both_sides' })
|
||||
})
|
||||
|
||||
it('toggles plain zones; the ten bilateral annotations and the 18 others split as the sheet says', () => {
|
||||
expect(decideZoneClick(a('c7-t1'), emptyObservation())).toEqual({
|
||||
kind: 'toggle',
|
||||
})
|
||||
const observable = sheet.sheet.document.annotations.filter(
|
||||
(x) => x.kind !== 'detail_trigger',
|
||||
)
|
||||
const decisions = observable.map(
|
||||
(x) => decideZoneClick(x, emptyObservation()).kind,
|
||||
)
|
||||
expect(
|
||||
decisions.filter((k) => k === 'open_laterality_picker'),
|
||||
).toHaveLength(10)
|
||||
expect(decisions.filter((k) => k === 'open_vertebra_picker')).toHaveLength(
|
||||
5,
|
||||
)
|
||||
expect(decisions.filter((k) => k === 'toggle')).toHaveLength(12)
|
||||
})
|
||||
})
|
||||
|
||||
describe('reducers', () => {
|
||||
it('toggleZone adds a zone with snapshots then removes it', () => {
|
||||
const added = toggleZone(emptyObservation(), a('c7-t1'))
|
||||
expect(added.zones).toEqual([
|
||||
{
|
||||
annotationId: 'c7-t1',
|
||||
viewId: 'main',
|
||||
labelFrSnapshot: 'Charnière C7-T1 (cervico-thoracique)',
|
||||
labelEnSnapshot: 'C7-T1 junction (cervicothoracic)',
|
||||
},
|
||||
])
|
||||
expect(toggleZone(added, a('c7-t1')).zones).toEqual([])
|
||||
})
|
||||
|
||||
it('ensureZone keeps an existing zone and reports its index', () => {
|
||||
const base = toggleZone(
|
||||
toggleZone(emptyObservation(), a('c7-t1')),
|
||||
a('cervical'),
|
||||
)
|
||||
expect(ensureZone(base, a('cervical')).index).toBe(1)
|
||||
const { observation, index } = ensureZone(emptyObservation(), a('cervical'))
|
||||
expect(index).toBe(0)
|
||||
expect(observation.zones[0]!.annotationId).toBe('cervical')
|
||||
})
|
||||
|
||||
it('addSides appends only the missing sides and never removes one', () => {
|
||||
const hip = a('hip')
|
||||
const left = addSides(emptyObservation(), hip, ['left'])
|
||||
expect(sidesPresent(left, refOf(hip))).toEqual(['left'])
|
||||
const same = addSides(left, hip, ['left'])
|
||||
expect(same).toBe(left)
|
||||
const both = addSides(left, hip, ['left', 'right'])
|
||||
expect(both.zones.map((z) => z.side)).toEqual(['left', 'right'])
|
||||
expect(removeAllSides(both, refOf(hip)).zones).toEqual([])
|
||||
})
|
||||
|
||||
it('removeZoneAt removes one zone by index and keeps findings (BDR-019 wart kept, D5)', () => {
|
||||
const obs = {
|
||||
...toggleZone(emptyObservation(), a('c7-t1')),
|
||||
findings: [
|
||||
{
|
||||
findingZoneId: 'c7-t1',
|
||||
path: ['c7-t1-dysfunctions', 'segmental', 'fixation'],
|
||||
labelFrSnapshot: 'F',
|
||||
labelEnSnapshot: 'F',
|
||||
},
|
||||
],
|
||||
}
|
||||
const out = removeZoneAt(obs, 0)
|
||||
expect(out.zones).toEqual([])
|
||||
expect(out.findings).toHaveLength(1)
|
||||
})
|
||||
|
||||
it('detail-view zones are distinct from main-view zones with the same id', () => {
|
||||
const atm = a('atm')
|
||||
const obs = toggleZone(emptyObservation(), atm)
|
||||
expect(obs.zones[0]).toMatchObject({ annotationId: 'atm', viewId: 'head' })
|
||||
expect(decideZoneClick(atm, obs)).toEqual({ kind: 'toggle' })
|
||||
})
|
||||
})
|
||||
|
||||
describe('vertebrae (BDR-019 sync, region codes from the sheet)', () => {
|
||||
it('collects vertebrae across spine zones, the priority zone first', () => {
|
||||
const obs = {
|
||||
...emptyObservation(),
|
||||
zones: [
|
||||
{
|
||||
annotationId: 'thoracic',
|
||||
viewId: 'main',
|
||||
vertebrae: [{ region: 'T', index: 2 }],
|
||||
},
|
||||
{
|
||||
annotationId: 'cervical',
|
||||
viewId: 'main',
|
||||
vertebrae: [
|
||||
{ region: 'C', index: 3 },
|
||||
{ region: 'C', index: 4 },
|
||||
],
|
||||
},
|
||||
{ annotationId: 'c7-t1', viewId: 'main' },
|
||||
],
|
||||
}
|
||||
expect(collectVertebrae(obs, sheet, 1)).toEqual([
|
||||
{ region: 'C', index: 3 },
|
||||
{ region: 'C', index: 4 },
|
||||
{ region: 'T', index: 2 },
|
||||
])
|
||||
})
|
||||
|
||||
it('replaces per region, prunes emptied zones and spawns zones for new regions', () => {
|
||||
const base = ensureZone(emptyObservation(), a('cervical')).observation
|
||||
const out = syncVertebrae(
|
||||
base,
|
||||
[
|
||||
{ region: 'L', index: 3 },
|
||||
{ region: 'L', index: 4 },
|
||||
{ region: 'Cd', index: 20 },
|
||||
],
|
||||
sheet,
|
||||
'main',
|
||||
)
|
||||
expect(out.zones.map((z) => z.annotationId)).toEqual(['lumbar', 'caudal'])
|
||||
expect(out.zones[0]!.vertebrae).toEqual([
|
||||
{ region: 'L', index: 3 },
|
||||
{ region: 'L', index: 4 },
|
||||
])
|
||||
expect(out.zones[0]!.labelFrSnapshot).toBe('Vertèbres lombaires')
|
||||
const cleared = syncVertebrae(out, [], sheet, 'main')
|
||||
expect(cleared.zones).toEqual([])
|
||||
})
|
||||
|
||||
it('keeps non-spine zones untouched and ignores unknown regions', () => {
|
||||
const base = toggleZone(emptyObservation(), a('c7-t1'))
|
||||
const out = syncVertebrae(base, [{ region: 'XX', index: 1 }], sheet, 'main')
|
||||
expect(out.zones).toEqual(base.zones)
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,113 @@
|
||||
/**
|
||||
* Replaces anatomy.horse / char.svgCatalogLink: the bundled reference sheet
|
||||
* loads, validates, and indexes as the canonical document says.
|
||||
*/
|
||||
import { beforeAll, describe, expect, it } from 'vitest'
|
||||
import { bundledSheetProvider } from '@/sheets/provider'
|
||||
import {
|
||||
buildSheetIndex,
|
||||
isObservable,
|
||||
pickLabel,
|
||||
type SheetIndex,
|
||||
} from '@/services/sheetIndex'
|
||||
import { loadTestSheet } from '../helpers/sheet'
|
||||
|
||||
let sheet: SheetIndex
|
||||
beforeAll(async () => {
|
||||
sheet = await loadTestSheet()
|
||||
})
|
||||
|
||||
describe('bundled sheet provider', () => {
|
||||
it('returns the equine draft with its reference, assets and migration map', async () => {
|
||||
const loaded = await bundledSheetProvider.getReferenceSheet('equine')
|
||||
expect(loaded).not.toBeNull()
|
||||
expect(loaded!.status).toBe('draft')
|
||||
expect(loaded!.speciesId).toBe('equine')
|
||||
expect(loaded!.ref.documentSha256).toMatch(/^[0-9a-f]{64}$/)
|
||||
expect(loaded!.ref.versionId).toBeNull()
|
||||
expect(loaded!.migrationMap.sheet).toEqual(loaded!.ref)
|
||||
expect(Object.keys(loaded!.assets)).toHaveLength(1)
|
||||
expect(loaded!.assets[loaded!.document.views[0]!.svg_asset_id!]).toContain(
|
||||
'<svg',
|
||||
)
|
||||
expect(await bundledSheetProvider.getReferenceSheet('canine')).toBeNull()
|
||||
})
|
||||
})
|
||||
|
||||
describe('sheet index', () => {
|
||||
it('exposes the views, 28 annotations (27 observable), 27 finding zones and 5 regions', () => {
|
||||
const { document } = sheet.sheet
|
||||
expect(sheet.mainView.id).toBe('main')
|
||||
expect(sheet.view('head')).toMatchObject({
|
||||
kind: 'detail',
|
||||
parent_view_id: 'main',
|
||||
svg_asset_id: null,
|
||||
})
|
||||
expect(document.annotations).toHaveLength(28)
|
||||
expect(document.annotations.filter(isObservable)).toHaveLength(27)
|
||||
expect(sheet.annotationsOfView('head')).toHaveLength(9)
|
||||
expect(sheet.annotationsOfView('main')).toHaveLength(19)
|
||||
expect(document.finding_zones).toHaveLength(27)
|
||||
expect(sheet.regions().map((r) => r.code)).toEqual([
|
||||
'C',
|
||||
'T',
|
||||
'L',
|
||||
'S',
|
||||
'Cd',
|
||||
])
|
||||
expect(sheet.region('Cd')).toMatchObject({
|
||||
count: 18,
|
||||
count_range: { min: 15, max: 21 },
|
||||
})
|
||||
})
|
||||
|
||||
it('links every observable annotation to an existing finding zone, the trigger to the head view', () => {
|
||||
for (const a of sheet.sheet.document.annotations) {
|
||||
if (!isObservable(a)) {
|
||||
expect(a.opens_view_id).toBe('head')
|
||||
continue
|
||||
}
|
||||
expect(a.finding_zone_id, a.id).not.toBeNull()
|
||||
expect(sheet.findingZone(a.finding_zone_id!), a.id).toBeDefined()
|
||||
}
|
||||
expect(sheet.spineAnnotation('C', 'main')?.id).toBe('cervical')
|
||||
expect(sheet.spineAnnotation('C', 'head')).toBeUndefined()
|
||||
expect(sheet.isSpine('cervical')).toBe(true)
|
||||
expect(sheet.isSpine('hip')).toBe(false)
|
||||
expect(sheet.isSpine('head-trigger')).toBe(false)
|
||||
})
|
||||
|
||||
it('resolves finding paths and reports absent ones', () => {
|
||||
expect(
|
||||
sheet.nodeAt('hip', [
|
||||
'hip-dysfunctions',
|
||||
'articular',
|
||||
'restriction-flexion',
|
||||
])?.name.fr,
|
||||
).toBe('Restriction en flexion')
|
||||
expect(sheet.nodeAt('hip', ['hip-dysfunctions'])?.name.fr).toBe(
|
||||
'Dysfonctions ostéopathiques',
|
||||
)
|
||||
expect(
|
||||
sheet.nodeAt('cervical', [
|
||||
'cervical-observations',
|
||||
'stumbling-proprioceptive',
|
||||
]),
|
||||
).toBeUndefined()
|
||||
expect(sheet.nodeAt('nowhere', ['x'])).toBeUndefined()
|
||||
expect(sheet.nodeAt('hip', [])).toBeUndefined()
|
||||
})
|
||||
|
||||
it('names annotations and triggers in both locales', () => {
|
||||
expect(pickLabel(sheet.name(sheet.annotation('hip')!), 'fr')).toBe(
|
||||
'Hanche (coxo-fémorale)',
|
||||
)
|
||||
expect(pickLabel(sheet.name(sheet.annotation('hip')!), 'en')).toBe(
|
||||
'Hip joint',
|
||||
)
|
||||
expect(pickLabel(sheet.name(sheet.annotation('head-trigger')!), 'en')).toBe(
|
||||
'Head (left lateral view)',
|
||||
)
|
||||
expect(buildSheetIndex(sheet.sheet).mainView).toEqual(sheet.mainView)
|
||||
})
|
||||
})
|
||||
@@ -1,5 +1,5 @@
|
||||
import { describe, it, expect } from 'vitest'
|
||||
import { ReportSchema } from '@/domain/schema/report'
|
||||
import { ReportSchema } from '@faunosteo/domain'
|
||||
import { generateId } from '@/lib/id'
|
||||
import { todayIso, nowIso } from '@/lib/dates'
|
||||
import { assert } from '@/lib/assert'
|
||||
@@ -12,37 +12,32 @@ describe('skeleton smoke test', () => {
|
||||
})
|
||||
|
||||
it('todayIso returns an ISO date string', () => {
|
||||
const today = todayIso()
|
||||
expect(today).toMatch(/^\d{4}-\d{2}-\d{2}$/)
|
||||
expect(todayIso()).toMatch(/^\d{4}-\d{2}-\d{2}$/)
|
||||
})
|
||||
|
||||
it('nowIso returns an ISO timestamp string', () => {
|
||||
const now = nowIso()
|
||||
expect(now).toMatch(/^\d{4}-\d{2}-\d{2}T/)
|
||||
expect(nowIso()).toMatch(/^\d{4}-\d{2}-\d{2}T/)
|
||||
})
|
||||
|
||||
it('ReportSchema parses a valid minimal report', () => {
|
||||
const validReport = {
|
||||
version: 2 as const,
|
||||
it('ReportSchema parses a valid minimal v3 report', () => {
|
||||
const result = ReportSchema.safeParse({
|
||||
version: 3,
|
||||
id: generateId(),
|
||||
createdAt: nowIso(),
|
||||
date: todayIso(),
|
||||
practitioner: { name: 'Dr. Dupont' },
|
||||
animal: { speciesId: 'equine', name: 'Mistral' },
|
||||
owner: { name: 'Jean Martin' },
|
||||
sheet: { sheetId: 's', versionId: null, documentSha256: 'a'.repeat(64) },
|
||||
observations: [],
|
||||
conclusion: '',
|
||||
recommendations: '',
|
||||
}
|
||||
|
||||
const result = ReportSchema.safeParse(validReport)
|
||||
})
|
||||
expect(result.success).toBe(true)
|
||||
})
|
||||
|
||||
it('ReportSchema rejects a report missing required fields', () => {
|
||||
const invalid = { version: 1, id: '' }
|
||||
const result = ReportSchema.safeParse(invalid)
|
||||
expect(result.success).toBe(false)
|
||||
expect(ReportSchema.safeParse({ version: 1, id: '' }).success).toBe(false)
|
||||
})
|
||||
|
||||
it('assert passes when condition is truthy', () => {
|
||||
|
||||
@@ -1,52 +0,0 @@
|
||||
import { describe, it, expect } from 'vitest'
|
||||
import EQUINE_FINDINGS from '@/domain/species/equine/pathologies'
|
||||
import {
|
||||
SpeciesFindingsSchema,
|
||||
type FindingNode,
|
||||
} from '@/domain/schema/findings'
|
||||
|
||||
function walkLeaves(node: FindingNode, fn: (leaf: FindingNode) => void): void {
|
||||
if (!node.children || node.children.length === 0) {
|
||||
fn(node)
|
||||
return
|
||||
}
|
||||
for (const child of node.children) walkLeaves(child, fn)
|
||||
}
|
||||
|
||||
describe('equine findings tree', () => {
|
||||
it('parses against SpeciesFindingsSchema', () => {
|
||||
expect(() => SpeciesFindingsSchema.parse(EQUINE_FINDINGS)).not.toThrow()
|
||||
})
|
||||
|
||||
it('species id matches the registry id', () => {
|
||||
expect(EQUINE_FINDINGS.species.id).toBe('equine')
|
||||
})
|
||||
|
||||
it('scope_disclaimer is non-empty', () => {
|
||||
expect(EQUINE_FINDINGS.scope_disclaimer.length).toBeGreaterThan(0)
|
||||
})
|
||||
|
||||
it('has at least one zone with at least one category with at least one leaf', () => {
|
||||
const zoneIds = Object.keys(EQUINE_FINDINGS.zones)
|
||||
expect(zoneIds.length).toBeGreaterThanOrEqual(1)
|
||||
const someZone = EQUINE_FINDINGS.zones[zoneIds[0]]
|
||||
expect(someZone.categories.length).toBeGreaterThanOrEqual(1)
|
||||
let leafCount = 0
|
||||
walkLeaves(someZone.categories[0], () => {
|
||||
leafCount += 1
|
||||
})
|
||||
expect(leafCount).toBeGreaterThanOrEqual(1)
|
||||
})
|
||||
|
||||
it('every leaf carries both FR and EN labels', () => {
|
||||
const missing: string[] = []
|
||||
for (const zone of Object.values(EQUINE_FINDINGS.zones)) {
|
||||
for (const category of zone.categories) {
|
||||
walkLeaves(category, (leaf) => {
|
||||
if (!leaf.name_fr || !leaf.name_en) missing.push(leaf.id)
|
||||
})
|
||||
}
|
||||
}
|
||||
expect(missing).toEqual([])
|
||||
})
|
||||
})
|
||||
@@ -1,24 +0,0 @@
|
||||
import { describe, it, expect } from 'vitest'
|
||||
import { getSpecies, getAllSpecies } from '@/domain/species/registry'
|
||||
|
||||
describe('species registry', () => {
|
||||
it('returns the equine manifest', () => {
|
||||
const eq = getSpecies('equine')
|
||||
expect(eq).toBeDefined()
|
||||
expect(eq?.labelFr).toBe('Cheval')
|
||||
expect(eq?.labelEn).toBe('Horse')
|
||||
expect(eq?.mainSvg).toBe('/species/equine/Horse.svg')
|
||||
expect(eq?.details.head).toBe('/species/equine/Horse_head.svg')
|
||||
expect(eq?.vertebralFormula).toEqual({ C: 7, T: 18, L: 6, S: 5, Cd: 18 })
|
||||
})
|
||||
|
||||
it('returns undefined for unknown species', () => {
|
||||
expect(getSpecies('martian')).toBeUndefined()
|
||||
})
|
||||
|
||||
it('lists at least the equine species', () => {
|
||||
const all = getAllSpecies()
|
||||
expect(all.length).toBeGreaterThanOrEqual(1)
|
||||
expect(all.find((s) => s.id === 'equine')).toBeDefined()
|
||||
})
|
||||
})
|
||||
@@ -1,35 +0,0 @@
|
||||
import { describe, it, expect, beforeEach } from 'vitest'
|
||||
import { useReportStore } from '@/state/reportStore'
|
||||
|
||||
const STORAGE_KEY = 'osteo:draft'
|
||||
|
||||
const draft = {
|
||||
date: '2026-05-18',
|
||||
practitioner: { name: 'Dr. Dupont' },
|
||||
animal: { speciesId: 'equine', name: 'Mistral' },
|
||||
owner: { name: 'Jean Martin' },
|
||||
observations: [],
|
||||
conclusion: '',
|
||||
recommendations: '',
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
useReportStore.getState().reset()
|
||||
sessionStorage.clear()
|
||||
})
|
||||
|
||||
describe('reportStore sessionStorage mirror', () => {
|
||||
it('mirrors the report on every change', () => {
|
||||
useReportStore.getState().initReport(draft)
|
||||
const raw = sessionStorage.getItem(STORAGE_KEY)
|
||||
expect(raw).not.toBeNull()
|
||||
const parsed = JSON.parse(raw!)
|
||||
expect(parsed.practitioner.name).toBe('Dr. Dupont')
|
||||
})
|
||||
|
||||
it('clears the mirror on reset', () => {
|
||||
useReportStore.getState().initReport(draft)
|
||||
useReportStore.getState().reset()
|
||||
expect(sessionStorage.getItem(STORAGE_KEY)).toBeNull()
|
||||
})
|
||||
})
|
||||
@@ -1,58 +0,0 @@
|
||||
import { describe, it, expect, beforeEach, vi } from 'vitest'
|
||||
|
||||
const draft = {
|
||||
date: '2026-05-18',
|
||||
practitioner: { name: 'Dr. Dupont' },
|
||||
animal: { speciesId: 'equine', name: 'Mistral' },
|
||||
owner: { name: 'Jean Martin' },
|
||||
observations: [],
|
||||
conclusion: '',
|
||||
recommendations: '',
|
||||
}
|
||||
|
||||
/** Fresh module instance = simulated page load. */
|
||||
async function freshStore() {
|
||||
const mod = await import('@/state/reportStore')
|
||||
return mod.useReportStore
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
vi.resetModules()
|
||||
sessionStorage.clear()
|
||||
})
|
||||
|
||||
describe('reportStore draft restore', () => {
|
||||
it('restores the sessionStorage draft on store init (page refresh)', async () => {
|
||||
const store1 = await freshStore()
|
||||
store1.getState().initReport(draft)
|
||||
const saved = store1.getState().report!
|
||||
|
||||
vi.resetModules() // simulate refresh: new module, sessionStorage intact
|
||||
const store2 = await freshStore()
|
||||
|
||||
expect(store2.getState().report).not.toBeNull()
|
||||
expect(store2.getState().report!.id).toBe(saved.id)
|
||||
expect(store2.getState().report!.animal.name).toBe('Mistral')
|
||||
})
|
||||
|
||||
it('starts empty when the stored draft is invalid', async () => {
|
||||
sessionStorage.setItem('osteo:draft', '{"version":999,"garbage":true}')
|
||||
const store = await freshStore()
|
||||
expect(store.getState().report).toBeNull()
|
||||
})
|
||||
|
||||
it('starts empty when no draft exists', async () => {
|
||||
const store = await freshStore()
|
||||
expect(store.getState().report).toBeNull()
|
||||
})
|
||||
|
||||
it('clears the draft after reset (no resurrection on next load)', async () => {
|
||||
const store1 = await freshStore()
|
||||
store1.getState().initReport(draft)
|
||||
store1.getState().reset()
|
||||
|
||||
vi.resetModules()
|
||||
const store2 = await freshStore()
|
||||
expect(store2.getState().report).toBeNull()
|
||||
})
|
||||
})
|
||||
Loaded 100 of 114 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user