Files
faunosteo/scripts/r4-afm-data.mjs
bchanot 70007e0c93 feat(domain): R4.4 layout to a draw log: text rules, AFM metrics, dates (O4, O5, O6) and the page layouts (O1)
pdf::write: text (safe_text with the frozen V8 classes, js_upper from the O4 tables,
js_trim, measure = Σ(WX || 250 + KPX) × size / 1000 over WinAnsi bytes, wrap_lines on JS
\s), afm_data generated by scripts/r4-afm-data.mjs from O5 and O4, dates (Date.UTC years
0-99 → 19xx, fr-FR / en-US long dates), input checks (branding and labels schemas,
snapshot gate with the R3 SVG reader, sheet mismatch, page caps), the header, footer,
observation and conclusion layouts into a DrawLog (per page, footers last, links by page).
cargo: O4 55,992 widths bit-exact, 1,168 wraps, safeText over every code point, upper
1,580, O6 6,468 cells + 22; O1 12 runs 2,124 ops equal at full precision; the Step 6 text
and image goldens (24) derive from the log. ts-rs: ExportInput, ExportErrorKind,
ExportWarning, LogoSlot.
2026-10-18 21:47:40 +02:00

254 lines
8.0 KiB
JavaScript

// R4.4a generator of crates/core/src/pdf/write/afm_data.rs (plan 2026-10-17
// §B.1.3 "Text rules"): the metrics pdf-lib 1.17.1 measures the three standard
// fonts with, over WinAnsi, from the frozen O5 oracle (afm.json), and the
// Unicode tables of the text rules as V8 had them, from the frozen O4 oracle
// (text.json): the safeText dropped classes, toUpperCase, JS \s and trim.
// Every table is sorted for a binary search. Deterministic: rerunning on the
// same oracles writes the same file (the header names their sha256 and the
// commit that last touched each). The Rust suite crates/core/tests/pdf_text.rs
// checks the tables back against the oracles.
// Usage: node scripts/r4-afm-data.mjs
import { execFileSync } from 'node:child_process'
import { createHash } from 'node:crypto'
import { readFileSync, writeFileSync } from 'node:fs'
import { join, resolve } from 'node:path'
import { fileURLToPath } from 'node:url'
const ROOT = resolve(fileURLToPath(new URL('..', import.meta.url)))
const ORACLES = 'crates/core/tests/oracles/r4'
const OUT = join(ROOT, 'crates/core/src/pdf/write/afm_data.rs')
const FONTS = [
['Helvetica', 'HELVETICA'],
['Helvetica-Bold', 'HELVETICA_BOLD'],
['Times-Roman', 'TIMES_ROMAN'],
]
const MAX_LINE = 100
const INDENT = ' '
function readOracle(name) {
const path = `${ORACLES}/${name}`
const text = readFileSync(join(ROOT, path), 'utf8')
const sha256 = createHash('sha256').update(text).digest('hex')
const commit = execFileSync('git', ['log', '-1', '--format=%h', '--', path], {
cwd: ROOT,
encoding: 'utf8',
}).trim()
return { path, data: JSON.parse(text), sha256, commit: commit || 'none' }
}
function fail(message) {
throw new Error(`r4-afm-data: ${message}`)
}
function hex(codePoint) {
return `0x${codePoint.toString(16).toUpperCase().padStart(4, '0')}`
}
/** Items joined by ", " and packed greedily into lines of at most MAX_LINE. */
function pack(items, indent) {
const lines = []
let line = ''
for (const item of items) {
const next = line ? `${line} ${item},` : `${indent}${item},`
if (next.length > MAX_LINE && line) {
lines.push(line)
line = `${indent}${item},`
} else {
line = next
}
}
if (line) lines.push(line)
return lines.join('\n')
}
function byteGlyphs(winAnsi) {
const glyphs = new Map()
for (const [, byte, glyph] of winAnsi) {
const known = glyphs.get(byte)
if (known !== undefined && known !== glyph) {
fail(`byte ${byte} prints ${known} and ${glyph}`)
}
glyphs.set(byte, glyph)
}
return glyphs
}
function widthsOf(font, glyphs) {
const widths = new Array(256).fill(0)
for (const [byte, glyph] of glyphs) {
const metric = font.glyphs[glyph]
if (metric !== undefined) widths[byte] = metric[0]
}
return widths
}
function kerningOf(font, glyphs) {
const pairs = []
for (const [left, leftGlyph] of glyphs) {
const row = font.kerning[leftGlyph] ?? {}
for (const [right, rightGlyph] of glyphs) {
const amount = row[rightGlyph]
if (amount !== undefined) pairs.push([left, right, amount])
}
}
return pairs.sort((a, b) => a[0] - b[0] || a[1] - b[1])
}
function fontStatic(name, constName, font, glyphs) {
const widths = widthsOf(font, glyphs)
const kerning = kerningOf(font, glyphs)
const tuples = kerning.map(([l, r, k]) => `(${l}, ${r}, ${k})`)
return [
`/// ${name}: ${kerning.length} kerning pairs between WinAnsi glyphs.`,
'#[rustfmt::skip]',
`pub static ${constName}: FontMetrics = FontMetrics {`,
`${INDENT}widths: [`,
pack(widths.map(String), INDENT.repeat(2)),
`${INDENT}],`,
`${INDENT}kerning: &[`,
pack(tuples, INDENT.repeat(2)),
`${INDENT}],`,
'};',
].join('\n')
}
function rangesOf(rows, keep) {
return rows.filter(keep).map(([start, end]) => `(${hex(start)}, ${hex(end)})`)
}
function sliceStatic(doc, name, type, items) {
return [
...doc.map((line) => `/// ${line}`),
'#[rustfmt::skip]',
`pub static ${name}: &[${type}] = &[`,
pack(items, INDENT),
'];',
].join('\n')
}
function checkSafeText(ranges, winAnsi) {
const encodable = new Set(winAnsi.map(([codePoint]) => codePoint))
for (const [start, end, kind] of ranges) {
for (let cp = start; cp <= end; cp += 1) {
const surrogate = cp >= 0xd800 && cp <= 0xdfff
const expected = encodable.has(cp) && !surrogate ? 'kept' : 'question'
if (kind !== 'dropped' && kind !== expected) {
fail(`safeText ${hex(cp)} is ${kind}, WinAnsi says ${expected}`)
}
}
}
}
function upperSpecial([codePoint, result]) {
const escaped = result
.map((cp) => `\\u{${cp.toString(16).toUpperCase()}}`)
.join('')
return `(${hex(codePoint)}, "${escaped}")`
}
function header(afm, text) {
const env = text.data.environment
return [
`//! Generated by \`scripts/r4-afm-data.mjs\`: do not edit, rerun the generator.`,
'//!',
'//! The AFM metrics of Helvetica, Helvetica-Bold and Times-Roman over WinAnsi as pdf-lib',
'//! 1.17.1 measures them (@pdf-lib/standard-fonts 1.0.0), and the Unicode tables of the',
`//! text rules as V8 ${env.v8} had them (Node ${env.node}, ICU ${env.icu},`,
`//! Unicode ${env.unicode}). Sources, the frozen oracles:`,
`//! - O5 \`${afm.path}\` (commit ${afm.commit})`,
`//! sha256 ${afm.sha256}`,
`//! - O4 \`${text.path}\` (commit ${text.commit})`,
`//! sha256 ${text.sha256}`,
].join('\n')
}
const FONT_METRICS = `/// The metrics one standard font is measured with, by WinAnsi byte.
pub struct FontMetrics {
/// AFM \`WX\` of the glyph each byte prints; 0 where the byte prints no glyph (the
/// width lookup then falls back to 250, pdf-lib's \`|| 250\`).
pub widths: [u16; 256],
/// AFM \`KPX\` (left byte, right byte, amount) between WinAnsi glyphs, sorted by pair.
pub kerning: &'static [(u8, u8, i16)],
}`
function checkRuns(runs) {
runs.forEach(([start, end], index) => {
const previous = runs[index - 1]
if (end < start || (previous && previous[1] >= start)) {
fail(`upper run ${hex(start)} unsorted or overlapping`)
}
})
}
function unicodeTables(text, winAnsi) {
const { safeText, upper, jsWhitespace, jsTrim } = text
checkSafeText(safeText.ranges, winAnsi)
checkRuns(upper.runs)
const sortedWinAnsi = [...winAnsi].sort((a, b) => a[0] - b[0])
return [
sliceStatic(
[
'`Encodings.WinAnsi`: (code point, byte) for every code point it encodes, sorted.',
],
'WINANSI',
'(u32, u8)',
sortedWinAnsi.map(([cp, byte]) => `(${hex(cp)}, ${byte})`),
),
sliceStatic(
[
'safeText `[\\p{Cc}\\p{Cf}\\p{Zl}\\p{Zp}]`: the dropped code point ranges, inclusive.',
],
'SAFE_TEXT_DROPPED',
'(u32, u32)',
rangesOf(safeText.ranges, ([, , kind]) => kind === 'dropped'),
),
sliceStatic(
[
'`toUpperCase` one-to-one: (start, end, step, delta), start + k * step <= end maps to',
'itself + delta. Sorted by start, disjoint.',
],
'UPPER_RUNS',
'(u32, u32, u32, i32)',
upper.runs.map(
([s, e, step, d]) => `(${hex(s)}, ${hex(e)}, ${step}, ${d})`,
),
),
sliceStatic(
['`toUpperCase` one-to-many: (code point, result), sorted.'],
'UPPER_SPECIAL',
'(u32, &str)',
[...upper.special].sort((a, b) => a[0] - b[0]).map(upperSpecial),
),
sliceStatic(
['JS `\\s`: the matched code point ranges, inclusive.'],
'JS_WHITESPACE',
'(u32, u32)',
rangesOf(jsWhitespace.ranges, () => true),
),
sliceStatic(
['`String.prototype.trim`: the stripped code point ranges, inclusive.'],
'JS_TRIM',
'(u32, u32)',
rangesOf(jsTrim.ranges, () => true),
),
]
}
function generate() {
const afm = readOracle('afm.json')
const text = readOracle('text.json')
const { winAnsi, fonts } = afm.data
const glyphs = byteGlyphs(winAnsi)
const parts = [
header(afm, text),
FONT_METRICS,
...FONTS.map(([name, constName]) =>
fontStatic(name, constName, fonts[name], glyphs),
),
...unicodeTables(text.data, winAnsi),
]
writeFileSync(OUT, `${parts.join('\n\n')}\n`)
}
generate()