feat(pdf): @faunosteo/pdf engine — explicit inputs, envelope v1 attachment, layered reader, xmldom composition, allowlist SVG sanitiser, WinAnsi guard, rasterizer adapter; goldens reproduced
This commit is contained in:
1 parent
e7419cb4cb
commit
c17956031d
46 files changed
+4396
-1
No files matched your search
@@ -0,0 +1,90 @@
|
||||
import { readFileSync } from 'node:fs'
|
||||
import { fileURLToPath } from 'node:url'
|
||||
import { join, resolve } from 'node:path'
|
||||
import {
|
||||
AnatomicalSheetDocumentSchema,
|
||||
ReportMigrationMapSchema,
|
||||
type ReportMigrationMap,
|
||||
type SnapshotSource,
|
||||
} from '@faunosteo/domain'
|
||||
|
||||
/**
|
||||
* Paths and loaders shared by the engine tests. The committed equine draft
|
||||
* is read from the seed as the application bundles it; the Phase 0 goldens
|
||||
* and fixtures are read from the app's test folder, never copied.
|
||||
*/
|
||||
|
||||
const HERE = resolve(fileURLToPath(import.meta.url), '..')
|
||||
export const REPO_ROOT = resolve(HERE, '../../../..')
|
||||
export const DRAFT_DIR = resolve(
|
||||
REPO_ROOT,
|
||||
'supabase/seed/anatomical-sheets/equine/draft',
|
||||
)
|
||||
export const LEGACY_BASELINE = resolve(
|
||||
REPO_ROOT,
|
||||
'supabase/seed/anatomical-sheets/equine/legacy-import/document.json',
|
||||
)
|
||||
export const FIXTURES_DIR = resolve(REPO_ROOT, 'apps/app/tests/fixtures')
|
||||
export const GOLDEN_DIR = resolve(FIXTURES_DIR, 'goldens/step6')
|
||||
export const PUBLIC_DIR = resolve(REPO_ROOT, 'apps/app/public')
|
||||
|
||||
export function readJson<T = unknown>(path: string): T {
|
||||
return JSON.parse(readFileSync(path, 'utf8')) as T
|
||||
}
|
||||
|
||||
export function readFixtureJson<T = unknown>(name: string): T {
|
||||
return readJson<T>(resolve(FIXTURES_DIR, name))
|
||||
}
|
||||
|
||||
export function readFixtureBytes(name: string): Uint8Array {
|
||||
return new Uint8Array(readFileSync(resolve(FIXTURES_DIR, name)))
|
||||
}
|
||||
|
||||
interface SeedRef {
|
||||
sheet_id: string
|
||||
version_id: string | null
|
||||
document_sha256: string
|
||||
schema_version: number
|
||||
species_id: string
|
||||
}
|
||||
|
||||
interface SeedAsset {
|
||||
file: string
|
||||
sha256: string
|
||||
svg_asset_id: string
|
||||
}
|
||||
|
||||
export interface DraftSheet extends SnapshotSource {
|
||||
assetHashes: Readonly<Record<string, string>>
|
||||
migrationMap: ReportMigrationMap
|
||||
}
|
||||
|
||||
export function loadDraftSheet(): DraftSheet {
|
||||
const json = <T>(name: string) => readJson<T>(join(DRAFT_DIR, name))
|
||||
const ref = json<SeedRef>('sheet-ref.json')
|
||||
const assets: Record<string, string> = {}
|
||||
const assetHashes: Record<string, string> = {}
|
||||
for (const asset of json<SeedAsset[]>('assets.json')) {
|
||||
assets[asset.svg_asset_id] = readFileSync(
|
||||
join(DRAFT_DIR, 'assets', asset.file),
|
||||
'utf8',
|
||||
)
|
||||
assetHashes[asset.svg_asset_id] = asset.sha256
|
||||
}
|
||||
return {
|
||||
status: 'draft',
|
||||
ref: {
|
||||
sheetId: ref.sheet_id,
|
||||
versionId: ref.version_id,
|
||||
documentSha256: ref.document_sha256,
|
||||
},
|
||||
speciesId: ref.species_id,
|
||||
schemaVersion: ref.schema_version,
|
||||
document: AnatomicalSheetDocumentSchema.parse(json('document.json')),
|
||||
assets,
|
||||
assetHashes,
|
||||
migrationMap: ReportMigrationMapSchema.parse(
|
||||
json('report-migration-map.json'),
|
||||
),
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,359 @@
|
||||
import { readFileSync } from 'node:fs'
|
||||
import { resolve } from 'node:path'
|
||||
import { DOMParser, type Element, type Node } from '@xmldom/xmldom'
|
||||
import { expect, vi } from 'vitest'
|
||||
import {
|
||||
PDFArray,
|
||||
PDFDict,
|
||||
PDFDocument,
|
||||
PDFHexString,
|
||||
PDFName,
|
||||
PDFNumber,
|
||||
PDFPage,
|
||||
PDFString,
|
||||
} from 'pdf-lib'
|
||||
import type {
|
||||
Branding,
|
||||
Observation,
|
||||
Report,
|
||||
SheetSnapshot,
|
||||
} from '@faunosteo/domain'
|
||||
import { composeHighlightedViewSvg, type Rasterizer } from '../../src'
|
||||
import { GOLDEN_DIR, PUBLIC_DIR } from './draft'
|
||||
|
||||
/**
|
||||
* Step 6 Phase 0 goldens, replayed on the engine: the same recorder on
|
||||
* pdf-lib, the same link reader, the same view facts (computed with xmldom
|
||||
* instead of the browser DOM) and the same fixed PNG rasters.
|
||||
*/
|
||||
|
||||
export const FIXED_EXPORTED_AT = new Date('2026-10-11T12:00:00.000Z')
|
||||
|
||||
/** 1×1 PNG (nologos: the legacy stub) and 2×1 PNG (logos: deterministic partner logo width). */
|
||||
export const ONE_PX_PNG = Uint8Array.from(
|
||||
Buffer.from(
|
||||
'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==',
|
||||
'base64',
|
||||
),
|
||||
)
|
||||
export const TWO_BY_ONE_PNG = Uint8Array.from(
|
||||
Buffer.from(
|
||||
'iVBORw0KGgoAAAANSUhEUgAAAAIAAAABCAIAAAB7QOjdAAAAD0lEQVR4nGPYEWX///9/AA0PBE/1T7nxAAAAAElFTkSuQmCC',
|
||||
'base64',
|
||||
),
|
||||
)
|
||||
|
||||
/** A rasterizer returning the same PNG whatever the SVG, like the Phase 0 mock. */
|
||||
export function fixedRasterizer(png: Uint8Array): Rasterizer {
|
||||
return async () => png
|
||||
}
|
||||
|
||||
export type LogoMode = 'nologos' | 'logos'
|
||||
|
||||
const SITE_URL = 'https://faunosteo.com'
|
||||
const POWERED_BY = {
|
||||
url: 'https://zenquality.fr',
|
||||
fallbackText: 'zenquality.fr',
|
||||
}
|
||||
const PARTNER = {
|
||||
url: 'https://www.instagram.com/paws.iin.harmony',
|
||||
fallbackText: '@paws.iin.harmony',
|
||||
}
|
||||
|
||||
function publicPng(relative: string): { kind: 'png'; base64: string } {
|
||||
const bytes = readFileSync(resolve(PUBLIC_DIR, relative))
|
||||
return { kind: 'png', base64: Buffer.from(bytes).toString('base64') }
|
||||
}
|
||||
|
||||
/** Every logo null, credits with their fallback texts (fetch 404 in Phase 0). */
|
||||
export function nologosBranding(): Branding {
|
||||
return {
|
||||
siteUrl: SITE_URL,
|
||||
headerLogo: null,
|
||||
footerLogo: null,
|
||||
poweredBy: { logo: null, ...POWERED_BY },
|
||||
partner: { logo: null, ...PARTNER },
|
||||
}
|
||||
}
|
||||
|
||||
/** The four real `public/` files (Phase 0 fetch stub). */
|
||||
export function logosBranding(): Branding {
|
||||
return {
|
||||
siteUrl: SITE_URL,
|
||||
headerLogo: publicPng('assets/faunosteo_logo_horizontal-512.png'),
|
||||
footerLogo: publicPng('assets/faunosteo-horizontal-com-512.png'),
|
||||
poweredBy: {
|
||||
logo: publicPng('brand/zenquality-logo-fr.png'),
|
||||
...POWERED_BY,
|
||||
},
|
||||
partner: {
|
||||
logo: {
|
||||
kind: 'svg',
|
||||
svg: readFileSync(resolve(PUBLIC_DIR, 'Paws_in_harmony.svg'), 'utf8'),
|
||||
},
|
||||
...PARTNER,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
export function brandingOf(mode: LogoMode): Branding {
|
||||
return mode === 'logos' ? logosBranding() : nologosBranding()
|
||||
}
|
||||
|
||||
export function rasterizerOf(mode: LogoMode): Rasterizer {
|
||||
return fixedRasterizer(mode === 'logos' ? TWO_BY_ONE_PNG : ONE_PX_PNG)
|
||||
}
|
||||
|
||||
export interface TextEntry {
|
||||
page: number
|
||||
text: string
|
||||
x: number | null
|
||||
y: number | null
|
||||
size: number | null
|
||||
font: string | null
|
||||
}
|
||||
|
||||
export interface ImageEntry {
|
||||
page: number
|
||||
x: number | null
|
||||
y: number | null
|
||||
width: number | null
|
||||
height: number | null
|
||||
}
|
||||
|
||||
export interface LinkEntry {
|
||||
page: number
|
||||
rect: number[]
|
||||
uri: string
|
||||
}
|
||||
|
||||
export function round2(value: unknown): number | null {
|
||||
return typeof value === 'number' ? Math.round(value * 100) / 100 : null
|
||||
}
|
||||
|
||||
/** Pages are appended in order and never moved: the index at draw time is final. */
|
||||
function pageIndex(page: PDFPage): number {
|
||||
return page.doc.getPages().indexOf(page)
|
||||
}
|
||||
|
||||
export interface DrawRecording {
|
||||
texts: TextEntry[]
|
||||
images: ImageEntry[]
|
||||
stop(): void
|
||||
}
|
||||
|
||||
/** Records every drawText / drawImage while letting pdf-lib draw for real. */
|
||||
export function recordDrawing(): DrawRecording {
|
||||
const texts: TextEntry[] = []
|
||||
const images: ImageEntry[] = []
|
||||
const drawText = PDFPage.prototype.drawText
|
||||
const drawImage = PDFPage.prototype.drawImage
|
||||
const textSpy = vi
|
||||
.spyOn(PDFPage.prototype, 'drawText')
|
||||
.mockImplementation(function (this: PDFPage, text, options) {
|
||||
texts.push({
|
||||
page: pageIndex(this),
|
||||
text,
|
||||
x: round2(options?.x),
|
||||
y: round2(options?.y),
|
||||
size: round2(options?.size),
|
||||
font: options?.font?.name ?? null,
|
||||
})
|
||||
return drawText.call(this, text, options)
|
||||
})
|
||||
const imageSpy = vi
|
||||
.spyOn(PDFPage.prototype, 'drawImage')
|
||||
.mockImplementation(function (this: PDFPage, image, options) {
|
||||
images.push({
|
||||
page: pageIndex(this),
|
||||
x: round2(options?.x),
|
||||
y: round2(options?.y),
|
||||
width: round2(options?.width),
|
||||
height: round2(options?.height),
|
||||
})
|
||||
return drawImage.call(this, image, options)
|
||||
})
|
||||
return {
|
||||
texts,
|
||||
images,
|
||||
stop: () => {
|
||||
textSpy.mockRestore()
|
||||
imageSpy.mockRestore()
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
function linkOf(dict: PDFDict, page: number): LinkEntry | null {
|
||||
if (dict.get(PDFName.of('Subtype')) !== PDFName.of('Link')) return null
|
||||
const rect = dict
|
||||
.lookup(PDFName.of('Rect'), PDFArray)
|
||||
.asArray()
|
||||
.map((n) => round2((n as PDFNumber).asNumber()) ?? 0)
|
||||
const uri = dict.lookup(PDFName.of('A'), PDFDict).lookup(PDFName.of('URI'))
|
||||
const text =
|
||||
uri instanceof PDFString || uri instanceof PDFHexString
|
||||
? uri.decodeText()
|
||||
: String(uri)
|
||||
return { page, rect, uri: text }
|
||||
}
|
||||
|
||||
/** Every `/Annot /Link` of the saved PDF, page by page, in annotation order. */
|
||||
export async function readLinks(bytes: Uint8Array): Promise<LinkEntry[]> {
|
||||
const doc = await PDFDocument.load(bytes)
|
||||
const out: LinkEntry[] = []
|
||||
doc.getPages().forEach((page, index) => {
|
||||
const annots = page.node.Annots()
|
||||
if (!annots) return
|
||||
for (let i = 0; i < annots.size(); i += 1) {
|
||||
const link = linkOf(annots.lookup(i, PDFDict), index)
|
||||
if (link) out.push(link)
|
||||
}
|
||||
})
|
||||
return out
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// View facts (G2), computed with xmldom on the engine's SVG
|
||||
|
||||
export const HIGHLIGHT_FILL = '#b85a3f'
|
||||
|
||||
export interface HighlightedElement {
|
||||
tag: string
|
||||
cx: string | null
|
||||
cy: string | null
|
||||
r: string | null
|
||||
points: string | null
|
||||
d: string | null
|
||||
fill: string | null
|
||||
fillOpacity: string | null
|
||||
filter: string | null
|
||||
}
|
||||
|
||||
export interface ViewSnapshot {
|
||||
observationId: string
|
||||
viewId: string
|
||||
viewBox: string | null
|
||||
halo: boolean
|
||||
highlighted: HighlightedElement[]
|
||||
nonHighlightedVisible: number
|
||||
dataAttributes: number
|
||||
titles: number
|
||||
}
|
||||
|
||||
function isElement(node: Node): node is Element {
|
||||
return node.nodeType === 1
|
||||
}
|
||||
|
||||
/** Every element under `root` (root included), document order. */
|
||||
export function allElements(root: Element): Element[] {
|
||||
const out: Element[] = []
|
||||
const stack: Element[] = [root]
|
||||
while (stack.length) {
|
||||
const el = stack.pop()!
|
||||
out.push(el)
|
||||
const children = Array.from(el.childNodes).filter(isElement)
|
||||
for (let i = children.length - 1; i >= 0; i -= 1) stack.push(children[i]!)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
export function elementChildren(el: Element): Element[] {
|
||||
return Array.from(el.childNodes).filter(isElement)
|
||||
}
|
||||
|
||||
function highlightedOf(el: Element): HighlightedElement {
|
||||
const attr = (name: string) => el.getAttribute(name)
|
||||
return {
|
||||
tag: el.tagName,
|
||||
cx: attr('cx'),
|
||||
cy: attr('cy'),
|
||||
r: attr('r'),
|
||||
points: attr('points'),
|
||||
d: attr('d'),
|
||||
fill: attr('fill'),
|
||||
fillOpacity: attr('fill-opacity'),
|
||||
filter: attr('filter'),
|
||||
}
|
||||
}
|
||||
|
||||
/** Children of the annotation layer (last `<g>` of the root) still visible and not highlighted. */
|
||||
function countVisibleNonHighlighted(root: Element): number {
|
||||
const layer = elementChildren(root)
|
||||
.filter((c) => c.tagName === 'g')
|
||||
.at(-1)
|
||||
if (!layer) return 0
|
||||
return elementChildren(layer).filter(
|
||||
(el) =>
|
||||
el.getAttribute('fill') !== HIGHLIGHT_FILL &&
|
||||
el.getAttribute('display') !== 'none',
|
||||
).length
|
||||
}
|
||||
|
||||
function countDataAttributes(root: Element): number {
|
||||
return allElements(root).reduce(
|
||||
(count, el) =>
|
||||
count +
|
||||
Array.from(el.attributes).filter((a) => a.name.startsWith('data-'))
|
||||
.length,
|
||||
0,
|
||||
)
|
||||
}
|
||||
|
||||
export function parseXml(svg: string): Element {
|
||||
return new DOMParser().parseFromString(svg, 'image/svg+xml').documentElement!
|
||||
}
|
||||
|
||||
export function snapshotView(
|
||||
sheet: SheetSnapshot,
|
||||
observation: Observation,
|
||||
viewId: string,
|
||||
): ViewSnapshot {
|
||||
const root = parseXml(composeHighlightedViewSvg(sheet, viewId, observation))
|
||||
const elements = allElements(root)
|
||||
return {
|
||||
observationId: observation.id,
|
||||
viewId,
|
||||
viewBox: root.getAttribute('viewBox'),
|
||||
halo: elements.some(
|
||||
(el) => el.tagName === 'filter' && el.getAttribute('id') === 'osteo-halo',
|
||||
),
|
||||
highlighted: elements
|
||||
.filter((el) => el.getAttribute('fill') === HIGHLIGHT_FILL)
|
||||
.map(highlightedOf),
|
||||
nonHighlightedVisible: countVisibleNonHighlighted(root),
|
||||
dataAttributes: countDataAttributes(root),
|
||||
titles: elements.filter((el) => el.tagName === 'title').length,
|
||||
}
|
||||
}
|
||||
|
||||
/** The views an observation draws, in the pipeline's order: main first, then first appearance. */
|
||||
export function viewIdsOf(
|
||||
sheet: SheetSnapshot,
|
||||
observation: Observation,
|
||||
): string[] {
|
||||
const views = new Set(sheet.document.views.map((v) => v.id))
|
||||
const main = sheet.document.views.find((v) => v.kind === 'main')!.id
|
||||
return [...new Set(observation.zones.map((z) => z.viewId))]
|
||||
.filter((id) => views.has(id))
|
||||
.sort((a, b) => Number(b === main) - Number(a === main))
|
||||
}
|
||||
|
||||
export function snapshotViews(
|
||||
sheet: SheetSnapshot,
|
||||
report: Report,
|
||||
): ViewSnapshot[] {
|
||||
return report.observations.flatMap((observation) =>
|
||||
viewIdsOf(sheet, observation).map((viewId) =>
|
||||
snapshotView(sheet, observation, viewId),
|
||||
),
|
||||
)
|
||||
}
|
||||
|
||||
export function readGolden<T = unknown>(name: string): T {
|
||||
return JSON.parse(readFileSync(resolve(GOLDEN_DIR, name), 'utf8')) as T
|
||||
}
|
||||
|
||||
/** Asserts deep equality with a Phase 0 golden (never regenerated here). */
|
||||
export function checkGolden(name: string, actual: unknown): void {
|
||||
expect(actual, name).toEqual(readGolden(name))
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
import {
|
||||
AnatomicalSheetDocumentSchema,
|
||||
ReportV2Schema,
|
||||
type AnatomicalSheetDocument,
|
||||
type FindingCategory,
|
||||
type FindingNode,
|
||||
type ObservationV2,
|
||||
type ReportV2,
|
||||
} from '@faunosteo/domain'
|
||||
import { LEGACY_BASELINE, readJson } from './draft'
|
||||
|
||||
/**
|
||||
* The legacy catalog as the application's archive knew it: every leaf of the
|
||||
* generated baseline becomes a Report v2 finding, one observation per zone.
|
||||
* Same recipe as the app and domain helpers (Phase 0 `v2unresolved`).
|
||||
*/
|
||||
|
||||
export interface LegacyLeaf {
|
||||
zoneId: string
|
||||
path: string[]
|
||||
name: { fr: string; en: string }
|
||||
vet: boolean
|
||||
}
|
||||
|
||||
export function loadLegacyBaseline(): AnatomicalSheetDocument {
|
||||
return AnatomicalSheetDocumentSchema.parse(readJson(LEGACY_BASELINE))
|
||||
}
|
||||
|
||||
export function legacyLeaves(doc: AnatomicalSheetDocument): LegacyLeaf[] {
|
||||
const out: LegacyLeaf[] = []
|
||||
const walk = (
|
||||
zoneId: string,
|
||||
nodes: readonly (FindingCategory | FindingNode)[],
|
||||
prefix: string[],
|
||||
) => {
|
||||
for (const node of nodes) {
|
||||
const path = [...prefix, node.id]
|
||||
if (node.children.length > 0) walk(zoneId, node.children, path)
|
||||
else {
|
||||
const vet =
|
||||
'requires_vet_referral' in node && node.requires_vet_referral
|
||||
out.push({ zoneId, path, name: node.name, vet })
|
||||
}
|
||||
}
|
||||
}
|
||||
for (const zone of doc.finding_zones) walk(zone.id, zone.categories, [])
|
||||
return out
|
||||
}
|
||||
|
||||
export function leavesAsV2Report(leaves: LegacyLeaf[]): ReportV2 {
|
||||
const byZone = new Map<string, ObservationV2>()
|
||||
for (const leaf of leaves) {
|
||||
let obs = byZone.get(leaf.zoneId)
|
||||
if (!obs) {
|
||||
obs = {
|
||||
id: `obs-${leaf.zoneId}`,
|
||||
zones: [],
|
||||
findings: [],
|
||||
freeTextFindings: [],
|
||||
comment: '',
|
||||
}
|
||||
byZone.set(leaf.zoneId, obs)
|
||||
}
|
||||
obs.findings.push({
|
||||
zoneId: leaf.zoneId,
|
||||
path: leaf.path,
|
||||
labelFrSnapshot: leaf.name.fr,
|
||||
labelEnSnapshot: leaf.name.en || leaf.name.fr,
|
||||
...(leaf.vet ? { requiresVetReferral: true } : {}),
|
||||
})
|
||||
}
|
||||
return ReportV2Schema.parse({
|
||||
version: 2,
|
||||
id: 'all-leaves',
|
||||
createdAt: '2026-10-10T00:00:00Z',
|
||||
date: '2026-10-10',
|
||||
practitioner: { name: 'Synthetic' },
|
||||
animal: { speciesId: 'equine', name: 'Synthetic' },
|
||||
owner: { name: 'Synthetic' },
|
||||
observations: [...byZone.values()],
|
||||
conclusion: '',
|
||||
recommendations: '',
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
import { AFRelationship, PDFDocument, PDFName, PDFRawStream } from 'pdf-lib'
|
||||
|
||||
/** Crafted PDFs for the read tests, built with pdf-lib's own attach. */
|
||||
export async function pdfWithAttachment(
|
||||
name: string,
|
||||
payload: unknown,
|
||||
extra: { keywords?: string[]; before?: [string, unknown] } = {},
|
||||
): Promise<Uint8Array> {
|
||||
const doc = await PDFDocument.create()
|
||||
doc.addPage()
|
||||
if (extra.keywords) doc.setKeywords(extra.keywords)
|
||||
if (extra.before) await attachJson(doc, extra.before[0], extra.before[1])
|
||||
await attachJson(doc, name, payload)
|
||||
return doc.save()
|
||||
}
|
||||
|
||||
async function attachJson(
|
||||
doc: PDFDocument,
|
||||
name: string,
|
||||
payload: unknown,
|
||||
): Promise<void> {
|
||||
await doc.attach(new TextEncoder().encode(JSON.stringify(payload)), name, {
|
||||
mimeType: 'application/json',
|
||||
afRelationship: AFRelationship.Data,
|
||||
})
|
||||
}
|
||||
|
||||
export async function pdfWithoutAttachment(
|
||||
keywords?: string[],
|
||||
): Promise<Uint8Array> {
|
||||
const doc = await PDFDocument.create()
|
||||
doc.addPage()
|
||||
if (keywords) doc.setKeywords(keywords)
|
||||
return doc.save()
|
||||
}
|
||||
|
||||
/** Stored (Flate) size of the first `/EmbeddedFile` stream of a saved PDF. */
|
||||
export async function storedAttachmentSize(bytes: Uint8Array): Promise<number> {
|
||||
const doc = await PDFDocument.load(bytes)
|
||||
for (const [, object] of doc.context.enumerateIndirectObjects()) {
|
||||
if (!(object instanceof PDFRawStream)) continue
|
||||
const type = object.dict.lookup(PDFName.of('Type'))
|
||||
if (type === PDFName.of('EmbeddedFile')) return object.contents.length
|
||||
}
|
||||
throw new Error('no EmbeddedFile stream')
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
import {
|
||||
buildSheetSnapshot,
|
||||
readReportDocument,
|
||||
ReportSchema,
|
||||
type Report,
|
||||
type SheetSnapshot,
|
||||
} from '@faunosteo/domain'
|
||||
import { loadDraftSheet, readFixtureJson, type DraftSheet } from './draft'
|
||||
import {
|
||||
leavesAsV2Report,
|
||||
legacyLeaves,
|
||||
loadLegacyBaseline,
|
||||
} from './legacy-leaves'
|
||||
|
||||
/** The three Phase 0 reports, built with the Phase 0 recipe. */
|
||||
export const REPORT_NAMES = ['v2full', 'demo', 'v2unresolved'] as const
|
||||
export type ReportName = (typeof REPORT_NAMES)[number]
|
||||
|
||||
export interface GoldenReports {
|
||||
draft: DraftSheet
|
||||
reports: Record<ReportName, Report>
|
||||
snapshots: Record<ReportName, SheetSnapshot>
|
||||
/** Unresolved findings of `v2unresolved` as the migration counted them. */
|
||||
unresolvedOfV2Unresolved: number
|
||||
}
|
||||
|
||||
/** sphenoid + ssb (the families the migration cannot place) plus one leaf that resolves. */
|
||||
function buildV2Unresolved(draft: DraftSheet) {
|
||||
const leaves = legacyLeaves(loadLegacyBaseline())
|
||||
const unresolvedFamilies = leaves.filter(
|
||||
(l) => l.zoneId === 'sphenoid' || l.zoneId === 'ssb',
|
||||
)
|
||||
const resolved = leaves.find((l) => l.zoneId === 'frontal')!
|
||||
return readReportDocument(
|
||||
leavesAsV2Report([...unresolvedFamilies, resolved]),
|
||||
draft.migrationMap,
|
||||
)
|
||||
}
|
||||
|
||||
export function loadGoldenReports(): GoldenReports {
|
||||
const draft = loadDraftSheet()
|
||||
const unresolved = buildV2Unresolved(draft)
|
||||
const reports: Record<ReportName, Report> = {
|
||||
v2full: readReportDocument(
|
||||
readFixtureJson('report-v2.full.json'),
|
||||
draft.migrationMap,
|
||||
).report,
|
||||
demo: ReportSchema.parse(readFixtureJson('report-v3.demo.json')),
|
||||
v2unresolved: unresolved.report,
|
||||
}
|
||||
const snapshots = Object.fromEntries(
|
||||
REPORT_NAMES.map((name) => [
|
||||
name,
|
||||
buildSheetSnapshot(draft, reports[name]),
|
||||
]),
|
||||
) as Record<ReportName, SheetSnapshot>
|
||||
return {
|
||||
draft,
|
||||
reports,
|
||||
snapshots,
|
||||
unresolvedOfV2Unresolved: unresolved.unresolvedFindings,
|
||||
}
|
||||
}
|
||||
|
||||
/** The 612-leaf legacy report migrated through the draft map (T5). */
|
||||
export function allLeavesMigrated(draft: DraftSheet) {
|
||||
return readReportDocument(
|
||||
leavesAsV2Report(legacyLeaves(loadLegacyBaseline())),
|
||||
draft.migrationMap,
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,88 @@
|
||||
import { Resvg } from '@resvg/resvg-js'
|
||||
import type { Rasterizer } from '../../src'
|
||||
|
||||
/**
|
||||
* A real Node rasterizer for T10. resvg 0.40 (resvg-js 2.6.2) panics
|
||||
* (`geom.rs:27`, `Option::unwrap() on None`) when gradient-filled elements
|
||||
* are culled by a cropped root `viewBox` such as the head view's
|
||||
* `60 100 500 380` on the equine drawing, aborting the process. The
|
||||
* adapter therefore renders the box covering the whole content at the
|
||||
* same scale and crops the pixels to the requested view: identical output
|
||||
* for a view that already covers its content (main view).
|
||||
*/
|
||||
|
||||
export interface Raster {
|
||||
requested: { widthPx: number; heightPx: number }
|
||||
png: Uint8Array
|
||||
}
|
||||
|
||||
interface Box {
|
||||
x: number
|
||||
y: number
|
||||
width: number
|
||||
height: number
|
||||
}
|
||||
|
||||
const FONT = { loadSystemFonts: false }
|
||||
|
||||
function rootViewBox(svg: string): Box | null {
|
||||
const tag = svg.match(/<svg\b[^>]*>/)?.[0] ?? ''
|
||||
const raw = tag.match(/\sviewBox="([^"]+)"/)?.[1]
|
||||
if (!raw) return null
|
||||
const [x, y, width, height] = raw
|
||||
.trim()
|
||||
.split(/[\s,]+/)
|
||||
.map(Number)
|
||||
if (!(width! > 0) || !(height! > 0)) return null
|
||||
return { x: x!, y: y!, width: width!, height: height! }
|
||||
}
|
||||
|
||||
function withViewBox(svg: string, box: Box): string {
|
||||
const value = `${box.x} ${box.y} ${box.width} ${box.height}`
|
||||
return svg.replace(/(<svg\b[^>]*?\sviewBox=")[^"]+(")/, `$1${value}$2`)
|
||||
}
|
||||
|
||||
function union(a: Box, b: Box): Box {
|
||||
const x = Math.min(a.x, b.x)
|
||||
const y = Math.min(a.y, b.y)
|
||||
return {
|
||||
x,
|
||||
y,
|
||||
width: Math.max(a.x + a.width, b.x + b.width) - x,
|
||||
height: Math.max(a.y + a.height, b.y + b.height) - y,
|
||||
}
|
||||
}
|
||||
|
||||
function contentBox(svg: string): Box | null {
|
||||
const bbox = new Resvg(svg, { font: FONT }).getBBox()
|
||||
if (!bbox || !(bbox.width > 0) || !(bbox.height > 0)) return null
|
||||
return { x: bbox.x, y: bbox.y, width: bbox.width, height: bbox.height }
|
||||
}
|
||||
|
||||
export function resvgRasterizer(record: Raster[] = []): Rasterizer {
|
||||
return async (svg, size) => {
|
||||
const crop = rootViewBox(svg)
|
||||
const content = crop ? contentBox(svg) : null
|
||||
const full = crop && content ? union(crop, content) : crop
|
||||
const scale = crop ? size.widthPx / crop.width : 1
|
||||
const left = Math.round(((crop?.x ?? 0) - (full?.x ?? 0)) * scale)
|
||||
const top = Math.round(((crop?.y ?? 0) - (full?.y ?? 0)) * scale)
|
||||
const resvg = new Resvg(full ? withViewBox(svg, full) : svg, {
|
||||
fitTo: {
|
||||
mode: 'width',
|
||||
value: full ? Math.round(full.width * scale) : size.widthPx,
|
||||
},
|
||||
background: 'white',
|
||||
font: FONT,
|
||||
crop: {
|
||||
left,
|
||||
top,
|
||||
right: left + size.widthPx,
|
||||
bottom: top + size.heightPx,
|
||||
},
|
||||
})
|
||||
const png = new Uint8Array(resvg.render().asPng())
|
||||
record.push({ requested: size, png })
|
||||
return png
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user