test(tests): R4.1c text, AFM, dates and PNG oracles (O4, O5, O6)

This commit is contained in:
bchanot committed 2026-10-18 05:37:18 +02:00
1 parent 96df15edae
commit 516342beca
111 files changed
+73567

No files matched your search

+121
View File
@@ -0,0 +1,121 @@
import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
import { dirname, resolve } from 'node:path'
import { expect } from 'vitest'
import { REPO_ROOT } from './draft'
/**
* Shared plumbing of the R4.1 freeze generators (plan 2026-10-17 §B.5.1,
* O4 to O6). `MAKE_R4_ORACLES=1` writes the files; without it the
* generator recomputes and compares with the committed ones.
*/
export const R4_ORACLES = resolve(REPO_ROOT, 'crates/core/tests/oracles/r4')
export const MAKE_R4 = process.env.MAKE_R4_ORACLES === '1'
/** Where the oracle was computed; informative, left out of the comparison. */
export interface OracleEnvironment {
node: string
v8: string
icu: string | null
unicode: string | null
}
export function environment(): OracleEnvironment {
return {
node: process.version,
v8: process.versions.v8,
icu: process.versions.icu ?? null,
unicode: process.versions.unicode ?? null,
}
}
/** B.5.2: no generator writes while the field corpus is reachable. */
function assertNoFieldCorpus(): void {
if (process.env.FAUNOSTEO_FIELD_CORPUS) {
throw new Error(
'FAUNOSTEO_FIELD_CORPUS is set: R4 oracle generators refuse to write',
)
}
}
export function writeOracleFile(
path: string,
bytes: string | Uint8Array,
): void {
assertNoFieldCorpus()
mkdirSync(dirname(path), { recursive: true })
writeFileSync(path, bytes)
}
/** The JSON value as the file holds it: `-0` becomes `0`, `undefined` fields vanish. */
const asJson = (value: unknown): unknown => JSON.parse(JSON.stringify(value))
/**
* Writes `value` as `JSON.stringify(value, null, 2)` (MAKE), or asserts
* deep equality with the committed file, `environment` excepted.
*/
export function freezeJson(
name: string,
value: { environment: OracleEnvironment },
): void {
const path = resolve(R4_ORACLES, name)
if (MAKE_R4) {
writeOracleFile(path, `${JSON.stringify(value, null, 2)}\n`)
return
}
const expected = JSON.parse(readFileSync(path, 'utf8')) as Record<
string,
unknown
>
const computed = asJson(value) as Record<string, unknown>
delete expected.environment
delete computed.environment
expect(computed).toEqual(expected)
}
/** A number as JavaScript prints it, `-0` kept apart from `0`. */
export const jsNumber = (value: number): string =>
Object.is(value, -0) ? '-0' : String(value)
/** mulberry32: a small seeded PRNG, [0, 1). */
export function mulberry32(seed: number): () => number {
let state = seed >>> 0
return () => {
state = (state + 0x6d2b79f5) >>> 0
let t = state
t = Math.imul(t ^ (t >>> 15), t | 1)
t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
return ((t ^ (t >>> 14)) >>> 0) / 4294967296
}
}
export const MAX_CODE_POINT = 0x10ffff
/** Every code point from 0 to 0x10FFFF run-length encoded as `[start, end, class]` (end inclusive). */
export function classRanges<T extends string>(
classOf: (cp: number) => T,
): Array<[number, number, T]> {
const out: Array<[number, number, T]> = []
for (let cp = 0; cp <= MAX_CODE_POINT; cp += 1) {
const cls = classOf(cp)
const last = out.at(-1)
if (last && last[2] === cls && last[1] === cp - 1) last[1] = cp
else out.push([cp, cp, cls])
}
return out
}
/** The code points where `test` holds, as `[start, end]` ranges (end inclusive). */
export function codePointRanges(
test: (cp: number) => boolean,
): Array<[number, number]> {
return classRanges((cp) => (test(cp) ? 'in' : 'out'))
.filter(([, , cls]) => cls === 'in')
.map(([start, end]) => [start, end])
}
export const isSurrogate = (cp: number): boolean => cp >= 0xd800 && cp <= 0xdfff
/** A one-code-point string; a surrogate stays a lone single-unit string. */
export const charOf = (cp: number): string =>
isSurrogate(cp) ? String.fromCharCode(cp) : String.fromCodePoint(cp)
@@ -0,0 +1,95 @@
/**
* R4.1 freeze O5 (plan 2026-10-17 §B.5.1): `formatDate` (render/dates.ts)
* as the TypeScript engine prints it with Node's ICU, for fr and en, over a
* grid of `YYYY-MM-DD` inputs (years 0000 to 9999 with the `Date.UTC`
* 0-99 → 1900-1999 mapping, months 00 to 13, days 00 to 32, so rolled-over
* dates come back unchanged) and strings the pattern refuses.
* `MAKE_R4_ORACLES=1` writes `crates/core/tests/oracles/r4/dates.json`.
*/
import { describe, it } from 'vitest'
import { formatDate } from '../src/render/dates'
import { environment, freezeJson } from './helpers/r4-oracle-io'
const YEARS = [
'0000',
'0001',
'0050',
'0099',
'0100',
'0999',
'1000',
'1900',
'1904',
'1999',
'2000',
'2024',
'2026',
'9999',
]
const pad2 = (n: number): string => String(n).padStart(2, '0')
const MONTHS = Array.from({ length: 14 }, (_, i) => pad2(i))
const DAYS = Array.from({ length: 33 }, (_, i) => pad2(i))
/** Inputs `^\d{4}-\d{2}-\d{2}$` refuses (printed unchanged), plus near misses it accepts. */
const OTHER_INPUTS = [
'2026-1-5',
'26-01-05',
'',
'2026-01-05T00:00',
' 2026-01-05',
'2026-01-05 ',
'2026 -01-05',
'\u00a02026-01-05',
'2026-01-05',
'+2026-01-05',
'-2026-01-05',
'+002026-01-05',
'2026/01/05',
'2026-01-05\n',
'\n2026-01-05',
'20260105',
'2026-001-05',
'abcd-ef-gh',
'١٢٣٤-٠١-٠٥',
'2026-01-05Z',
'10000-01-05',
'0000-00-00',
]
function buildGrid() {
const results: Record<string, { fr: string[]; en: string[] }> = {}
for (const year of YEARS) {
for (const month of MONTHS) {
const inputs = DAYS.map((day) => `${year}-${month}-${day}`)
results[`${year}-${month}`] = {
fr: inputs.map((input) => formatDate(input, 'fr')),
en: inputs.map((input) => formatDate(input, 'en')),
}
}
}
return results
}
function buildDates() {
return {
comment: [
'formatDate(input, locale) (packages/pdf/src/render/dates.ts), Intl.DateTimeFormat fr-FR and',
'en-US, day numeric, month long, year numeric, UTC. grid.results["YYYY-MM"].fr[d] is the',
'output for input "YYYY-MM-" + days[d] (d = 0..32); an output equal to its input means the',
'date was refused (rolled over or out of range). others: [input, fr, en].',
],
environment: environment(),
grid: { years: YEARS, months: MONTHS, days: DAYS, results: buildGrid() },
others: OTHER_INPUTS.map((input) => [
input,
formatDate(input, 'fr'),
formatDate(input, 'en'),
]),
}
}
describe('R4 date oracles (TypeScript freeze)', () => {
it('matches the frozen formatDate outputs', () => {
freezeJson('dates.json', buildDates())
})
})
File diff suppressed because it is too large. Load diff
+875
View File
@@ -0,0 +1,875 @@
/**
* R4.1 freeze O4 (plan 2026-10-17 §B.5.1): the text and number rules the
* Rust writer reproduces, computed with the TypeScript engine and pdf-lib
* 1.17.1. `afm.json`: the metrics and the WinAnsi table pdf-lib measures
* with (`@pdf-lib/standard-fonts`). `text.json`: `measure` over a corpus ×
* the three fonts × eight sizes, `wrapLines`, `safeText` over every code
* point, `toUpperCase`, JS `\s` and `trim`, `Math.round`, pdf-lib's
* `numberToString` and `rasterSizeOf`. `MAKE_R4_ORACLES=1` writes
* `crates/core/tests/oracles/r4/{afm,text}.json`.
*/
import { readFileSync } from 'node:fs'
import { resolve } from 'node:path'
import { beforeAll, describe, expect, it } from 'vitest'
import { Encodings, Font, FontNames } from '@pdf-lib/standard-fonts'
import {
numberToString,
PageSizes,
PDFDocument,
StandardFontEmbedder,
type PDFFont,
} from 'pdf-lib'
import type { Observation } from '@faunosteo/domain'
import { defaultPdfLabels } from '../src'
import { embedFonts } from '../src/render/fonts'
import { measure, wrapLines } from '../src/render/text'
import { rasterSizeOf, renderHighlightedView } from '../src/svg/view'
import { safeText } from '../src/text'
import { DRAFT_DIR, loadDraftSheet } from './helpers/draft'
import {
charOf,
classRanges,
codePointRanges,
environment,
freezeJson,
isSurrogate,
jsNumber,
MAX_CODE_POINT,
mulberry32,
} from './helpers/r4-oracle-io'
import {
loadGoldenReports,
REPORT_NAMES,
type GoldenReports,
} from './helpers/reports'
/** The fonts `embedFonts` embeds, in its order: bodyRegular, bodyBold, headingRegular. */
const FONT_NAMES = [
FontNames.Helvetica,
FontNames.HelveticaBold,
FontNames.TimesRoman,
]
const SIZES = [8, 9, 10, 11, 14, 22, 9.5, 13.333333333333334]
const SEED = 0x52344f34
const RANDOM_WINANSI = 500
const RANDOM_UNICODE = 200
let fonts: PDFFont[]
let golden: GoldenReports
beforeAll(async () => {
const embedded = await embedFonts(await PDFDocument.create())
fonts = [embedded.bodyRegular, embedded.bodyBold, embedded.headingRegular]
golden = loadGoldenReports()
})
// ---------------------------------------------------------------------------
// afm.json
/**
* StandardFontEmbedder of pdf-lib 1.17.1 (es build; the cjs build vitest loads
* differs only by the `utils_1.` prefix), quoted for the port.
*/
const EMBEDDER_SOURCE = [
'StandardFontEmbedder.prototype.widthOfTextAtSize = function (text, size) {',
' var glyphs = this.encodeTextAsGlyphs(text);',
' var totalWidth = 0;',
' for (var idx = 0, len = glyphs.length; idx < len; idx++) {',
' var left = glyphs[idx].name;',
' var right = (glyphs[idx + 1] || {}).name;',
' var kernAmount = this.font.getXAxisKerningForPair(left, right) || 0;',
' totalWidth += this.widthOfGlyph(left) + kernAmount;',
' }',
' var scale = size / 1000;',
' return totalWidth * scale;',
'};',
'StandardFontEmbedder.prototype.widthOfGlyph = function (glyphName) {',
" // Default to 250 if font doesn't specify a width",
' return this.font.getWidthOfGlyph(glyphName) || 250;',
'};',
'StandardFontEmbedder.prototype.encodeTextAsGlyphs = function (text) {',
' var codePoints = Array.from(text);',
' var glyphs = new Array(codePoints.length);',
' for (var idx = 0, len = codePoints.length; idx < len; idx++) {',
' var codePoint = toCodePoint(codePoints[idx]);',
' glyphs[idx] = this.encoding.encodeUnicodeCodePoint(codePoint);',
' }',
' return glyphs;',
'};',
]
/** @pdf-lib/standard-fonts 1.0.0 Font.js, the two lookups the embedder calls. */
const FONT_SOURCE = [
'this.getWidthOfGlyph = function (glyphName) {',
' return _this.CharWidths[glyphName];',
'};',
'this.getXAxisKerningForPair = function (leftGlyphName, rightGlyphName) {',
' return (_this.KernPairXAmounts[leftGlyphName] || {})[rightGlyphName];',
'};',
'// CharWidths: CharMetrics reduced name -> WX; KernPairXAmounts: KernPairs reduced',
'// left -> right -> amount (a later duplicate would win; the three fonts have none).',
]
const normalised = (code: string): string =>
code.replace(/\b\w+_\d+\./g, '').replace(/\s+/g, ' ')
/** Every quoted body line, whitespace-normalised, is in the installed code. */
function assertQuoted(quote: string[], installed: string): void {
const code = normalised(installed)
for (const line of quote.filter(
(l) => l.startsWith(' ') && !l.includes('//'),
)) {
expect(code, line).toContain(normalised(line.trim()))
}
}
function assertQuoteMatchesInstalled(): void {
const proto = StandardFontEmbedder.prototype as unknown as Record<
string,
() => void
>
const methods = ['widthOfTextAtSize', 'widthOfGlyph', 'encodeTextAsGlyphs']
assertQuoted(
EMBEDDER_SOURCE,
methods.map((name) => proto[name]!.toString()).join('\n'),
)
const font = Font.load(FontNames.Helvetica)
const lookups = [font.getWidthOfGlyph, font.getXAxisKerningForPair]
assertQuoted(FONT_SOURCE, lookups.map((fn) => fn.toString()).join('\n'))
}
type WinAnsiRow = [number, number, string]
/** `Encodings.WinAnsi`: code point → [byte code, glyph name], code point order. */
function winAnsiTable(): WinAnsiRow[] {
const encoding = Encodings.WinAnsi
return encoding.supportedCodePoints.map((cp) => {
const { code, name } = encoding.encodeUnicodeCodePoint(cp)
return [cp, code, name]
})
}
function fontMetrics(fontName: FontNames, table: WinAnsiRow[]) {
const font = Font.load(fontName)
const glyphs: Record<string, [number, number[]]> = {}
for (const { N, WX } of font.CharMetrics) {
const codes = table
.filter(([, , name]) => name === N)
.map(([, code]) => code)
glyphs[N] = [WX, [...new Set(codes)].sort((a, b) => a - b)]
}
const kerning: Record<string, Record<string, number>> = {}
for (const [left, right, amount] of font.KernPairs) {
kerning[left] = { ...kerning[left], [right]: amount }
}
/** The AFM header fields: every own value that is neither a table nor a method. */
const scalars = Object.fromEntries(
Object.entries(font).filter(
([, value]) => typeof value !== 'function' && typeof value !== 'object',
),
)
return {
...scalars,
FontBBox: font.FontBBox,
charMetricsCount: font.CharMetrics.length,
kernPairsCount: font.KernPairs.length,
winAnsiGlyphsWithoutWidth: [
...new Set(table.map(([, , name]) => name)),
].filter((name) => font.getWidthOfGlyph(name) === undefined),
glyphs,
kerning,
}
}
function buildAfm() {
assertQuoteMatchesInstalled()
const table = winAnsiTable()
return {
comment: [
'O4 metrics: what pdf-lib 1.17.1 measures with (@pdf-lib/standard-fonts 1.0.0, Font.load).',
'glyphs: name -> [WX, WinAnsi byte codes that print this glyph]; no AFM C field is kept by',
'the package. kerning: left -> right -> KPX amount, every pair of the font. winAnsi: code',
'point -> [byte code, glyph name] for every code point Encodings.WinAnsi can encode (note',
'376 U+0178 -> [159, "ydieresis"], 160 -> "space", 173 -> "hyphen", as pdf-lib has them).',
'Width of a string: sum over its glyphs of (WX || 250) + (KPX(left, next) || 0), times',
'size / 1000 (measuredWith below). The fonts carry no APAFML notice in this package:',
'Notice/Comment are the AFM header fields as pdf-lib stores them.',
],
measuredWith: [...EMBEDDER_SOURCE, ...FONT_SOURCE],
environment: environment(),
fonts: Object.fromEntries(
FONT_NAMES.map((name) => [name, fontMetrics(name, table)]),
),
winAnsi: table,
}
}
// ---------------------------------------------------------------------------
// text.json: measure
/** Every `{ fr, en }` label found under a `name` key of the draft document. */
function sheetNames(): string[] {
const out: string[] = []
const walk = (value: unknown, key: string): void => {
if (Array.isArray(value)) return value.forEach((item) => walk(item, key))
if (!value || typeof value !== 'object') return
const record = value as Record<string, unknown>
if (
key === 'name' &&
typeof record.fr === 'string' &&
typeof record.en === 'string'
) {
out.push(record.fr, record.en)
return
}
for (const [k, v] of Object.entries(record)) walk(v, k)
}
walk(loadDraftSheet().document, '')
return out
}
function stringLeaves(value: unknown): string[] {
if (typeof value === 'string') return [value]
if (Array.isArray(value)) return value.flatMap(stringLeaves)
if (value && typeof value === 'object')
return Object.values(value).flatMap(stringLeaves)
return []
}
const pdfLabelTexts = (): string[] => [
...Object.values(defaultPdfLabels.fr),
...Object.values(defaultPdfLabels.en),
]
function randomText(
rng: () => number,
alphabet: number[],
maxLength: number,
): string {
const length = 1 + Math.floor(rng() * maxLength)
return Array.from({ length }, () =>
String.fromCodePoint(alphabet[Math.floor(rng() * alphabet.length)]!),
).join('')
}
/** A scalar value (never a surrogate) from one of four bands: ASCII, 2-byte, BMP, astral. */
function randomScalar(rng: () => number): number {
const bands: Array<[number, number]> = [
[0, 0x7f],
[0x80, 0x7ff],
[0x800, 0xffff],
[0x10000, MAX_CODE_POINT],
]
const [low, high] = bands[Math.floor(rng() * bands.length)]!
for (;;) {
const cp = low + Math.floor(rng() * (high - low + 1))
if (!isSurrogate(cp)) return cp
}
}
function randomUnicodeText(rng: () => number): string {
const length = 1 + Math.floor(rng() * 16)
return Array.from({ length }, () =>
String.fromCodePoint(randomScalar(rng)),
).join('')
}
interface CorpusGroups {
sheetNames: string[]
pdfLabels: string[]
reports: string[]
randomWinAnsi: string[]
randomUnicode: string[]
}
/** Each fixed text and its upper-case form; a text already seen in an earlier group is not repeated. */
function corpus(): CorpusGroups {
const seen = new Set<string>()
const fresh = (texts: string[]) =>
texts.filter((text) => !seen.has(text) && seen.add(text))
const withUpper = (texts: string[]) =>
fresh(texts.flatMap((text) => [text, text.toUpperCase()]))
const rng = mulberry32(SEED)
const winAnsi = Encodings.WinAnsi.supportedCodePoints
return {
sheetNames: withUpper(sheetNames()),
pdfLabels: withUpper(pdfLabelTexts()),
reports: withUpper(
REPORT_NAMES.flatMap((name) => stringLeaves(golden.reports[name])),
),
randomWinAnsi: Array.from({ length: RANDOM_WINANSI }, () =>
randomText(rng, winAnsi, 40),
),
randomUnicode: Array.from({ length: RANDOM_UNICODE }, () =>
randomUnicodeText(rng),
),
}
}
/** The width rule of StandardFontEmbedder, as the Rust port must write it. */
const WIDTH_FORMULA = 'units * (size / 1000)'
const SAMPLE_HEAD = 100
const SAMPLE_DRAWN = 100
const SAMPLE_SEED = SEED + 2
/** Flat row indices that keep their widths: the first 100, then 100 distinct others drawn by the PRNG. */
function widthSample(total: number): number[] {
const rng = mulberry32(SAMPLE_SEED)
const head = Math.min(SAMPLE_HEAD, total)
const picked = new Set(Array.from({ length: head }, (_, i) => i))
const target = Math.min(total, SAMPLE_HEAD + SAMPLE_DRAWN)
while (picked.size < target) {
picked.add(SAMPLE_HEAD + Math.floor(rng() * (total - SAMPLE_HEAD)))
}
return [...picked].sort((a, b) => a - b)
}
interface MeasureRow {
text: string
safe: string
units: number[]
widths?: number[][]
}
/**
* One text: its safeText form and the raw unit sum per font (size 1000).
* Every font × size is checked against the formula; the widths are kept
* for sampled rows only.
*/
function measureRow(text: string, keepWidths: boolean): MeasureRow {
const safe = safeText(text)
const units = fonts.map((font) => font.widthOfTextAtSize(safe, 1000))
const widths = fonts.map((font, f) =>
SIZES.map((size) => {
const width = measure(font, text, size)
expect(width).toBe(units[f]! * (size / 1000))
expect(width).toBe(font.widthOfTextAtSize(safe, size))
return width
}),
)
return keepWidths ? { text, safe, units, widths } : { text, safe, units }
}
function measureGroups(groups: CorpusGroups, sample: Set<number>) {
const rows: Record<string, MeasureRow[]> = {}
let offset = 0
for (const [name, texts] of Object.entries(groups) as Array<
[string, string[]]
>) {
rows[name] = texts.map((text, i) =>
measureRow(text, sample.has(offset + i)),
)
offset += texts.length
}
return rows
}
function buildMeasure() {
const groups = corpus()
const total = Object.values(groups).reduce((n, texts) => n + texts.length, 0)
const sample = widthSample(total)
return {
comment: [
'measure(font, text, size) = font.widthOfTextAtSize(safeText(text), size) (render/text.ts).',
'units[f] = widthOfTextAtSize(safe, 1000): the raw sum of glyph widths and kerning for',
'fonts[f]. The generator asserts, for every row, font and size, measure === widthFormula',
'evaluated in JavaScript (f64, this exact expression and order); widths[f][s] (sizes[s]) is',
'kept only on the widthSample rows. Fixed groups hold each text and its toUpperCase(); a',
'text is listed once, in the first group that has it. Random groups use mulberry32(seed):',
'randomWinAnsi draws 1-40 code points of Encodings.WinAnsi, randomUnicode 1-16 scalar',
'values from four bands (ASCII, 2-byte, rest of the BMP, astral), no surrogate.',
],
fonts: fonts.map((font) => font.name),
sizes: SIZES,
widthFormula: WIDTH_FORMULA,
seed: SEED,
counts: Object.fromEntries(
Object.entries(groups).map(([k, v]) => [k, (v as string[]).length]),
),
widthSample: {
rule: [
'Rows indexed in file order across the groups (sheetNames, pdfLabels, reports,',
`randomWinAnsi, randomUnicode), from 0. Kept: indices 0..${SAMPLE_HEAD - 1}, then`,
`${SAMPLE_DRAWN} distinct indices drawn as ${SAMPLE_HEAD} + floor(rng() * (total - ${SAMPLE_HEAD}))`,
'with rng = mulberry32(seed), a repeat drawn again; listed ascending.',
],
seed: SAMPLE_SEED,
total,
indices: sample,
},
groups: measureGroups(groups, new Set(sample)),
}
}
// ---------------------------------------------------------------------------
// text.json: wrapLines
/** `width - MARGIN_X * 2` on A4, the only maxWidth the observation and conclusion pages pass. */
const LAYOUT_MAX_WIDTH = PageSizes.A4[0] - 36 * 2
const WRAP_WIDTHS = [LAYOUT_MAX_WIDTH, 0, 1, 50, 100, 200, 300, 1000]
/** wrapLines is only called with bodyRegular: size 10 (observation sections), 11 (conclusion). */
const WRAP_SIZES = [10, 11]
function reportLongTexts(): string[] {
return REPORT_NAMES.flatMap((name) => {
const report = golden.reports[name]
const next = report.nextAppointment
return [
report.conclusion,
report.recommendations,
next && next.kind === 'period' ? next.text : '',
...report.observations.flatMap((o) => [
o.comment,
o.comment.trim(),
...o.freeTextFindings,
]),
...report.observations.map((o) => o.freeTextFindings.join(' · ')),
]
})
}
function edgeWrapTexts(): string[] {
const document = loadDraftSheet().document
const vocabulary = sheetNames()
.filter((_, i) => i % 2 === 0)
.slice(0, 60)
return [
document.scope_disclaimer.fr ?? '',
document.scope_disclaimer.en ?? '',
vocabulary.join(' '),
'',
' ',
'\t\n',
' leading and trailing ',
'a\u00a0b\u2028c\ufeffd\u3000e\u1680f\u205fg',
'word\u200bjoined by a zero width space',
'x\u0007y z',
'\u0007 \u0007 word \u0007',
'Supercalifragilisticexpialidocious'.repeat(3),
'short Supercalifragilisticexpialidociouscalifragilistic tail',
'emoji 😀 and CJK 漢字 and ☃ and → arrows',
'Œuvre « guillemets » – tiret — long … points € ‰ ™',
]
}
function buildWrap() {
const seen = new Set<string>()
const texts = [
...reportLongTexts(),
...pdfLabelTexts(),
...edgeWrapTexts(),
].filter((text) => !seen.has(text) && seen.add(text))
const font = fonts[0]!
return {
comment: [
'wrapLines(text, font, size, maxWidth) (render/text.ts): split on JS /\\s+/, safeText per',
'word, greedy join with one space. lines[s][w] for sizes[s] and maxWidths[w]; maxWidths[0]',
'is the layout value A4 width - 36 * 2 as JavaScript computes it.',
],
font: font.name,
sizes: WRAP_SIZES,
maxWidths: WRAP_WIDTHS,
cases: texts.map((text) => ({
text,
lines: WRAP_SIZES.map((size) =>
WRAP_WIDTHS.map((max) => wrapLines(text, font, size, max)),
),
})),
}
}
// ---------------------------------------------------------------------------
// text.json: code point tables
type SafeClass = 'kept' | 'dropped' | 'question'
function safeClassOf(cp: number): SafeClass {
const char = charOf(cp)
const out = safeText(char)
if (out === char) return 'kept'
if (out === '') return 'dropped'
if (out === '?') return 'question'
throw new Error(`safeText(${cp}) gave ${JSON.stringify(out)}`)
}
type UpperRun = [number, number, number, number]
/** Single-code-point mappings as runs [start, end, step, delta]: start, start + step, … end map to cp + delta. */
function upperRuns(single: Array<[number, number]>): UpperRun[] {
const runs: UpperRun[] = []
for (const [cp, mapped] of single) {
const delta = mapped - cp
const last = runs.at(-1)
const step = last ? cp - last[1] : 0
const joins =
last &&
last[3] === delta &&
(last[0] === last[1] ? step <= 2 : step === last[2])
if (last && joins) {
last[2] = step
last[1] = cp
} else runs.push([cp, cp, 1, delta])
}
return runs
}
function expandRuns(runs: UpperRun[]): Array<[number, number]> {
return runs.flatMap(([start, end, step, delta]) => {
const out: Array<[number, number]> = []
for (let cp = start; cp <= end; cp += step) out.push([cp, cp + delta])
return out
})
}
function buildUpper() {
const single: Array<[number, number]> = []
const special: Array<[number, number[]]> = []
for (let cp = 0; cp <= MAX_CODE_POINT; cp += 1) {
if (isSurrogate(cp)) continue
const char = String.fromCodePoint(cp)
const upper = char.toUpperCase()
if (upper === char) continue
const mapped = Array.from(upper, (c) => c.codePointAt(0)!)
if (mapped.length === 1) single.push([cp, mapped[0]!])
else special.push([cp, mapped])
}
const runs = upperRuns(single)
expect(expandRuns(runs)).toEqual(single)
return {
comment: [
'String.fromCodePoint(cp).toUpperCase() for every non-surrogate code point where it differs.',
'runs: [start, end, step, delta]: start, start + step, ... end each map to cp + delta (one',
'code point). special: [cp, result code points] when the result is not one code point.',
'Any other code point maps to itself.',
],
singleCount: single.length,
runs,
special,
}
}
const isJsWhitespace = (cp: number): boolean =>
!isSurrogate(cp) && /\s/.test(String.fromCodePoint(cp))
const isJsTrimmed = (cp: number): boolean =>
!isSurrogate(cp) && `${String.fromCodePoint(cp)}a`.trim() === 'a'
// ---------------------------------------------------------------------------
// text.json: numbers
const HALF_TIES = [
0.5, -0.5, 1.5, -1.5, 2.5, -2.5, 3.5, -3.5, 4.5, 99.5, 1199.5, 2399.5,
]
const ROUND_EDGES = [
0.49999999999999994,
-0.49999999999999994,
0.5000000000000001,
1.4999999999999998,
2 ** 52 + 0.5,
2 ** 52 - 0.5,
-(2 ** 52) + 0.5,
2 ** 53,
2 ** 53 + 2,
1e21,
1.7976931348623157e308,
5e-324,
-5e-324,
1e-300,
0,
-0,
0.4,
-0.4,
0.6,
-0.6,
100.49999999999999,
Infinity,
-Infinity,
NaN,
1200 * 0.2,
1200 * 0.6,
1200 * 1.2345,
1200 * (943 / 1200),
1200 * (942.5 / 1200),
]
function mathRoundInputs(rng: () => number): number[] {
const random = Array.from({ length: 50 }, () => (rng() - 0.5) * 6000)
const halves = Array.from(
{ length: 50 },
() => Math.floor((rng() - 0.5) * 2e6) + 0.5,
)
const raster = Array.from({ length: 30 }, () => 1200 * (0.2 + rng() * 1.8))
return [...HALF_TIES, ...ROUND_EDGES, ...random, ...halves, ...raster]
}
const LAYOUT_SUMS = [
36 + 523.28 / 2,
595.28 - 36,
841.89 - 95,
841.89 - 122,
841.89 - 122 - 12,
(595.28 - 72 - 16) / 2,
(595.28 - 72 - 16) / 2 / 2,
595.28 - 36 - 50.5,
800 - 12 * 3,
(14 - 10) * 0.3,
1 - 0.9,
0.1 + 0.2,
0.1 * 3,
523.28 * 0.6,
253.64 * 0.7876,
841.89 - 48,
36 + 253.64 + 16,
595.28 / 2 - 50,
]
const COLOUR_COMPONENTS = [
0.12, 0.11, 0.09, 0.42, 0.39, 0.35, 0.72, 0.25, 0.55, 0.65, 0.45, 0.85, 0.18,
0.78, 0.2,
]
const INTEGERS = [
0,
1,
2,
36,
72,
595,
842,
1000,
2 ** 31,
2 ** 32,
2 ** 53,
1e15,
1e20,
123456789,
-1,
-842,
]
const TINY_RESIDUES = [
0.1 + 0.2 - 0.3,
1.0000000000001 - 1,
3 * 0.1 - 0.3,
523.28 - 523.2799999999999,
1e-13,
1.5e-13,
9.999999999999999e-14,
0.30000000000000004 - 0.3,
0.000001,
0.0000009999999,
5e-324,
1e-300,
2.2250738585072014e-308,
-1e-7,
-1.5e-13,
-(0.1 + 0.2 - 0.3),
]
const LARGE = [
1e21,
1.5e21,
9.999999999999999e21,
1e22,
1.2345678901234567e25,
2 ** 70,
2 ** 100,
1e100,
1.7976931348623157e308,
-1e21,
-3.3e25,
999999999999999900000,
1e21 - 65536,
]
const SPECIAL_NUMBERS = [NaN, Infinity, -Infinity, -0]
function numberInputs(rng: () => number): number[] {
const n = (count: number, make: () => number) =>
Array.from({ length: count }, make)
const widths = fonts.map((font) =>
measure(font, 'Restriction en flexion', 10),
)
return [
...n(300, () => rng() * 842),
...n(150, () => rng()),
...n(50, () => -rng() * 842),
...n(50, () => -rng()),
...INTEGERS,
...LAYOUT_SUMS,
...COLOUR_COMPONENTS,
...widths.flatMap((w) => [595.28 - 36 - w, (595.28 - w) / 2, w + 10]),
...n(14, () => 0).map((_, i) => 10 ** -(i + 7)),
...n(28, () => (1 + rng() * 9) * 10 ** -(7 + Math.floor(rng() * 14))),
...TINY_RESIDUES,
...LARGE,
...n(20, () => (1 + rng() * 9) * 10 ** (21 + Math.floor(rng() * 280))),
...SPECIAL_NUMBERS,
]
}
function buildNumbers() {
const rng = mulberry32(SEED + 1)
return {
mathRound: {
comment:
'Math.round(input): [input, output] as JavaScript prints them, "-0" kept, NaN/Infinity by name.',
seed: SEED + 1,
cases: mathRoundInputs(rng).map((x) => [
jsNumber(x),
jsNumber(Math.round(x)),
]),
},
numberToString: {
comment: [
'pdf-lib 1.17.1 numberToString (utils/numbers.js, as loaded), the operand printer of every',
'content stream operator and PDFNumber: [String(input) ("-0" for -0), output]. Source below.',
],
source: numberToString.toString().split('\n'),
seed: SEED + 1,
cases: numberInputs(rng).map((x) => [jsNumber(x), numberToString(x)]),
},
}
}
// ---------------------------------------------------------------------------
// text.json: rasterSizeOf
const VIEW_BOXES: Array<string | null> = [
null,
'',
'0 0 100 50',
'0 0 1200 943',
'0,0,100,50',
'0, 0, 100, 50',
' 0 0 100 50 ',
'\t0\n0\r100\u00a050\ufeff',
'0\u20280\u3000100\u205f50',
'0 0 0x10 0x20',
'0 0 Infinity 50',
'0 0 100 Infinity',
'0 0 -Infinity 50',
'0 0 NaN 50',
'0 0 -100 50',
'0 0 100 -50',
'0 0 0 50',
'0 0 100 0',
'0 0 -0 50',
'0 0 100',
'0 0',
'0',
'0 0 100 50 7',
'0 0 100 1000',
'0 0 1000 1',
'0 0 1e2 5e1',
'0 0 1E2 5E1',
'0 0 1e999 50',
'0 0 100 1e-400',
'0 0 5e-324 1',
'0 0 .5 .25',
'0 0 5. 2.',
'0 0 +100 +50',
'0 0 0b11 0o7',
'0 0 1_000 500',
'0 0 100px 50px',
',0 0 100 50',
'0 0 100 50,',
'0 0 100,,50',
'a b c d',
'-50 -50 100 50',
'0 0 100 50.5',
'0 0 1200 942.5',
'0 0 3 2',
'0 0 7 3',
'0 0 2400 1885',
'0 0 100 20',
'0 0 100 200',
'0 0 100 19.999',
'0 0 100 200.001',
'0 0 1 0.6000000000000001',
'0 0 100 0x',
'0 0 ١٠٠ ٥٠',
'0 0 100 50',
]
const VIEW_BOX_ATTRIBUTE = /<svg\b[^>]*\sviewBox="([^"]*)"/
/** The viewBox of every drawing the draft sheet bundles, as its asset text declares it. */
function draftViewBoxes(): string[] {
const assets = JSON.parse(
readFileSync(resolve(DRAFT_DIR, 'assets.json'), 'utf8'),
) as Array<{ file: string }>
return assets.flatMap(({ file }) => {
const match = VIEW_BOX_ATTRIBUTE.exec(
readFileSync(resolve(DRAFT_DIR, 'assets', file), 'utf8'),
)
return match ? [match[1]!] : []
})
}
/** The viewBox `rasterSizeOf` reads for each view of the draft: the composed root's, view framing applied. */
function composedViewBoxes(): string[] {
const sheet = golden.snapshots.demo
const none = {
id: 'none',
zones: [],
findings: [],
freeTextFindings: [],
comment: '',
} as unknown as Observation
return sheet.document.views.map((view) => {
const { svg } = renderHighlightedView(sheet, view.id, none)
return VIEW_BOX_ATTRIBUTE.exec(svg)?.[1] ?? ''
})
}
function buildRasterSizes() {
return {
comment: [
'rasterSizeOf(viewBox) (svg/view.ts): [input (null = attribute absent), widthPx, heightPx].',
'The last rows are the draft drawing viewBoxes, then the composed view roots (main, head).',
],
cases: [...VIEW_BOXES, ...draftViewBoxes(), ...composedViewBoxes()].map(
(viewBox) => {
const { widthPx, heightPx } = rasterSizeOf(viewBox)
return [viewBox, widthPx, heightPx]
},
),
}
}
function buildText() {
return {
comment: [
'O4 text and numbers, frozen from the TypeScript engine (packages/pdf) and pdf-lib 1.17.1.',
'Code point tables depend on the V8 / ICU / Unicode versions in environment.',
],
environment: environment(),
measure: buildMeasure(),
wrapLines: buildWrap(),
safeText: {
comment: [
'safeText(one code point) over 0..0x10FFFF, surrogates as lone single-unit strings:',
'[start, end, class]; kept = unchanged, dropped = removed (\\p{Cc}, \\p{Cf}, \\p{Zl}, \\p{Zp}),',
'question = replaced by "?" (not WinAnsi-encodable). Ranges are contiguous and cover all.',
],
ranges: classRanges(safeClassOf),
},
upper: buildUpper(),
jsWhitespace: {
comment:
'Code points JS /\\s/ matches (non-surrogates), [start, end] ranges.',
ranges: codePointRanges(isJsWhitespace),
},
jsTrim: {
comment:
'Code points String.prototype.trim removes (non-surrogates), [start, end] ranges.',
ranges: codePointRanges(isJsTrimmed),
},
...buildNumbers(),
rasterSizeOf: buildRasterSizes(),
}
}
describe('R4 text oracles (TypeScript freeze)', () => {
it('matches the frozen AFM metrics and WinAnsi table', () => {
freezeJson('afm.json', buildAfm())
})
it('matches the frozen text and number rules', () => {
freezeJson('text.json', buildText())
}, 120_000)
})