@jasy/pdf 1.0.0-beta.6 → 1.0.0-beta.7

package/dist/edit/fill.js

@@ -6,6 +6,7 @@ import { flattenInto } from "./flatten.js";
 import { getArrayBuffer } from "../utils/utf8-to-windows1252-encoder.js";
 import { get, isDict, isRef } from "./objects.js";
 import { encodePdfText } from "../text/pdf-text-string.js";
+import { preloadStandardFonts } from "../utils/afm-parser.js";
 /** Field flags we have to honour when filling (see `forms/acroform.ts` for the writer's side). */
 const FF_READ_ONLY = 1 << 0;
 const FF_MULTI_SELECT = 1 << 21;
@@ -227,6 +228,7 @@ function plan(field, value, enciphered) {
  * @param values field name -> value. Names are the fully qualified ones `readAcroForm` reports.
  */
 export async function fillForm(bytes, values, options = {}) {
+    await preloadStandardFonts(); // a field's new face is measured in Helvetica
     // Two option combinations describe a document nobody wants. Refused before the file is opened, since
     // the answer does not depend on it.
     if (options.fieldAppearances === false && options.needAppearances === false) {

package/dist/edit/flatten.js

@@ -1,3 +1,4 @@
+import { preloadStandardFonts } from "../utils/afm-parser.js";
 import { PdfDocument } from "./document.js";
 import { readAcroForm } from "./acroform-reader.js";
 import { bakeAppearance, bakeButtonStates, readLook } from "./appearance.js";
@@ -430,6 +431,7 @@ function pruneKids(doc, list, gone, out = [], depth = 0) {
 }
 /** Flatten an existing form: its values become page content and stop being editable. */
 export async function flattenForm(bytes, options = {}) {
+    await preloadStandardFonts(); // a widget without a face gets one, measured in Helvetica
     const doc = await PdfDocument.open(bytes, {
         password: options.password,
         maxStreamSize: options.maxStreamSize,

package/dist/renderer/pdf-document-class.js

@@ -1,3 +1,4 @@
+import { preloadStandardFonts } from "../utils/afm-parser.js";
 import { FontStyle, PDFObjectManager } from "../utils/pdf-object-manager.js";
 import { PDFRenderer } from "./pdf-renderer.js";
 // Re-exported so existing `../renderer` consumers keep importing these from here.
@@ -97,6 +98,8 @@ export class PDFDocument {
     }
     beforeRenderer() { }
     static async render() {
+        // Before build(): a subclass may measure text there, through `objectManager`.
+        await preloadStandardFonts();
         const instance = new this();
         instance.child = instance.build();
         return await PDFRenderer.render(instance.child, instance._objectManager);

package/dist/renderer/pdf-renderer.js

@@ -52,9 +52,12 @@ import { RotatedElement } from "../elements/layout/rotated-element.js";
 import { RotatedBoxElement } from "../elements/layout/rotated-box-element.js";
 import { RotatedRenderer } from "./rotated-renderer.js";
 import { collectImageElements } from "../layout/collect-images.js";
+import { preloadStandardFonts } from "../utils/afm-parser.js";
 import { DEFAULT_TEXT_STYLE, mergeTextStyle } from "../text/text-style.js";
 export class PDFRenderer {
     static async render(document, objectManager) {
+        // Layout measures synchronously, so the standard font metrics are loaded before it starts.
+        await preloadStandardFonts();
         // Register all Renderer
         RendererRegistry.register(TextElement, TextRenderer.render);
         RendererRegistry.register(ContainerElement, ContainerRenderer.render);

package/dist/utils/afm-parser.d.ts

@@ -1,21 +1,34 @@
 import type { FontVerticals } from "../text/line-metrics.js";
 import type { FontDecoration } from "../text/text-decoration.js";
-export declare function standardParser(fullName: string, data: string): AFMParser;
+/** One standard font's metrics, pre-parsed from its AFM file by scripts/gen-font-data.mjs. */
+export interface StandardFontData {
+    /** FontBBox, in glyph units (1000 / em). */
+    bbox: number[];
+    /** UnderlinePosition (negative: below the baseline), UnderlineThickness. */
+    underline: number[];
+    capHeight: number;
+    xHeight: number;
+    /** The advance of every glyph by index; 0 where the font has none. */
+    widths: number[];
+    /** [first, count, second - previous second, value, ...] */
+    kerning: number[];
+}
+/** The 14 names, known without their data: registering a font must not wait for it. */
+export declare const STANDARD_FONT_NAMES: ReadonlySet<string>;
+/**
+ * Loads the metrics of the 14 standard fonts. Every render does this itself; call it ahead of time to
+ * have the first PDF without the wait, or to measure outside a render. Once per process.
+ */
+export declare function preloadStandardFonts(): Promise<void>;
+export declare function standardParser(fullName: string): AFMParser;
+/** A standard font's metrics, read on first use - by then a render has loaded them. */
 export declare class AFMParser {
-    private advanceWidths;
-    private kerningPairs;
-    private glyphMap;
-    private bbox;
+    private readonly fullName;
+    private font?;
     private cachedVerticals?;
-    private underlinePosition;
-    private underlineThickness;
-    private capHeight;
-    private xHeight;
     private cachedDecoration?;
-    constructor(afmData: string);
-    private getGlyphName;
-    private parseAFMData;
-    private parseCharMetrics;
+    constructor(fullName: string);
+    private get data();
     /**
      * The font's LINE metrics, as fractions of the em: how far a line box must reach above and below
      * the baseline. Taken from the `FontBBox`.
@@ -41,8 +54,9 @@ export declare class AFMParser {
      * strikethrough crosses at half of that. Still read from the font, not guessed.
      */
     decoration(): FontDecoration;
-    getAdvanceWidth(charName: string): number;
-    /** The pair's kerning. The AFM keys its pairs by GLYPH name (`KPX T comma`), like its widths - so the
-     *  characters are named first, or only letter-letter pairs (where the two coincide) would ever hit. */
+    /** One character's advance. A string of several characters is not a glyph name here: it measures 0. */
+    getAdvanceWidth(char: string): number;
+    /** The pair's kerning. The AFM keys its pairs by GLYPH, like its widths - so the characters are
+     *  mapped to glyphs first, or only letter-letter pairs (where the two coincide) would ever hit. */
     getKerning(firstChar: string, secondChar: string): number;
 }

package/dist/utils/afm-parser.js

@@ -1,118 +1,79 @@
-import { AGL } from "../assets/font-data.js";
-/** The Adobe Glyph List: code point -> glyph name. Constant, so it is parsed once per process and
- *  shared by every face rather than rebuilt per `AFMParser`. */
-let sharedGlyphMap;
-function glyphList() {
-    if (sharedGlyphMap)
-        return sharedGlyphMap;
-    const map = {};
-    for (const line of AGL.split("\n")) {
-        const parts = line.trim().split(";");
-        if (parts.length >= 2)
-            map[String.fromCharCode(parseInt(parts[0], 16))] = parts[1];
-    }
-    // Windows-1252 characters the AGLFN leaves out, by the glyph WinAnsiEncoding draws them with
-    // (ISO 32000-1, Annex D). Unnamed, they were measured as "?" while the viewer drew the real glyph.
-    map["\u00a0"] = "space";
-    map["\u00ad"] = "hyphen";
-    map["\u00b2"] = "twosuperior";
-    map["\u00b3"] = "threesuperior";
-    map["\u00b9"] = "onesuperior";
-    return (sharedGlyphMap = map);
+/** The 14 names, known without their data: registering a font must not wait for it. */
+export const STANDARD_FONT_NAMES = new Set([
+    "Courier",
+    "Courier-Bold",
+    "Courier-BoldOblique",
+    "Courier-Oblique",
+    "Helvetica",
+    "Helvetica-Bold",
+    "Helvetica-BoldOblique",
+    "Helvetica-Oblique",
+    "Symbol",
+    "Times-Bold",
+    "Times-BoldItalic",
+    "Times-Italic",
+    "Times-Roman",
+    "ZapfDingbats",
+]);
+// The metrics are 155 KB of numbers that only a render needs, so they are loaded then, and an app
+// that ships jasy does not carry them in its start bundle. Layout is synchronous: everything that
+// measures awaits this first (PDFRenderer.render, fillForm, flattenForm).
+let metrics;
+let loading;
+let glyphOf;
+/**
+ * Loads the metrics of the 14 standard fonts. Every render does this itself; call it ahead of time to
+ * have the first PDF without the wait, or to measure outside a render. Once per process.
+ */
+export function preloadStandardFonts() {
+    // ".js", not ".ts": tsc rewrites the extension of a static import, not of a dynamic one.
+    return (loading ?? (loading = import("../assets/standard-fonts.js").then((m) => {
+        metrics = m;
+        glyphOf = new Map();
+        for (let i = 0; i < m.CHARS.length; i += 2) {
+            glyphOf.set(String.fromCharCode(m.CHARS[i]), m.CHARS[i + 1]);
+        }
+    }, (e) => {
+        loading = undefined; // a chunk lost to a deploy: the next render tries again
+        throw e;
+    })));
 }
-/** One parser per standard-14 face for the whole process: the AFM data is a constant and a parsed
+/** One parser per standard-14 face for the whole process: the metrics are constants and a parsed
  *  face is read-only, so every document can share one. */
 const STANDARD_PARSERS = new Map();
-export function standardParser(fullName, data) {
+export function standardParser(fullName) {
     let parser = STANDARD_PARSERS.get(fullName);
     if (!parser)
-        STANDARD_PARSERS.set(fullName, (parser = new AFMParser(data)));
+        STANDARD_PARSERS.set(fullName, (parser = new AFMParser(fullName)));
     return parser;
 }
+/** A standard font's metrics, read on first use - by then a render has loaded them. */
 export class AFMParser {
-    constructor(afmData) {
-        this.advanceWidths = {};
-        this.kerningPairs = {};
-        this.glyphMap = glyphList();
-        // The font's bounding box in glyph space (1000 units / em), from the AFM header. This - not the
-        // `Ascender` line - is what a line box is built from; see `verticals()`.
-        this.bbox = [0, 0, 0, 0];
-        // Glyph metrics from the AFM header, for underline / strikethrough. All 14 standard fonts carry
-        // the underline pair; Symbol and ZapfDingbats have no CapHeight/XHeight (they have no lowercase).
-        this.underlinePosition = 0; // negative, as the AFM writes it: below the baseline
-        this.underlineThickness = 0;
-        this.capHeight = 0;
-        this.xHeight = 0;
-        this.parseAFMData(afmData);
+    constructor(fullName) {
+        this.fullName = fullName;
     }
-    getGlyphName(char) {
-        return this.glyphMap[char] || char;
-    }
-    parseAFMData(afmData) {
-        var _a;
-        const lines = afmData.split("\n");
-        let inCharMetrics = false;
-        for (let line of lines) {
-            line = line.trim();
-            if (line.startsWith("StartCharMetrics")) {
-                inCharMetrics = true;
-                continue;
-            }
-            if (line.startsWith("EndCharMetrics")) {
-                inCharMetrics = false;
-                continue;
-            }
-            if (inCharMetrics) {
-                const charData = this.parseCharMetrics(line);
-                if (charData) {
-                    const { charName, wx } = charData;
-                    this.advanceWidths[charName] = wx;
-                }
-            }
-            if (line.startsWith("UnderlinePosition ")) {
-                this.underlinePosition = parseFloat(line.slice(18));
-            }
-            if (line.startsWith("UnderlineThickness ")) {
-                this.underlineThickness = parseFloat(line.slice(19));
-            }
-            if (line.startsWith("CapHeight ")) {
-                this.capHeight = parseFloat(line.slice(10));
-            }
-            if (line.startsWith("XHeight ")) {
-                this.xHeight = parseFloat(line.slice(8));
-            }
-            if (line.startsWith("FontBBox ")) {
-                const [x0, y0, x1, y1] = line.slice(9).trim().split(/\s+/).map(parseFloat);
-                this.bbox = [x0, y0, x1, y1];
-            }
-            if (line.startsWith("KPX")) {
-                const parts = line.split(/\s+/);
-                const firstChar = parts[1];
-                const secondChar = parts[2];
-                const kerning = parseFloat(parts[3]);
-                // Nested by first glyph, then second. A flat `${a}-${b}` key would have to be BUILT on every
-                // lookup, and getKerning runs once per adjacent character pair - that string allocation was a
-                // quarter of a standard-font render.
-                ((_a = this.kerningPairs)[firstChar] ?? (_a[firstChar] = {}))[secondChar] = kerning;
-            }
+    get data() {
+        if (this.font)
+            return this.font;
+        const raw = metrics?.FONTS[this.fullName];
+        if (!raw) {
+            throw new Error(metrics
+                ? `@jasy/pdf: "${this.fullName}" is not one of the 14 standard fonts.`
+                : "@jasy/pdf: the standard font metrics are not loaded. A render loads them itself; to " +
+                    "measure text outside one, await preloadStandardFonts() first.");
         }
-    }
-    parseCharMetrics(line) {
-        const parts = line.split(";").map((part) => part.trim());
-        let charName = "";
-        let wx = 0;
-        for (const part of parts) {
-            if (part.startsWith("N ")) {
-                charName = part.split(" ")[1];
-            }
-            if (part.startsWith("WX ")) {
-                wx = parseFloat(part.split(" ")[1]);
+        const kerning = new Map();
+        for (let i = 0; i < raw.kerning.length;) {
+            const first = raw.kerning[i++];
+            const pairs = new Map();
+            let second = 0;
+            for (let n = raw.kerning[i++]; n > 0; n--) {
+                second += raw.kerning[i++];
+                pairs.set(second, raw.kerning[i++]);
             }
+            kerning.set(first, pairs);
         }
-        if (charName && wx) {
-            return { charName, wx };
-        }
-        return null;
+        return (this.font = { ...raw, kerning });
     }
     /**
      * The font's LINE metrics, as fractions of the em: how far a line box must reach above and below
@@ -133,7 +94,7 @@ export class AFMParser {
     verticals() {
         if (this.cachedVerticals)
             return this.cachedVerticals;
-        const [, yMin, , yMax] = this.bbox;
+        const [, yMin, , yMax] = this.data.bbox;
         this.cachedVerticals = { ascent: yMax / 1000, descent: -yMin / 1000, lineGap: 0 };
         return this.cachedVerticals;
     }
@@ -147,21 +108,30 @@ export class AFMParser {
     decoration() {
         if (this.cachedDecoration)
             return this.cachedDecoration;
-        const capHeight = this.capHeight || this.bbox[3];
+        const { bbox, underline, xHeight } = this.data;
+        const capHeight = this.data.capHeight || bbox[3];
         this.cachedDecoration = {
-            underlinePosition: -this.underlinePosition / 1000, // AFM writes it negative (below the baseline)
-            underlineThickness: this.underlineThickness / 1000,
+            underlinePosition: -underline[0] / 1000, // AFM writes it negative (below the baseline)
+            underlineThickness: underline[1] / 1000,
             capHeight: capHeight / 1000,
-            xHeight: (this.xHeight || capHeight / 2) / 1000,
+            xHeight: (xHeight || capHeight / 2) / 1000,
         };
         return this.cachedDecoration;
     }
-    getAdvanceWidth(charName) {
-        return this.advanceWidths[this.getGlyphName(charName)] || 0;
+    /** One character's advance. A string of several characters is not a glyph name here: it measures 0. */
+    getAdvanceWidth(char) {
+        const { widths } = this.data; // first: it throws when the metrics are not loaded
+        const glyph = glyphOf.get(char);
+        return glyph === undefined ? 0 : widths[glyph];
     }
-    /** The pair's kerning. The AFM keys its pairs by GLYPH name (`KPX T comma`), like its widths - so the
-     *  characters are named first, or only letter-letter pairs (where the two coincide) would ever hit. */
+    /** The pair's kerning. The AFM keys its pairs by GLYPH, like its widths - so the characters are
+     *  mapped to glyphs first, or only letter-letter pairs (where the two coincide) would ever hit. */
     getKerning(firstChar, secondChar) {
-        return this.kerningPairs[this.getGlyphName(firstChar)]?.[this.getGlyphName(secondChar)] ?? 0;
+        const { kerning } = this.data;
+        const first = glyphOf.get(firstChar);
+        const second = glyphOf.get(secondChar);
+        if (first === undefined || second === undefined)
+            return 0;
+        return kerning.get(first)?.get(second) ?? 0;
     }
 }

package/dist/utils/pdf-object-manager.js

@@ -1,9 +1,8 @@
 import { pageFormats, PageSize } from "../constants/page-sizes.js";
-import { STANDARD_AFM } from "../assets/font-data.js";
 import { md5, md5Hex } from "./md5.js";
 import { zlibSync } from "fflate";
 import { bytesFromLatin1, latin1FromBytes } from "./bytes.js";
-import { standardParser } from "./afm-parser.js";
+import { STANDARD_FONT_NAMES, standardParser } from "./afm-parser.js";
 import { mergeSpans, TTFParser } from "./ttf-parser.js";
 import { WoffError, isWoff, woffToSfnt } from "./woff.js";
 import { isWoff2 } from "./woff2.js";
@@ -612,13 +611,12 @@ endstream`;
         this.fontEpoch++;
         this.verticalsCache.delete(fontName);
         this.decorationCache.delete(fontName);
-        const data = STANDARD_AFM[fullName];
-        if (data !== undefined) {
+        if (STANDARD_FONT_NAMES.has(fullName)) {
             this.afmParsers.push({
                 fontName,
                 fontStyle,
                 fullFontName: fullName,
-                parser: standardParser(fullName, data),
+                parser: standardParser(fullName),
             });
         }
         const resourceNumber = this.objects.length + 1; // New resource number

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jasy/pdf",
-  "version": "1.0.0-beta.6",
+  "version": "1.0.0-beta.7",
   "description": "Create PDFs in TypeScript: declarative, component-based layout with real pagination, in Node or the browser. Its own engine - no headless browser, no Java. Powers ZUGFeRD / XRechnung e-invoices.",
   "keywords": [
     "accessibility",
@@ -56,14 +56,12 @@
     "@types/node": "^25.9.3",
     "@vitest/coverage-v8": "^2.1.1",
     "hyphen": "^1.14.1",
-    "ncp": "^2.0.0",
     "oxfmt": "^0.55.0",
     "oxlint": "^1.70.0",
     "typescript": "^5.5.4",
     "vitest": "^2.1.1"
   },
   "scripts": {
-    "copy-assets": "ncp ./src/lib/assets ./dist/assets",
     "cli": "pnpm --filter @jasy/cli dev",
     "cli:watch": "pnpm --filter @jasy/cli watch",
     "play": "pnpm --filter @jasy/playground play",
@@ -71,7 +69,7 @@
     "play:react": "pnpm --filter @jasy/react play",
     "test": "vitest",
     "test:coverage": "vitest --coverage",
-    "build": "tsc && node scripts/fix-dts-ext.mjs && pnpm run copy-assets",
+    "build": "tsc && node scripts/fix-dts-ext.mjs",
     "lint": "oxlint",
     "lint:fix": "oxlint --fix",
     "fmt": "oxfmt",