@jasy/pdf 1.0.0-beta.2 → 1.0.0-beta.3

package/dist/elements/text-element.d.ts

@@ -130,6 +130,14 @@ export declare class TextElement extends SizedPDFElement implements Fragmentable
     private readonly role?;
     constructor({ fontSize, content, fontFamily, fontStyle, color, textAlignment, maxLines, orphans, widows, overflow, lineHeight, underline, strikethrough, skipInk, letterSpacing, direction, fontFallback, textTransform, wordSpacing, textIndent, breakWord, hyphenate, ligatures, role, }: TextElementParams);
     private resolveStyle;
+    /**
+     * The last `display(metrics)` result, with what it depended on - recasing, coverage and the fallback
+     * split each walk the whole text, and every measure, break and draw asks again.
+     *
+     * COMPARED, not cleared in `resolveStyle`: that runs on every pass and resolves to the same values,
+     * so clearing would drop the answer exactly when it is about to be reused.
+     */
+    private displayed?;
     /** Justified lines may be squeezed to keep a word; every other alignment gets no slack. Read by the
      *  breaker in BOTH passes, or a measured line and a drawn one would disagree about where it ends. */
     /**

package/dist/elements/text-element.js

@@ -73,14 +73,37 @@ export class TextElement extends SizedPDFElement {
      * same width in most fonts).
      */
     display(metrics) {
+        const memo = this.displayed;
+        if (metrics &&
+            memo &&
+            memo.metrics === metrics &&
+            // A face registered since then changes what is drawable and how the fallback stack splits.
+            memo.epoch === (metrics.fontEpoch ?? 0) &&
+            memo.family === this.fontFamily &&
+            memo.style === this.fontStyle &&
+            memo.transform === this.textTransform &&
+            memo.fallback === this.fontFallback)
+            return memo.value;
         const cased = this.recased();
         // A SPAN may bring its own stack, so the element's being empty is not enough to skip the pass.
         const anyStack = this.fontFallback.length > 0 ||
             (typeof cased !== "string" && cased.some((seg) => (seg.fontFallback?.length ?? 0) > 0));
         if (!metrics)
             return cased;
+        const remember = (value) => {
+            this.displayed = {
+                metrics,
+                epoch: metrics.fontEpoch ?? 0,
+                family: this.fontFamily,
+                style: this.fontStyle,
+                transform: this.textTransform,
+                fallback: this.fontFallback,
+                value,
+            };
+            return value;
+        };
         if (!anyStack)
-            return this.covered(cased, metrics);
+            return remember(this.covered(cased, metrics));
         // Font fallback turns the content into spans - one per family - which every later pass already
         // knows how to handle. Nothing new downstream.
         const pieces = typeof cased === "string" ? [{ content: cased }] : cased;
@@ -93,7 +116,7 @@ export class TextElement extends SizedPDFElement {
                 for (const run of runs)
                     out.push({ ...seg, content: run.text, fontFamily: run.fontFamily });
         }
-        return this.covered(out, metrics);
+        return remember(this.covered(out, metrics));
     }
     /**
      * Drops or substitutes whatever the RESOLVED font cannot draw. Runs last, after the fallback stack

package/dist/text/advance.js

@@ -39,6 +39,12 @@ export function codePointCount(text) {
  * is thrown away when it flips; the same document can be rendered twice with different options.
  */
 const ADVANCE_CACHE = new WeakMap();
+/**
+ * The innermost map a `RunFont` resolves to, remembered on the font object itself. The breaker builds
+ * one font per run and asks for every word with it, so without this each word walks five maps of which
+ * four hold a single entry.
+ */
+const BY_FONT = new WeakMap();
 function baseAdvance(metrics, text, font) {
     let entry = ADVANCE_CACHE.get(metrics);
     const epoch = metrics.fontEpoch ?? 0;
@@ -49,6 +55,20 @@ function baseAdvance(metrics, text, font) {
         entry = { epoch, kerning, byFamily: new Map() };
         ADVANCE_CACHE.set(metrics, entry);
     }
+    // Same font object as last time, and the metrics entry has not been replaced: the map is already known.
+    // Its FIELDS are compared, not just its identity: a caller that reuses one object and changes the
+    // size on it would otherwise be handed the previous size's map.
+    const known = BY_FONT.get(font);
+    if (known?.entry === entry &&
+        known.family === font.fontFamily &&
+        known.size === font.fontSize &&
+        known.style === font.fontStyle &&
+        known.ligatures === font.ligatures) {
+        const seen = known.byText.get(text);
+        if (seen !== undefined)
+            return seen;
+        return measureAndStore(metrics, text, font, known.byText);
+    }
     let byStyle = entry.byFamily.get(font.fontFamily);
     if (!byStyle)
         entry.byFamily.set(font.fontFamily, (byStyle = new Map()));
@@ -61,9 +81,21 @@ function baseAdvance(metrics, text, font) {
     let byText = bySize.get(font.fontSize);
     if (!byText)
         bySize.set(font.fontSize, (byText = new Map()));
+    BY_FONT.set(font, {
+        entry,
+        family: font.fontFamily,
+        size: font.fontSize,
+        style: font.fontStyle,
+        ligatures: font.ligatures,
+        byText,
+    });
     const hit = byText.get(text);
     if (hit !== undefined)
         return hit;
+    return measureAndStore(metrics, text, font, byText);
+}
+/** The measurement itself, once a miss has found the map it belongs in. */
+function measureAndStore(metrics, text, font, byText) {
     let advance = metrics.getStringWidth(text, font.fontFamily, font.fontSize, font.fontStyle, font.ligatures);
     if (metrics.kerningEnabled) {
         let units = 0;

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

@@ -1,5 +1,6 @@
 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;
 export declare class AFMParser {
     private advanceWidths;
     private kerningPairs;

package/dist/utils/afm-parser.js

@@ -13,6 +13,15 @@ function glyphList() {
     }
     return (sharedGlyphMap = map);
 }
+/** One parser per standard-14 face for the whole process: the AFM data is a constant and a parsed
+ *  face is read-only, so every document can share one. */
+const STANDARD_PARSERS = new Map();
+export function standardParser(fullName, data) {
+    let parser = STANDARD_PARSERS.get(fullName);
+    if (!parser)
+        STANDARD_PARSERS.set(fullName, (parser = new AFMParser(data)));
+    return parser;
+}
 export class AFMParser {
     constructor(afmData) {
         this.advanceWidths = {};

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

@@ -3,7 +3,7 @@ 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 { AFMParser } from "./afm-parser.js";
+import { standardParser } from "./afm-parser.js";
 import { mergeSpans, TTFParser } from "./ttf-parser.js";
 import { WoffError, isWoff, woffToSfnt } from "./woff.js";
 import { isWoff2 } from "./woff2.js";
@@ -577,7 +577,7 @@ endstream`;
                 fontName,
                 fontStyle,
                 fullFontName: fullName,
-                parser: new AFMParser(data),
+                parser: standardParser(fullName, data),
             });
         }
         const resourceNumber = this.objects.length + 1; // New resource number

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jasy/pdf",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.3",
   "description": "Declarative, component-based PDF generation in pure TypeScript - Flutter-style components, real AFM font metrics, a hand-rolled PDF writer. No headless browser, no Java.",
   "keywords": [
     "declarative",