import { mkdirSync, readFileSync, writeFileSync } from 'node:fs' import { fileURLToPath } from 'node:url' import { dirname, resolve } from 'node:path' 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/core-wasm/types' import { composeHighlightedViewSvg } from '@faunosteo/pdf' /** The engine's own (Zod-inferred) types of the same JSON contracts. */ type EngineView = Parameters import { nologosBranding } from './sheet' /** * Step 6 Phase 0 freeze: what the PDF pipeline drew before the engine, * recorded as JSON goldens (docs/development/STEP6_PDF_ARCHIVE_ANALYSIS.md * §17) that the app export path must still reproduce. The recorder spies on * pdf-lib, the link reader parses the saved bytes, the view snapshot parses * the engine's highlighted SVG with the browser DOM. Numbers are rounded to * 2 decimals; nothing ordered by drawing order is sorted. */ /** 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', ), ) const HERE = dirname(fileURLToPath(import.meta.url)) export const FIXTURES_DIR = resolve(HERE, '../fixtures') export const GOLDEN_DIR = resolve(FIXTURES_DIR, 'goldens/step6') /** `MAKE_GOLDEN=1` writes the goldens instead of asserting them. */ export const MAKE_GOLDEN = process.env.MAKE_GOLDEN === '1' export type LogoMode = 'nologos' | 'logos' 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 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 } 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 { 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 } /** * The branding of one logo mode, for a test that mocks `@/pdf/branding`: * `logos` is the real module (the bundled files), `nologos` every slot * empty with the credits' fallback texts (the Phase 0 fetch 404). */ export async function brandingOf(mode: LogoMode): Promise { if (mode === 'nologos') return nologosBranding() const real = await vi.importActual('@/pdf/branding') return real.loadBranding() } const HIGHLIGHT_FILL = '#b85a3f' 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 `` of the root) still visible and not highlighted. */ function countVisibleNonHighlighted(root: Element): number { const layer = Array.from(root.children) .filter((c) => c.tagName === 'g') .at(-1) if (!layer) return 0 return Array.from(layer.children).filter( (el) => el.getAttribute('fill') !== HIGHLIGHT_FILL && el.getAttribute('display') !== 'none', ).length } function countDataAttributes(root: Element): number { return [root, ...Array.from(root.querySelectorAll('*'))].reduce( (count, el) => count + Array.from(el.attributes).filter((a) => a.name.startsWith('data-')) .length, 0, ) } export function snapshotView( sheet: SheetSnapshot, observation: Observation, viewId: string, ): ViewSnapshot { const svg = composeHighlightedViewSvg( sheet as EngineView[0], viewId, observation as EngineView[2], ) const root = new DOMParser().parseFromString( svg, 'image/svg+xml', ).documentElement return { observationId: observation.id, viewId, viewBox: root.getAttribute('viewBox'), halo: root.querySelector('filter#osteo-halo') !== null, highlighted: Array.from( root.querySelectorAll(`[fill="${HIGHLIGHT_FILL}"]`), ).map(highlightedOf), nonHighlightedVisible: countVisibleNonHighlighted(root), dataAttributes: countDataAttributes(root), titles: root.getElementsByTagName('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(name: string): T { return JSON.parse(readFileSync(resolve(GOLDEN_DIR, name), 'utf8')) as T } /** Writes the golden under MAKE_GOLDEN, asserts deep equality otherwise. */ export function checkGolden(name: string, actual: unknown): void { if (MAKE_GOLDEN) { mkdirSync(GOLDEN_DIR, { recursive: true }) writeFileSync( resolve(GOLDEN_DIR, name), `${JSON.stringify(actual, null, 2)}\n`, ) return } expect(actual, name).toEqual(readGolden(name)) }