feat(domain): canonical anatomical sheet document, integrity rules, tests

This commit is contained in:
bchanot committed 2026-10-08 23:42:42 +02:00
1 parent aea8902711
commit 36812f4625
13 files changed
+1849

No files matched your search

+20
View File
@@ -0,0 +1,20 @@
import globals from 'globals'
import tseslint from 'typescript-eslint'
export default tseslint.config(
{ ignores: ['node_modules/**'] },
{
files: ['**/*.ts'],
extends: [...tseslint.configs.recommended],
languageOptions: {
globals: { ...globals.node, ...globals.es2022 },
},
rules: {
'@typescript-eslint/no-explicit-any': 'warn',
'@typescript-eslint/no-unused-vars': [
'error',
{ argsIgnorePattern: '^_' },
],
},
},
)
+32
View File
@@ -0,0 +1,32 @@
{
"name": "@faunosteo/domain",
"version": "0.1.0",
"private": true,
"description": "Faunosteo pure domain model: canonical anatomical sheet document, Zod schemas and integrity rules",
"license": "MIT",
"type": "module",
"main": "./src/index.ts",
"types": "./src/index.ts",
"exports": {
".": "./src/index.ts",
"./anatomical-sheet": "./src/anatomical-sheet/index.ts"
},
"scripts": {
"typecheck": "tsc -p tsconfig.json --noEmit",
"test": "vitest",
"test:run": "vitest run",
"lint": "eslint . --max-warnings 0",
"build": "tsc -p tsconfig.json --noEmit"
},
"dependencies": {
"zod": "^3.24.1"
},
"devDependencies": {
"@types/node": "^20.19.41",
"eslint": "^9.17.0",
"globals": "^15.14.0",
"typescript": "^5.7.2",
"typescript-eslint": "^8.19.0",
"vitest": "^3.2.7"
}
}
@@ -0,0 +1,43 @@
import {
AnatomicalSheetDocumentSchema,
SHEET_DOCUMENT_SCHEMA_VERSION,
type AnatomicalSheetDocument,
type LocalizedText,
} from './schema'
export interface NewSheetDocumentParams {
species_id: string
name: LocalizedText
}
export const MAIN_VIEW_ID = 'view-main'
/**
* Starting point of a new sheet: shape-valid so it can be saved as a draft
* at once, but not publishable until the main view gets its SVG asset.
*/
export function createEmptySheetDocument(
params: NewSheetDocumentParams,
): AnatomicalSheetDocument {
return AnatomicalSheetDocumentSchema.parse({
schema_version: SHEET_DOCUMENT_SCHEMA_VERSION,
species_id: params.species_id,
name: params.name,
description: {},
scope_disclaimer: {},
attribution: { authors: [], license: null, notes: null },
vertebral_config: { regions: [] },
categories: [],
views: [
{
id: MAIN_VIEW_ID,
kind: 'main',
name: { fr: 'Vue principale', en: 'Main view' },
svg_asset_id: null,
view_box: null,
},
],
annotations: [],
finding_zones: [],
})
}
@@ -0,0 +1,3 @@
export * from './schema'
export * from './validate'
export * from './create'
@@ -0,0 +1,280 @@
import { z } from 'zod'
/**
* Canonical anatomical sheet document, schema_version 1.
*
* Shape contract of docs/development/ANATOMICAL_SHEET_MODEL.md §2. Every
* object is strict: a canonical document must not silently carry fields no
* version of the schema defines. Cross-references (view ids, zone ids…) are
* checked by validateSheetDocument, not here, so a draft with dangling
* references can still be saved.
*/
export const SHEET_DOCUMENT_SCHEMA_VERSION = 1
/** Ids are never derived from labels, so translations never move them. */
export const STABLE_ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,63}$/
export const StableIdSchema = z.string().regex(STABLE_ID_PATTERN)
/** Region codes are free (C, T, L, S, Cd for the horse), case included. */
export const RegionCodeSchema = z
.string()
.regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,15}$/)
export const LocalizedTextSchema = z
.object({ fr: z.string().min(1), en: z.string().min(1) })
.strict()
export const LocalizedOptionalTextSchema = z
.object({ fr: z.string().optional(), en: z.string().optional() })
.strict()
export const VertebralRegionSchema = z
.object({
code: RegionCodeSchema,
name: LocalizedTextSchema,
count: z.number().int().min(1),
})
.strict()
const HexColorSchema = z.string().regex(/^#[0-9a-fA-F]{6}$/)
export const AnnotationCategorySchema = z
.object({
id: StableIdSchema,
name: LocalizedTextSchema,
color: HexColorSchema.nullable(),
})
.strict()
const CoordinateSchema = z.number().finite()
export const ViewBoxSchema = z
.object({
min_x: CoordinateSchema,
min_y: CoordinateSchema,
width: CoordinateSchema.positive(),
height: CoordinateSchema.positive(),
})
.strict()
/** Null asset on a detail view means "parent asset cropped by view_box". */
const viewCommon = {
id: StableIdSchema,
name: LocalizedTextSchema,
svg_asset_id: z.string().uuid().nullable(),
view_box: ViewBoxSchema.nullable(),
}
const MainViewSchema = z
.object({ ...viewCommon, kind: z.literal('main') })
.strict()
const DetailViewSchema = z
.object({
...viewCommon,
kind: z.literal('detail'),
parent_view_id: StableIdSchema,
})
.strict()
/** Views form a tree: a detail names its parent, any depth. */
export const SheetViewSchema = z.discriminatedUnion('kind', [
MainViewSchema,
DetailViewSchema,
])
const CircleSchema = z
.object({
type: z.literal('circle'),
cx: CoordinateSchema,
cy: CoordinateSchema,
r: CoordinateSchema.positive(),
})
.strict()
const PolygonSchema = z
.object({
type: z.literal('polygon'),
points: z.array(z.tuple([CoordinateSchema, CoordinateSchema])).min(3),
})
.strict()
const PathSchema = z
.object({ type: z.literal('path'), d: z.string().min(1) })
.strict()
export const GeometrySchema = z.discriminatedUnion('type', [
CircleSchema,
PolygonSchema,
PathSchema,
])
/** Explicit on every annotation: absence no longer carries meaning. */
export const LateralitySchema = z.enum([
'unpaired',
'bilateral',
'left',
'right',
])
const annotationCommon = {
id: StableIdSchema,
view_id: StableIdSchema,
category_id: StableIdSchema,
laterality: LateralitySchema,
geometry: GeometrySchema.nullable(),
}
/** Observable annotations link to findings through one explicit field. */
const observableFields = {
...annotationCommon,
name: LocalizedTextSchema,
finding_zone_id: StableIdSchema.nullable(),
vertebral_region_code: RegionCodeSchema.nullable(),
}
const PointAnnotationSchema = z
.object({ ...observableFields, kind: z.literal('point') })
.strict()
const ZoneAnnotationSchema = z
.object({ ...observableFields, kind: z.literal('zone') })
.strict()
/** Navigation only: a trigger never carries findings. */
const DetailTriggerAnnotationSchema = z
.object({
...annotationCommon,
kind: z.literal('detail_trigger'),
name: LocalizedTextSchema.nullable(),
opens_view_id: StableIdSchema,
})
.strict()
export const AnnotationSchema = z.discriminatedUnion('kind', [
PointAnnotationSchema,
ZoneAnnotationSchema,
DetailTriggerAnnotationSchema,
])
export const SourceRefSchema = z
.object({
type: z.enum(['manual', 'journal', 'database', 'web']),
citation: z.string().min(1),
url: z.string().url().optional(),
})
.strict()
export type SourceRef = z.infer<typeof SourceRefSchema>
export type LocalizedText = z.infer<typeof LocalizedTextSchema>
export type LocalizedOptionalText = z.infer<typeof LocalizedOptionalTextSchema>
/** Parsed node: every optional key of the authoring form is filled in. */
export interface FindingNode {
id: string
name: LocalizedText
description: LocalizedOptionalText
requires_vet_referral: boolean
sources: SourceRef[]
children: FindingNode[]
}
/** Authoring form: leaves stay lean, hundreds of them carry no empty keys. */
export interface FindingNodeInput {
id: string
name: LocalizedText
description?: LocalizedOptionalText
requires_vet_referral?: boolean
sources?: SourceRef[]
children?: FindingNodeInput[]
}
export const FindingNodeSchema: z.ZodType<
FindingNode,
z.ZodTypeDef,
FindingNodeInput
> = z.lazy(() =>
z
.object({
id: StableIdSchema,
name: LocalizedTextSchema,
description: LocalizedOptionalTextSchema.default({}),
requires_vet_referral: z.boolean().default(false),
sources: z.array(SourceRefSchema).default([]),
children: z.array(FindingNodeSchema).default([]),
})
.strict(),
)
/** Typed business buckets; creators may add their own as 'custom'. */
export const FindingCategoryKindSchema = z.enum([
'dysfunction',
'observation',
'anamnesis',
'custom',
])
export const FindingCategorySchema = z
.object({
id: StableIdSchema,
kind: FindingCategoryKindSchema,
name: LocalizedTextSchema,
description: LocalizedOptionalTextSchema.default({}),
children: z.array(FindingNodeSchema),
})
.strict()
export const FindingZoneSchema = z
.object({
id: StableIdSchema,
name: LocalizedTextSchema,
categories: z.array(FindingCategorySchema),
})
.strict()
const AttributionSchema = z
.object({
authors: z.array(z.string().min(1)),
license: z.string().min(1).nullable(),
notes: z.string().min(1).nullable(),
})
.strict()
const VertebralConfigSchema = z
.object({ regions: z.array(VertebralRegionSchema) })
.strict()
export const AnatomicalSheetDocumentSchema = z
.object({
schema_version: z.literal(SHEET_DOCUMENT_SCHEMA_VERSION),
species_id: StableIdSchema,
name: LocalizedTextSchema,
description: LocalizedOptionalTextSchema,
scope_disclaimer: LocalizedOptionalTextSchema,
attribution: AttributionSchema,
vertebral_config: VertebralConfigSchema,
categories: z.array(AnnotationCategorySchema),
views: z.array(SheetViewSchema),
annotations: z.array(AnnotationSchema),
finding_zones: z.array(FindingZoneSchema),
})
.strict()
export type AnatomicalSheetDocument = z.output<
typeof AnatomicalSheetDocumentSchema
>
export type AnatomicalSheetDocumentInput = z.input<
typeof AnatomicalSheetDocumentSchema
>
export type VertebralRegion = z.infer<typeof VertebralRegionSchema>
export type AnnotationCategory = z.infer<typeof AnnotationCategorySchema>
export type ViewBox = z.infer<typeof ViewBoxSchema>
export type SheetView = z.infer<typeof SheetViewSchema>
export type Geometry = z.infer<typeof GeometrySchema>
export type Laterality = z.infer<typeof LateralitySchema>
export type Annotation = z.infer<typeof AnnotationSchema>
export type FindingCategoryKind = z.infer<typeof FindingCategoryKindSchema>
export type FindingCategory = z.output<typeof FindingCategorySchema>
export type FindingZone = z.output<typeof FindingZoneSchema>
@@ -0,0 +1,426 @@
import type {
AnatomicalSheetDocument,
Annotation,
FindingNode,
SheetView,
} from './schema'
/**
* Integrity tier of the sheet model (ANATOMICAL_SHEET_MODEL.md §2.1).
*
* The shape tier (Zod) accepts dangling references so drafts can be saved
* mid-edit; this tier lists every inconsistency for the editor and gates
* publication. Each rule is one function; codes are part of the contract
* shared with the SQL re-check (private.sheet_document_issues).
*/
export type SheetIssueSeverity = 'error' | 'warning'
export interface SheetIssue {
code: string
severity: SheetIssueSeverity
path: string
message: string
}
type Rule = (doc: AnatomicalSheetDocument) => SheetIssue[]
type ObservableAnnotation = Exclude<Annotation, { kind: 'detail_trigger' }>
type TriggerAnnotation = Extract<Annotation, { kind: 'detail_trigger' }>
type DetailView = Extract<SheetView, { kind: 'detail' }>
/** A sibling level of the finding tree: categories or node children. */
interface FindingLevelItem {
id: string
children: readonly FindingNode[]
}
function error(code: string, path: string, message: string): SheetIssue {
return { code, severity: 'error', path, message }
}
function warning(code: string, path: string, message: string): SheetIssue {
return { code, severity: 'warning', path, message }
}
/** Indexes of entries whose value already appeared earlier in the list. */
function repeatedIndexes(values: readonly string[]): number[] {
const seen = new Set<string>()
const repeated: number[] = []
values.forEach((value, index) => {
if (seen.has(value)) repeated.push(index)
seen.add(value)
})
return repeated
}
function duplicateIssues(
values: readonly string[],
code: string,
pathOf: (index: number) => string,
): SheetIssue[] {
return repeatedIndexes(values).map((index) =>
error(code, pathOf(index), `Duplicate id "${values[index]}"`),
)
}
function isObservable(
annotation: Annotation,
): annotation is ObservableAnnotation {
return annotation.kind !== 'detail_trigger'
}
function isTrigger(annotation: Annotation): annotation is TriggerAnnotation {
return annotation.kind === 'detail_trigger'
}
function viewsById(doc: AnatomicalSheetDocument): Map<string, SheetView> {
const byId = new Map<string, SheetView>()
for (const view of doc.views) if (!byId.has(view.id)) byId.set(view.id, view)
return byId
}
/** Rendering starts from a single root drawing. */
const checkMainViewCount: Rule = (doc) => {
const count = doc.views.filter((view) => view.kind === 'main').length
if (count === 1) return []
return [
error('view.main.count', 'views', `Expected 1 main view, found ${count}`),
]
}
const checkViewIdsUnique: Rule = (doc) =>
duplicateIssues(
doc.views.map((view) => view.id),
'view.id.duplicate',
(index) => `views[${index}].id`,
)
const checkViewParentsExist: Rule = (doc) => {
const byId = viewsById(doc)
return doc.views.flatMap((view, index) =>
view.kind === 'detail' && !byId.has(view.parent_view_id)
? [
error(
'view.parent.missing',
`views[${index}].parent_view_id`,
`Parent view "${view.parent_view_id}" does not exist`,
),
]
: [],
)
}
/**
* True when the parent chain loops before reaching the main view. A
* missing parent ends the walk: that case is view.parent.missing.
*/
function loopsBeforeMain(view: DetailView, byId: Map<string, SheetView>) {
const visited = new Set<string>([view.id])
let current: SheetView = view
while (current.kind === 'detail') {
const parent = byId.get(current.parent_view_id)
if (!parent) return false
if (visited.has(parent.id)) return true
visited.add(parent.id)
current = parent
}
return false
}
const checkViewParentCycles: Rule = (doc) => {
const byId = viewsById(doc)
return doc.views.flatMap((view, index) =>
view.kind === 'detail' && loopsBeforeMain(view, byId)
? [
error(
'view.parent.cycle',
`views[${index}].parent_view_id`,
`Parent chain of "${view.id}" never reaches the main view`,
),
]
: [],
)
}
function isOpenedFromParent(
view: DetailView,
doc: AnatomicalSheetDocument,
): boolean {
return doc.annotations.some(
(annotation) =>
isTrigger(annotation) &&
annotation.opens_view_id === view.id &&
annotation.view_id === view.parent_view_id,
)
}
/** A detail view nobody can open is dead content for the practitioner. */
const checkViewsReachable: Rule = (doc) => {
const byId = viewsById(doc)
return doc.views.flatMap((view, index) =>
view.kind === 'detail' &&
byId.has(view.parent_view_id) &&
!isOpenedFromParent(view, doc)
? [
error(
'view.unreachable',
`views[${index}]`,
`No detail_trigger in "${view.parent_view_id}" opens "${view.id}"`,
),
]
: [],
)
}
/** Every view must have something to draw: its own asset or a crop. */
function viewAssetIssue(view: SheetView, index: number): SheetIssue[] {
if (view.svg_asset_id !== null) return []
if (view.kind === 'main') {
return [
error(
'view.asset.missing',
`views[${index}].svg_asset_id`,
`Main view "${view.id}" has no SVG asset`,
),
]
}
if (view.view_box !== null) return []
return [
error(
'view.asset.missing',
`views[${index}].view_box`,
`Detail view "${view.id}" has neither an asset nor a view_box`,
),
]
}
const checkViewAssets: Rule = (doc) => doc.views.flatMap(viewAssetIssue)
/** Report points are keyed by annotation id across every view. */
const checkAnnotationIdsUnique: Rule = (doc) =>
duplicateIssues(
doc.annotations.map((annotation) => annotation.id),
'annotation.id.duplicate',
(index) => `annotations[${index}].id`,
)
const checkAnnotationViews: Rule = (doc) => {
const byId = viewsById(doc)
return doc.annotations.flatMap((annotation, index) =>
byId.has(annotation.view_id)
? []
: [
error(
'annotation.view.missing',
`annotations[${index}].view_id`,
`View "${annotation.view_id}" does not exist`,
),
],
)
}
const checkAnnotationCategories: Rule = (doc) => {
const ids = new Set(doc.categories.map((category) => category.id))
return doc.annotations.flatMap((annotation, index) =>
ids.has(annotation.category_id)
? []
: [
error(
'annotation.category.missing',
`annotations[${index}].category_id`,
`Category "${annotation.category_id}" does not exist`,
),
],
)
}
/** A trigger opens a direct child of the view it is drawn in. */
function opensChildOfOwnView(
trigger: TriggerAnnotation,
byId: Map<string, SheetView>,
): boolean {
const target = byId.get(trigger.opens_view_id)
return target?.kind === 'detail' && target.parent_view_id === trigger.view_id
}
const checkTriggerTargets: Rule = (doc) => {
const byId = viewsById(doc)
return doc.annotations.flatMap((annotation, index) =>
isTrigger(annotation) && !opensChildOfOwnView(annotation, byId)
? [
error(
'annotation.opens_view.invalid',
`annotations[${index}].opens_view_id`,
`"${annotation.opens_view_id}" is not a detail child of ` +
`"${annotation.view_id}"`,
),
]
: [],
)
}
const checkAnnotationFindingZones: Rule = (doc) => {
const ids = new Set(doc.finding_zones.map((zone) => zone.id))
return doc.annotations.flatMap((annotation, index) =>
isObservable(annotation) &&
annotation.finding_zone_id !== null &&
!ids.has(annotation.finding_zone_id)
? [
error(
'annotation.finding_zone.missing',
`annotations[${index}].finding_zone_id`,
`Finding zone "${annotation.finding_zone_id}" does not exist`,
),
]
: [],
)
}
const checkAnnotationRegions: Rule = (doc) => {
const codes = new Set(doc.vertebral_config.regions.map((r) => r.code))
return doc.annotations.flatMap((annotation, index) =>
isObservable(annotation) &&
annotation.vertebral_region_code !== null &&
!codes.has(annotation.vertebral_region_code)
? [
error(
'annotation.region.missing',
`annotations[${index}].vertebral_region_code`,
`Vertebral region "${annotation.vertebral_region_code}" ` +
'is not configured',
),
]
: [],
)
}
/** Allowed in a draft, but a click on it would offer nothing to record. */
const checkAnnotationsHaveFindings: Rule = (doc) =>
doc.annotations.flatMap((annotation, index) =>
isObservable(annotation) && annotation.finding_zone_id === null
? [
warning(
'annotation.no_findings',
`annotations[${index}].finding_zone_id`,
`Annotation "${annotation.id}" is linked to no finding zone`,
),
]
: [],
)
const checkRegionCodesUnique: Rule = (doc) =>
duplicateIssues(
doc.vertebral_config.regions.map((region) => region.code),
'region.code.duplicate',
(index) => `vertebral_config.regions[${index}].code`,
)
const checkCategoryIdsUnique: Rule = (doc) =>
duplicateIssues(
doc.categories.map((category) => category.id),
'category.id.duplicate',
(index) => `categories[${index}].id`,
)
const checkFindingZoneIdsUnique: Rule = (doc) =>
duplicateIssues(
doc.finding_zones.map((zone) => zone.id),
'finding_zone.id.duplicate',
(index) => `finding_zones[${index}].id`,
)
/**
* Findings are addressed by (zone, path[]) as Finding.path does today, so
* ids only need to be unique among siblings, at every depth.
*/
function siblingIssues(
nodes: readonly FindingLevelItem[],
path: string,
): SheetIssue[] {
const own = duplicateIssues(
nodes.map((node) => node.id),
'finding.id.duplicate',
(index) => `${path}[${index}].id`,
)
const nested = nodes.flatMap((node, index) =>
siblingIssues(node.children, `${path}[${index}].children`),
)
return [...own, ...nested]
}
const checkFindingSiblings: Rule = (doc) =>
doc.finding_zones.flatMap((zone, index) =>
siblingIssues(zone.categories, `finding_zones[${index}].categories`),
)
/** Allowed in a draft, but nothing on the drawing can reach this zone. */
const checkFindingZonesReferenced: Rule = (doc) => {
const referenced = new Set(
doc.annotations.filter(isObservable).map((a) => a.finding_zone_id),
)
return doc.finding_zones.flatMap((zone, index) =>
referenced.has(zone.id)
? []
: [
warning(
'finding_zone.unreferenced',
`finding_zones[${index}]`,
`No annotation points to finding zone "${zone.id}"`,
),
],
)
}
const RULES: readonly Rule[] = [
checkMainViewCount,
checkViewIdsUnique,
checkViewParentsExist,
checkViewParentCycles,
checkViewsReachable,
checkViewAssets,
checkAnnotationIdsUnique,
checkAnnotationViews,
checkAnnotationCategories,
checkTriggerTargets,
checkAnnotationFindingZones,
checkAnnotationRegions,
checkAnnotationsHaveFindings,
checkRegionCodesUnique,
checkCategoryIdsUnique,
checkFindingZoneIdsUnique,
checkFindingSiblings,
checkFindingZonesReferenced,
]
/** Lists every integrity issue of a shape-valid document. */
export function validateSheetDocument(
doc: AnatomicalSheetDocument,
): SheetIssue[] {
return RULES.flatMap((rule) => rule(doc))
}
/** Warnings never block publication; errors always do. */
export function isPublishable(issues: readonly SheetIssue[]): boolean {
return !issues.some((issue) => issue.severity === 'error')
}
export class SheetValidationError extends Error {
readonly issues: SheetIssue[]
constructor(issues: SheetIssue[]) {
const errors = issues.filter((issue) => issue.severity === 'error')
super(
`Sheet document is not publishable: ${errors.length} error(s), ` +
`first: ${errors[0]?.code ?? 'none'}`,
)
this.name = 'SheetValidationError'
this.issues = issues
}
}
/** TypeScript-side publication gate, mirrored by SQL at publish time. */
export function assertPublishable(doc: AnatomicalSheetDocument): void {
const issues = validateSheetDocument(doc)
if (!isPublishable(issues)) throw new SheetValidationError(issues)
}
+1
View File
@@ -0,0 +1 @@
export * from './anatomical-sheet'
@@ -0,0 +1,117 @@
import {
AnatomicalSheetDocumentSchema,
FindingNodeSchema,
StableIdSchema,
type AnatomicalSheetDocumentInput,
} from '../src'
import { horseSlice, horseSliceInput } from './fixtures/horse-slice'
// Mutations deliberately break the typed shape, so the draft is untyped.
// eslint-disable-next-line @typescript-eslint/no-explicit-any
type LooseDoc = any
type Mutation = (doc: LooseDoc) => void
/** Applies a mutation to the lean fixture and reports whether it parses. */
function parsesAfter(mutate: Mutation): boolean {
const doc: LooseDoc = horseSliceInput()
mutate(doc)
return AnatomicalSheetDocumentSchema.safeParse(doc).success
}
describe('AnatomicalSheetDocumentSchema', () => {
it('accepts the horse slice fixture', () => {
const result = AnatomicalSheetDocumentSchema.safeParse(horseSliceInput())
expect(result.success).toBe(true)
})
it('accepts a parsed document again (output is valid input)', () => {
expect(AnatomicalSheetDocumentSchema.parse(horseSlice())).toEqual(
horseSlice(),
)
})
const rejections: Array<[string, Mutation]> = [
['an unknown top-level key', (d) => (d.extra = true)],
['an unknown nested key', (d) => (d.views[0].zoom = 2)],
['a stable id with spaces', (d) => (d.annotations[0].id = 'Hip Joint')],
['a stable id with an accent', (d) => (d.categories[0].id = 'É')],
['an empty stable id', (d) => (d.finding_zones[0].id = '')],
['schema_version 2', (d) => (d.schema_version = 2)],
['a non-uuid svg_asset_id', (d) => (d.views[0].svg_asset_id = 'horse')],
[
'a polygon with 2 points',
(d) =>
(d.annotations[1].geometry.points = [
[0, 0],
[1, 1],
]),
],
['a circle with r 0', (d) => (d.annotations[0].geometry.r = 0)],
['a region count of 0', (d) => (d.vertebral_config.regions[0].count = 0)],
['a missing en label', (d) => delete d.name.en],
[
'a detail view without parent_view_id',
(d) => delete d.views[1].parent_view_id,
],
[
'a detail_trigger with finding_zone_id',
(d) => (d.annotations[3].finding_zone_id = 'hip'),
],
[
'a finding category kind foo',
(d) => (d.finding_zones[0].categories[0].kind = 'foo'),
],
]
it.each(rejections)('rejects %s', (_label, mutate) => {
expect(parsesAfter(mutate)).toBe(false)
})
})
describe('StableIdSchema', () => {
it.each(['hip', 'c7-t1', 'view_main', '0'])('accepts %s', (id) => {
expect(StableIdSchema.safeParse(id).success).toBe(true)
})
it.each(['Hip Joint', 'É', '', '-hip', 'a'.repeat(65)])(
'rejects %j',
(id) => {
expect(StableIdSchema.safeParse(id).success).toBe(false)
},
)
})
describe('FindingNodeSchema defaults', () => {
it('fills the optional keys of a lean node, recursively', () => {
const node = FindingNodeSchema.parse({
id: 'articular',
name: { fr: 'Articulaire', en: 'Articular' },
children: [{ id: 'flexion', name: { fr: 'Flexion', en: 'Flexion' } }],
})
expect(node.description).toEqual({})
expect(node.requires_vet_referral).toBe(false)
expect(node.sources).toEqual([])
expect(node.children[0]).toEqual({
id: 'flexion',
name: { fr: 'Flexion', en: 'Flexion' },
description: {},
requires_vet_referral: false,
sources: [],
children: [],
})
})
it('keeps explicit values of the fixture', () => {
const doc = horseSlice()
const lameness = doc.finding_zones[0].categories[1].children[0]
expect(lameness.requires_vet_referral).toBe(true)
const trauma = doc.finding_zones[0].categories[2].children[0]
expect(trauma.sources).toHaveLength(1)
})
it('does not add default keys to the lean input', () => {
const input: AnatomicalSheetDocumentInput = horseSliceInput()
const leaf = input.finding_zones[2].categories[0].children[0]
expect(Object.keys(leaf)).toEqual(['id', 'name'])
})
})
@@ -0,0 +1,426 @@
import {
AnatomicalSheetDocumentSchema,
SheetValidationError,
assertPublishable,
createEmptySheetDocument,
isPublishable,
validateSheetDocument,
type AnatomicalSheetDocument,
type Annotation,
type SheetView,
} from '../src'
import { HORSE_MAIN_ASSET_ID, horseSlice } from './fixtures/horse-slice'
/** [code, path] pairs: what each rule test pins down. */
function issuesOf(doc: AnatomicalSheetDocument): Array<[string, string]> {
return validateSheetDocument(doc).map((issue) => [issue.code, issue.path])
}
function mutated(
mutate: (doc: AnatomicalSheetDocument) => void,
): AnatomicalSheetDocument {
const doc = horseSlice()
mutate(doc)
return doc
}
function point(id: string, fields: Partial<Annotation> = {}): Annotation {
return {
id,
kind: 'point',
view_id: 'view-main',
category_id: 'articulations',
laterality: 'bilateral',
geometry: null,
name: { fr: id, en: id },
finding_zone_id: 'hip',
vertebral_region_code: null,
...fields,
} as Annotation
}
function trigger(id: string, viewId: string, opensViewId: string) {
return {
id,
kind: 'detail_trigger',
view_id: viewId,
category_id: 'cadrans-du-crane',
laterality: 'unpaired',
geometry: null,
name: null,
opens_view_id: opensViewId,
} satisfies Annotation
}
function detailView(id: string, parentId: string) {
return {
id,
kind: 'detail',
name: { fr: id, en: id },
parent_view_id: parentId,
svg_asset_id: HORSE_MAIN_ASSET_ID,
view_box: null,
} satisfies SheetView
}
describe('validateSheetDocument on the horse slice', () => {
it('reports no error and no warning', () => {
expect(validateSheetDocument(horseSlice())).toEqual([])
})
})
describe('integrity rules (one mutation per code)', () => {
it('view.main.count', () => {
const doc = mutated((d) => {
d.views.push({ ...d.views[0], id: 'view-alt' })
})
expect(issuesOf(doc)).toEqual([['view.main.count', 'views']])
})
it('view.main.count with no main view', () => {
const doc = mutated((d) => {
d.views = d.views.filter((view) => view.kind !== 'main')
})
const codes = issuesOf(doc).map(([code]) => code)
expect(codes).toContain('view.main.count')
})
it('view.id.duplicate', () => {
const doc = mutated((d) => {
d.views.push(structuredClone(d.views[1]))
})
expect(issuesOf(doc)).toEqual([['view.id.duplicate', 'views[2].id']])
})
it('view.parent.missing', () => {
const doc = mutated((d) => {
d.views.push(detailView('view-orphan', 'view-ghost'))
})
expect(issuesOf(doc)).toEqual([
['view.parent.missing', 'views[2].parent_view_id'],
])
})
it('view.parent.cycle (terminates on a two-view loop)', () => {
const doc = mutated((d) => {
d.views.push(detailView('view-a', 'view-b'))
d.views.push(detailView('view-b', 'view-a'))
d.annotations.push(trigger('open-a', 'view-b', 'view-a'))
d.annotations.push(trigger('open-b', 'view-a', 'view-b'))
})
expect(issuesOf(doc)).toEqual([
['view.parent.cycle', 'views[2].parent_view_id'],
['view.parent.cycle', 'views[3].parent_view_id'],
])
})
it('view.parent.cycle on a self-parent', () => {
const doc = mutated((d) => {
d.views.push(detailView('view-self', 'view-self'))
d.annotations.push(trigger('open-self', 'view-self', 'view-self'))
})
expect(issuesOf(doc)).toEqual([
['view.parent.cycle', 'views[2].parent_view_id'],
])
})
it('view.unreachable', () => {
const doc = mutated((d) => {
d.annotations = d.annotations.filter((a) => a.id !== 'head-trigger')
})
expect(issuesOf(doc)).toEqual([['view.unreachable', 'views[1]']])
})
it('view.asset.missing on the main view', () => {
const doc = mutated((d) => {
d.views[0].svg_asset_id = null
})
expect(issuesOf(doc)).toEqual([
['view.asset.missing', 'views[0].svg_asset_id'],
])
})
it('view.asset.missing on a detail view without asset nor view_box', () => {
const doc = mutated((d) => {
d.views[1].view_box = null
})
expect(issuesOf(doc)).toEqual([['view.asset.missing', 'views[1].view_box']])
})
it('annotation.id.duplicate (across views)', () => {
const doc = mutated((d) => {
d.annotations.push({ ...structuredClone(d.annotations[4]) })
d.annotations[6].view_id = 'view-main'
})
expect(issuesOf(doc)).toEqual([
['annotation.id.duplicate', 'annotations[6].id'],
])
})
it('annotation.view.missing', () => {
const doc = mutated((d) => {
d.annotations.push(point('ghost', { view_id: 'view-ghost' }))
})
expect(issuesOf(doc)).toEqual([
['annotation.view.missing', 'annotations[6].view_id'],
])
})
it('annotation.category.missing', () => {
const doc = mutated((d) => {
d.annotations[0].category_id = 'os'
})
expect(issuesOf(doc)).toEqual([
['annotation.category.missing', 'annotations[0].category_id'],
])
})
it('annotation.opens_view.invalid when the target is not a child', () => {
const doc = mutated((d) => {
d.annotations.push(trigger('loop', 'view-head', 'view-head'))
})
expect(issuesOf(doc)).toEqual([
['annotation.opens_view.invalid', 'annotations[6].opens_view_id'],
])
})
it('annotation.opens_view.invalid when the target is main or absent', () => {
const doc = mutated((d) => {
d.annotations.push(trigger('to-main', 'view-main', 'view-main'))
d.annotations.push(trigger('to-ghost', 'view-main', 'view-ghost'))
})
expect(issuesOf(doc)).toEqual([
['annotation.opens_view.invalid', 'annotations[6].opens_view_id'],
['annotation.opens_view.invalid', 'annotations[7].opens_view_id'],
])
})
it('annotation.finding_zone.missing', () => {
const doc = mutated((d) => {
d.annotations.push(point('stifle', { finding_zone_id: 'stifle' }))
})
expect(issuesOf(doc)).toEqual([
['annotation.finding_zone.missing', 'annotations[6].finding_zone_id'],
])
})
it('annotation.region.missing', () => {
const doc = mutated((d) => {
const cervical = d.annotations[1]
if (cervical.kind === 'detail_trigger') throw new Error('fixture')
cervical.vertebral_region_code = 'Q'
})
expect(issuesOf(doc)).toEqual([
['annotation.region.missing', 'annotations[1].vertebral_region_code'],
])
})
it('annotation.no_findings is a warning', () => {
const doc = mutated((d) => {
d.annotations.push(point('mandible', { finding_zone_id: null }))
})
expect(issuesOf(doc)).toEqual([
['annotation.no_findings', 'annotations[6].finding_zone_id'],
])
expect(validateSheetDocument(doc)[0].severity).toBe('warning')
})
it('region.code.duplicate', () => {
const doc = mutated((d) => {
const regions = d.vertebral_config.regions
regions.push(structuredClone(regions[0]))
})
expect(issuesOf(doc)).toEqual([
['region.code.duplicate', 'vertebral_config.regions[5].code'],
])
})
it('category.id.duplicate', () => {
const doc = mutated((d) => {
d.categories.push(structuredClone(d.categories[0]))
})
expect(issuesOf(doc)).toEqual([
['category.id.duplicate', 'categories[4].id'],
])
})
it('finding_zone.id.duplicate', () => {
const doc = mutated((d) => {
d.finding_zones.push(structuredClone(d.finding_zones[0]))
})
expect(issuesOf(doc)).toEqual([
['finding_zone.id.duplicate', 'finding_zones[5].id'],
])
})
it('finding.id.duplicate among finding categories', () => {
const doc = mutated((d) => {
const categories = d.finding_zones[0].categories
categories.push(structuredClone(categories[0]))
})
expect(issuesOf(doc)).toEqual([
['finding.id.duplicate', 'finding_zones[0].categories[3].id'],
])
})
it('finding.id.duplicate among nested children', () => {
const doc = mutated((d) => {
const articular = d.finding_zones[0].categories[0].children[0]
articular.children.push(structuredClone(articular.children[0]))
})
expect(issuesOf(doc)).toEqual([
[
'finding.id.duplicate',
'finding_zones[0].categories[0].children[0].children[2].id',
],
])
})
it('finding ids may repeat across different sibling arrays', () => {
const doc = mutated((d) => {
const hip = d.finding_zones[0].categories
hip[1].children.push(structuredClone(hip[0].children[0]))
})
expect(issuesOf(doc)).toEqual([])
})
it('finding_zone.unreferenced is a warning', () => {
const doc = mutated((d) => {
d.finding_zones.push({
id: 'stifle',
name: { fr: 'Grasset', en: 'Stifle' },
categories: [],
})
})
expect(issuesOf(doc)).toEqual([
['finding_zone.unreferenced', 'finding_zones[5]'],
])
expect(validateSheetDocument(doc)[0].severity).toBe('warning')
})
})
describe('publication gate', () => {
it('accepts the fixture', () => {
expect(isPublishable(validateSheetDocument(horseSlice()))).toBe(true)
expect(() => assertPublishable(horseSlice())).not.toThrow()
})
it('accepts a document with warnings only', () => {
const doc = mutated((d) => {
d.annotations.push(point('mandible', { finding_zone_id: null }))
})
expect(validateSheetDocument(doc)).toHaveLength(1)
expect(isPublishable(validateSheetDocument(doc))).toBe(true)
expect(() => assertPublishable(doc)).not.toThrow()
})
it('refuses a document with an error, exposing the issues', () => {
const doc = mutated((d) => {
d.views[0].svg_asset_id = null
})
expect(isPublishable(validateSheetDocument(doc))).toBe(false)
let caught: unknown
try {
assertPublishable(doc)
} catch (thrown) {
caught = thrown
}
expect(caught).toBeInstanceOf(SheetValidationError)
const codes = (caught as SheetValidationError).issues.map((i) => i.code)
expect(codes).toEqual(['view.asset.missing'])
})
})
describe('createEmptySheetDocument', () => {
const empty = () =>
createEmptySheetDocument({
species_id: 'equine',
name: { fr: 'Nouvelle fiche', en: 'New sheet' },
})
it('is valid for the shape tier', () => {
expect(AnatomicalSheetDocumentSchema.safeParse(empty()).success).toBe(true)
expect(empty().views).toEqual([
expect.objectContaining({
id: 'view-main',
kind: 'main',
svg_asset_id: null,
view_box: null,
}),
])
})
it('is not publishable: the main view has no asset', () => {
const issues = validateSheetDocument(empty())
expect(issues.map((issue) => issue.code)).toEqual(['view.asset.missing'])
expect(() => assertPublishable(empty())).toThrow(SheetValidationError)
})
})
/** True for a { fr?, en? } label object, the only thing a translator edits. */
function isLabel(value: unknown): value is Record<string, string> {
if (value === null || typeof value !== 'object' || Array.isArray(value)) {
return false
}
const keys = Object.keys(value)
return keys.length > 0 && keys.every((key) => key === 'fr' || key === 'en')
}
/** Rewrites every label with arbitrary strings, leaving all else intact. */
function mapLabels(
value: unknown,
rewrite: (label: Record<string, string>) => unknown,
): unknown {
if (isLabel(value)) return rewrite(value)
if (Array.isArray(value)) return value.map((v) => mapLabels(v, rewrite))
if (value === null || typeof value !== 'object') return value
return Object.fromEntries(
Object.entries(value).map(([k, v]) => [k, mapLabels(v, rewrite)]),
)
}
/** Every id and reference: values of keys named id, *_id or code. */
function collectIds(value: unknown, out: string[] = []): string[] {
if (Array.isArray(value)) value.forEach((v) => collectIds(v, out))
else if (value !== null && typeof value === 'object') {
for (const [key, v] of Object.entries(value)) {
const isRef = key === 'id' || key.endsWith('_id') || key.endsWith('code')
if (isRef && typeof v === 'string') out.push(`${key}=${v}`)
else collectIds(v, out)
}
}
return out
}
describe('ID stability under translation', () => {
it('keeps ids, references and validation output when labels change', () => {
const original = horseSlice()
let counter = 0
const relabeled = AnatomicalSheetDocumentSchema.parse(
mapLabels(original, (label) =>
Object.fromEntries(
Object.keys(label).map((locale) => [locale, `x${counter++}`]),
),
),
)
expect(counter).toBeGreaterThan(50)
expect(JSON.stringify(relabeled)).not.toEqual(JSON.stringify(original))
expect(collectIds(relabeled)).toEqual(collectIds(original))
const strip = () => null
expect(mapLabels(relabeled, strip)).toEqual(mapLabels(original, strip))
expect(validateSheetDocument(relabeled)).toEqual(
validateSheetDocument(original),
)
})
it('keeps validation output identical on a broken document too', () => {
const broken = mutated((d) => {
d.annotations[0].category_id = 'os'
d.views[1].view_box = null
})
const relabeled = mapLabels(broken, () => ({ fr: 'a', en: 'b' }))
expect(validateSheetDocument(relabeled as AnatomicalSheetDocument)).toEqual(
validateSheetDocument(broken),
)
})
})
+443
View File
@@ -0,0 +1,443 @@
import {
AnatomicalSheetDocumentSchema,
type AnatomicalSheetDocument,
type AnatomicalSheetDocumentInput,
type FindingNodeInput,
} from '../../src'
/**
* Reduced equine sheet built from the real assets: labels come from
* apps/app/public/species/equine/{Horse,Horse_head}.svg and from
* apps/app/src/domain/species/equine/pathologies.json. It exercises two
* views (one cropped detail), a trigger, a spine region, a bilateral joint,
* the three finding kinds, a two-level tree, a vet referral and a source.
* It references every finding zone, so it validates with zero issues.
*/
export const HORSE_MAIN_ASSET_ID = '3f6c1b52-8a4e-4d17-9b0c-5e2a7d91c4f8'
function leaf(id: string, fr: string, en: string): FindingNodeInput {
return { id, name: { fr, en } }
}
const ANAMNESIS = {
id: 'anamnesis',
kind: 'anamnesis',
name: {
fr: 'Anamnèse / facteurs rapportés',
en: 'Anamnesis / reported factors',
},
description: {
fr: "Facteurs rapportés par le propriétaire lors de l'anamnèse",
},
} as const
const OBSERVATIONS_NAME = {
fr: 'Observations / motifs de consultation',
en: 'Observations / consultation reasons',
}
const DYSFUNCTIONS_NAME = {
fr: 'Dysfonctions ostéopathiques',
en: 'Osteopathic dysfunctions',
}
const TRAUMA = leaf(
'trauma-direct',
'Traumatisme rapporté (choc, chute)',
'Reported trauma (blow, fall)',
)
const STRESS = leaf(
'stress-context',
'Contexte de stress / changement',
'Stress / change context',
)
const HIP_ZONE = {
id: 'hip',
name: { fr: 'Hanche (coxo-fémorale)', en: 'Hip joint' },
categories: [
{
id: 'hip-dysfunctions',
kind: 'dysfunction',
name: DYSFUNCTIONS_NAME,
children: [
{
id: 'articular',
name: {
fr: 'Restrictions de mobilité articulaire',
en: 'Articular mobility restrictions',
},
children: [
leaf(
'restriction-flexion',
'Restriction en flexion',
'Flexion restriction',
),
leaf(
'restriction-extension',
'Restriction en extension',
'Extension restriction',
),
],
},
],
},
{
id: 'hip-observations',
kind: 'observation',
name: OBSERVATIONS_NAME,
children: [
{
...leaf(
'limb-lameness',
'Boiterie rapportée (membre concerné)',
'Reported lameness (affected limb)',
),
requires_vet_referral: true,
},
],
},
{
...ANAMNESIS,
children: [
{
...TRAUMA,
sources: [
{
type: 'manual',
citation: 'Legacy equine catalog (pathologies.json)',
},
],
},
],
},
],
} satisfies AnatomicalSheetDocumentInput['finding_zones'][number]
const CERVICAL_ZONE = {
id: 'cervical',
name: { fr: 'Vertèbres cervicales', en: 'Cervical Vertebrae' },
categories: [
{
id: 'cervical-dysfunctions',
kind: 'dysfunction',
name: DYSFUNCTIONS_NAME,
children: [
{
id: 'muscular',
name: {
fr: 'Tensions musculaires paravertébrales',
en: 'Paravertebral muscle tensions',
},
children: [
leaf('splenius-tension', 'Tension du splénius', 'Splenius tension'),
],
},
],
},
{
id: 'cervical-observations',
kind: 'observation',
name: OBSERVATIONS_NAME,
children: [
{
...leaf(
'stumbling-proprioceptive',
'Trébuchements / déficit proprioceptif rapporté',
'Reported stumbling / proprioceptive deficit',
),
requires_vet_referral: true,
},
],
},
{ ...ANAMNESIS, children: [TRAUMA] },
],
} satisfies AnatomicalSheetDocumentInput['finding_zones'][number]
const C7_T1_ZONE = {
id: 'c7-t1',
name: {
fr: 'Charnière C7-T1 (cervico-thoracique)',
en: 'C7-T1 (Cervicothoracic)',
},
categories: [
{
id: 'c7-t1-dysfunctions',
kind: 'dysfunction',
name: DYSFUNCTIONS_NAME,
children: [
leaf(
'restriction-rotation',
'Restriction en rotation',
'Rotation restriction',
),
],
},
{
id: 'c7-t1-observations',
kind: 'observation',
name: OBSERVATIONS_NAME,
children: [
leaf(
'base-neck-stiffness',
"Raideur de la base de l'encolure",
'Base-of-neck stiffness',
),
],
},
{ ...ANAMNESIS, children: [STRESS] },
],
} satisfies AnatomicalSheetDocumentInput['finding_zones'][number]
const ATM_ZONE = {
id: 'atm',
name: {
fr: 'Articulation Temporo-Mandibulaire (ATM)',
en: 'Temporomandibular Joint (TMJ)',
},
categories: [
{
id: 'atm-dysfunctions',
kind: 'dysfunction',
name: {
fr: "Dysfonctions ostéopathiques de l'ATM",
en: 'Osteopathic TMJ dysfunctions',
},
children: [
leaf('masseter-tension', 'Tension du masséter', 'Masseter tension'),
],
},
{
id: 'atm-observations',
kind: 'observation',
name: OBSERVATIONS_NAME,
children: [
leaf(
'bit-defense',
'Réactions de défense au mors',
'Defense reactions to bit',
),
],
},
{
...ANAMNESIS,
children: [
leaf(
'dental-context',
'Suite de soin dentaire récent',
'Post recent dental care',
),
],
},
],
} satisfies AnatomicalSheetDocumentInput['finding_zones'][number]
const SPHENOID_ZONE = {
id: 'sphenoid',
name: { fr: 'Sphénoïde', en: 'Sphenoid' },
categories: [
{
id: 'ssb-dysfunctions',
kind: 'dysfunction',
name: DYSFUNCTIONS_NAME,
children: [
{
id: 'physiological',
name: {
fr: 'Lésions physiologiques (SSB)',
en: 'Physiological lesions (SBS)',
},
children: [
leaf('torsion-right', 'Torsion droite', 'Right torsion'),
leaf('torsion-left', 'Torsion gauche', 'Left torsion'),
],
},
],
},
{
id: 'sphenoid-observations',
kind: 'observation',
name: OBSERVATIONS_NAME,
children: [
leaf(
'post-trauma-head',
'Suite de traumatisme crânien',
'Post head trauma',
),
],
},
{ ...ANAMNESIS, children: [TRAUMA, STRESS] },
],
} satisfies AnatomicalSheetDocumentInput['finding_zones'][number]
const HORSE_SLICE_INPUT: AnatomicalSheetDocumentInput = {
schema_version: 1,
species_id: 'equine',
name: { fr: 'Cheval (extrait)', en: 'Horse (slice)' },
description: {
fr: 'Extrait de la fiche équine pour les tests du modèle',
en: 'Equine sheet slice for model tests',
},
scope_disclaimer: {
fr:
"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.',
},
attribution: { authors: ['Faunosteo'], license: 'MIT', notes: null },
vertebral_config: {
regions: [
{ code: 'C', name: { fr: 'Cervicales', en: 'Cervical' }, count: 7 },
{ code: 'T', name: { fr: 'Thoraciques', en: 'Thoracic' }, count: 18 },
{ code: 'L', name: { fr: 'Lombaires', en: 'Lumbar' }, count: 6 },
{ code: 'S', name: { fr: 'Sacrées', en: 'Sacral' }, count: 5 },
{ code: 'Cd', name: { fr: 'Caudales', en: 'Caudal' }, count: 18 },
],
},
categories: [
{
id: 'articulations',
name: { fr: 'Articulations', en: 'Joints' },
color: '#ff9500',
},
{
id: 'zone-colonne',
name: { fr: 'Zone colonne', en: 'Spine zone' },
color: '#e100ff',
},
{
id: 'charnieres-vertebrales',
name: { fr: 'Charnières vertébrales', en: 'Vertebral junctions' },
color: '#ff0000',
},
{
id: 'cadrans-du-crane',
name: { fr: 'Cadrans du crâne', en: 'Skull quadrants' },
color: '#1baa08',
},
],
views: [
{
id: 'view-main',
kind: 'main',
name: { fr: 'Cheval entier', en: 'Whole horse' },
svg_asset_id: HORSE_MAIN_ASSET_ID,
view_box: null,
},
{
id: 'view-head',
kind: 'detail',
name: { fr: 'Tête', en: 'Head' },
parent_view_id: 'view-main',
svg_asset_id: null,
view_box: { min_x: 60, min_y: 100, width: 500, height: 380 },
},
],
annotations: [
{
id: 'hip',
kind: 'point',
view_id: 'view-main',
category_id: 'articulations',
laterality: 'bilateral',
geometry: { type: 'circle', cx: 1516, cy: 695, r: 34 },
name: { fr: 'Hanche (coxo-fémorale)', en: 'Hip joint' },
finding_zone_id: 'hip',
vertebral_region_code: null,
},
{
id: 'cervical-vertebrae',
kind: 'zone',
view_id: 'view-main',
category_id: 'zone-colonne',
laterality: 'unpaired',
geometry: {
type: 'polygon',
points: [
[468, 276],
[489, 216],
[558, 248],
[586, 339],
[552, 461],
[524, 370],
],
},
name: { fr: 'Vertèbres cervicales', en: 'Cervical Vertebrae' },
finding_zone_id: 'cervical',
vertebral_region_code: 'C',
},
{
id: 'hinge-c7-t1',
kind: 'point',
view_id: 'view-main',
category_id: 'charnieres-vertebrales',
laterality: 'unpaired',
geometry: { type: 'circle', cx: 840.17, cy: 399.08, r: 30 },
name: {
fr: 'Charnière C7-T1 (cervico-thoracique)',
en: 'C7-T1 (Cervicothoracic)',
},
finding_zone_id: 'c7-t1',
vertebral_region_code: null,
},
{
id: 'head-trigger',
kind: 'detail_trigger',
view_id: 'view-main',
category_id: 'cadrans-du-crane',
laterality: 'unpaired',
geometry: {
type: 'polygon',
points: [
[454, 332],
[429, 202],
[349, 154],
[234, 279],
[164, 384],
[234, 468],
],
},
name: null,
opens_view_id: 'view-head',
},
{
id: 'atm',
kind: 'point',
view_id: 'view-head',
category_id: 'articulations',
laterality: 'bilateral',
geometry: { type: 'circle', cx: 384.94, cy: 314.02, r: 27 },
name: {
fr: 'Articulation Temporo-Mandibulaire (ATM)',
en: 'Temporomandibular Joint (TMJ)',
},
finding_zone_id: 'atm',
vertebral_region_code: null,
},
{
id: 'sphenoid',
kind: 'point',
view_id: 'view-head',
category_id: 'cadrans-du-crane',
laterality: 'unpaired',
geometry: { type: 'circle', cx: 299, cy: 298, r: 27 },
name: { fr: 'Sphénoïde', en: 'Sphenoid' },
finding_zone_id: 'sphenoid',
vertebral_region_code: null,
},
],
finding_zones: [HIP_ZONE, CERVICAL_ZONE, C7_T1_ZONE, ATM_ZONE, SPHENOID_ZONE],
}
/** Lean authoring form, as a creator or the importer would write it. */
export function horseSliceInput(): AnatomicalSheetDocumentInput {
return structuredClone(HORSE_SLICE_INPUT)
}
/** Parsed (total) document; a fresh copy so tests can mutate it freely. */
export function horseSlice(): AnatomicalSheetDocument {
return AnatomicalSheetDocumentSchema.parse(horseSliceInput())
}
+21
View File
@@ -0,0 +1,21 @@
{
"compilerOptions": {
"target": "ES2022",
"lib": ["ES2022"],
"module": "ESNext",
"moduleResolution": "bundler",
"strict": true,
"noUnusedLocals": true,
"noUnusedParameters": true,
"noFallthroughCasesInSwitch": true,
"noImplicitReturns": true,
"skipLibCheck": true,
"esModuleInterop": true,
"resolveJsonModule": true,
"isolatedModules": true,
"types": ["node", "vitest/globals"],
"noEmit": true
},
"include": ["src", "tests"],
"exclude": ["node_modules"]
}
+9
View File
@@ -0,0 +1,9 @@
import { defineConfig } from 'vitest/config'
export default defineConfig({
test: {
environment: 'node',
globals: true,
include: ['tests/**/*.test.ts'],
},
})
+28
View File
@@ -97,8 +97,36 @@ importers:
specifier: ^3.2.7
version: 3.2.7(@types/node@20.19.41)(happy-dom@20.10.6)(jiti@2.7.0)(lightningcss@1.32.0)
packages/domain:
dependencies:
zod:
specifier: ^3.24.1
version: 3.25.76
devDependencies:
'@types/node':
specifier: ^20.19.41
version: 20.19.41
eslint:
specifier: ^9.17.0
version: 9.39.4(jiti@2.7.0)
globals:
specifier: ^15.14.0
version: 15.15.0
typescript:
specifier: ^5.7.2
version: 5.9.3
typescript-eslint:
specifier: ^8.19.0
version: 8.59.3(eslint@9.39.4(jiti@2.7.0))(typescript@5.9.3)
vitest:
specifier: ^3.2.7
version: 3.2.7(@types/node@20.19.41)(happy-dom@20.10.6)(jiti@2.7.0)(lightningcss@1.32.0)
packages/supabase:
dependencies:
'@faunosteo/domain':
specifier: workspace:*
version: link:../domain
'@supabase/supabase-js':
specifier: ^2.100.0
version: 2.117.3