pagyra-js 0.0.19 → 0.0.21

package/dist/tests/pdf/filter-opacity.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/pdf/filter-opacity.spec.js

@@ -0,0 +1,30 @@
+import { describe, it, expect } from "vitest";
+import { extractOpacityMultiplier } from "../../src/pdf/utils/filter-utils.js";
+describe("extractOpacityMultiplier", () => {
+    it("returns 1 for empty filter list", () => {
+        expect(extractOpacityMultiplier([])).toBe(1);
+    });
+    it("returns value for single opacity()", () => {
+        const filters = [{ kind: "opacity", value: 0.5 }];
+        expect(extractOpacityMultiplier(filters)).toBe(0.5);
+    });
+    it("multiplies multiple opacity() filters", () => {
+        const filters = [
+            { kind: "opacity", value: 0.5 },
+            { kind: "opacity", value: 0.5 },
+        ];
+        expect(extractOpacityMultiplier(filters)).toBe(0.25);
+    });
+    it("ignores non-opacity filters", () => {
+        const filters = [
+            { kind: "blur", value: 5 },
+            { kind: "opacity", value: 0.7 },
+            { kind: "brightness", value: 1.5 },
+        ];
+        expect(extractOpacityMultiplier(filters)).toBeCloseTo(0.7);
+    });
+    it("clamps result to [0, 1]", () => {
+        const filters = [{ kind: "opacity", value: 0 }];
+        expect(extractOpacityMultiplier(filters)).toBe(0);
+    });
+});

package/dist/tests/pdf/font-subset-registry-key.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/pdf/font-subset-registry-key.spec.js

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+import { PdfFontRegistry } from "../../src/pdf/font-subset/font-registry.js";
+function makeFont(family, glyphIdForA, rawAccessor) {
+    const unicodeMap = new Map([[65, glyphIdForA]]);
+    return {
+        metrics: {
+            metrics: {
+                unitsPerEm: 1000,
+                ascender: 800,
+                descender: -200,
+                lineGap: 0,
+                capHeight: 700,
+                xHeight: 500,
+            },
+            glyphMetrics: new Map([
+                [0, { advanceWidth: 500, leftSideBearing: 0 }],
+                [glyphIdForA, { advanceWidth: 600, leftSideBearing: 0 }],
+            ]),
+            cmap: {
+                getGlyphId: (cp) => unicodeMap.get(cp) ?? 0,
+                hasCodePoint: (cp) => unicodeMap.has(cp),
+                unicodeMap,
+            },
+        },
+        program: {
+            sourceFormat: "ttf",
+            unitsPerEm: 1000,
+            glyphCount: 2048,
+            getRawTableData: rawAccessor,
+        },
+        css: {
+            family,
+            weight: 700,
+            style: "normal",
+        },
+    };
+}
+describe("PdfFontRegistry keying", () => {
+    it("separates subsets for different actual fonts even with same css family stack", () => {
+        const registry = new PdfFontRegistry();
+        const familyStack = 'system-ui, -apple-system, "Segoe UI", Roboto, sans-serif';
+        const fontA = makeFont(familyStack, 44, () => null);
+        const fontB = makeFont(familyStack, 43, () => null);
+        const runA = {
+            font: fontA,
+            glyphIds: [44],
+            positions: [{ x: 0, y: 0 }],
+            text: "H",
+            fontSize: 14,
+        };
+        const runB = {
+            font: fontB,
+            glyphIds: [43],
+            positions: [{ x: 0, y: 0 }],
+            text: "H",
+            fontSize: 14,
+        };
+        registry.registerGlyphRun(runA);
+        registry.registerGlyphRun(runB);
+        const subsetA = registry.ensureSubsetFor(fontA);
+        const subsetB = registry.ensureSubsetFor(fontB);
+        expect(subsetA.subset.name).not.toBe(subsetB.subset.name);
+        expect(subsetA.subset.encodeGlyph(44)).toBe(44);
+        expect(subsetB.subset.encodeGlyph(43)).toBe(43);
+    });
+});

package/dist/tests/pdf/header-footer-clip-overflow.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/pdf/header-footer-clip-overflow.spec.js

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+import { paintHeaderFooter } from "../../src/pdf/header-footer-painter.js";
+import { PagePainter } from "../../src/pdf/page-painter.js";
+import { PdfDocument } from "../../src/pdf/primitives/pdf-document.js";
+import { FontRegistry } from "../../src/pdf/font/font-registry.js";
+describe("header/footer clip overflow", () => {
+    function createPainter() {
+        const doc = new PdfDocument({});
+        const fontRegistry = new FontRegistry(doc, { fontFaces: [] });
+        const painter = new PagePainter(300, (v) => v, fontRegistry, 0);
+        return { painter, fontRegistry };
+    }
+    it("clips header rendering to max height when clipOverflow=true", async () => {
+        const { painter, fontRegistry } = createPainter();
+        await paintHeaderFooter(painter, {
+            content: "<div style=\"height:120px;background:#000\"></div>",
+            maxHeightPt: 24,
+            maxHeightPx: 24,
+        }, undefined, new Map(), 1, 1, { fontSizePt: 10 }, true, {
+            margins: { top: 10, right: 10, bottom: 10, left: 10 },
+            pageWidthPx: 200,
+            pageHeightPx: 300,
+            fontRegistry,
+            pageOffsetY: 0,
+            clipOverflow: true,
+        });
+        expect(painter.result().content).toContain("W n");
+    });
+    it("does not clip header rendering when clipOverflow=false", async () => {
+        const { painter, fontRegistry } = createPainter();
+        await paintHeaderFooter(painter, {
+            content: "<div style=\"height:120px;background:#000\"></div>",
+            maxHeightPt: 24,
+            maxHeightPx: 24,
+        }, undefined, new Map(), 1, 1, { fontSizePt: 10 }, true, {
+            margins: { top: 10, right: 10, bottom: 10, left: 10 },
+            pageWidthPx: 200,
+            pageHeightPx: 300,
+            fontRegistry,
+            pageOffsetY: 0,
+            clipOverflow: false,
+        });
+        expect(painter.result().content).not.toContain("W n");
+    });
+});

package/dist/tests/pdf/selawik-opt-in.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/pdf/selawik-opt-in.spec.js

@@ -0,0 +1,106 @@
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { prepareHtmlRender, renderHtmlToPdf } from "../../src/html-to-pdf.js";
+import { loadBuiltinFontConfig } from "../../src/pdf/font/builtin-fonts.js";
+import { NodeEnvironment } from "../../src/environment/node-environment.js";
+import { PdfDocument } from "../../src/pdf/primitives/pdf-document.js";
+import { FontRegistry } from "../../src/pdf/font/font-registry.js";
+import { TextFontResolver } from "../../src/pdf/renderers/text-font-resolver.js";
+const ASSET_FONTS_DIR = path.resolve(process.cwd(), "assets/fonts");
+const STACK = "'Selawik', 'DejaVu Sans', 'Arimo', system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif";
+const STRESS_TEXT = "HTML→PDF Stress • sem JS • sem fixed/sticky";
+const SELAWIK_CSS = `
+@font-face {
+  font-family: 'Selawik';
+  src: url('ttf/selawik/selawkl.ttf') format('truetype');
+  font-weight: 300;
+  font-style: normal;
+}
+@font-face {
+  font-family: 'Selawik';
+  src: url('ttf/selawik/selawksl.ttf') format('truetype');
+  font-weight: 300;
+  font-style: normal;
+}
+@font-face {
+  font-family: 'Selawik';
+  src: url('ttf/selawik/selawk.ttf') format('truetype');
+  font-weight: 400;
+  font-style: normal;
+}
+@font-face {
+  font-family: 'Selawik';
+  src: url('ttf/selawik/selawksb.ttf') format('truetype');
+  font-weight: 600;
+  font-style: normal;
+}
+@font-face {
+  font-family: 'Selawik';
+  src: url('ttf/selawik/selawkb.ttf') format('truetype');
+  font-weight: 700;
+  font-style: normal;
+}
+body {
+  font-family: ${STACK};
+}
+`;
+function cloneFontConfig(config) {
+    return {
+        fontFaceDefs: config.fontFaceDefs.map((face) => ({ ...face })),
+        defaultStack: [...(config.defaultStack ?? [])],
+    };
+}
+describe("Selawik opt-in integration", () => {
+    it("loads Selawik from @font-face and keeps symbol fallback safe", async () => {
+        const environment = new NodeEnvironment(ASSET_FONTS_DIR);
+        const builtin = await loadBuiltinFontConfig(environment);
+        if (!builtin) {
+            throw new Error("Builtin font config is required for this test");
+        }
+        const fontConfig = cloneFontConfig(builtin);
+        await prepareHtmlRender({
+            html: `<div>${STRESS_TEXT}</div>`,
+            css: SELAWIK_CSS,
+            pageWidth: 794,
+            pageHeight: 1123,
+            viewportWidth: 794,
+            viewportHeight: 1123,
+            margins: { top: 0, right: 0, bottom: 0, left: 0 },
+            fontConfig,
+            resourceBaseDir: ASSET_FONTS_DIR,
+            assetRootDir: ASSET_FONTS_DIR,
+            environment,
+        });
+        const selawikFaces = fontConfig.fontFaceDefs.filter((face) => face.family === "Selawik");
+        expect(selawikFaces.length).toBeGreaterThanOrEqual(5);
+        expect(selawikFaces.every((face) => face.data instanceof ArrayBuffer)).toBe(true);
+        expect(selawikFaces.map((face) => face.weight)).toEqual(expect.arrayContaining([300, 300, 400, 600, 700]));
+        const registry = new FontRegistry(new PdfDocument(), { fontFaces: [] });
+        await registry.initializeEmbedder(fontConfig);
+        const resolver = new TextFontResolver(registry);
+        const resolved = await resolver.ensureFontResource({
+            fontFamily: STACK,
+            fontWeight: 400,
+            fontStyle: "normal",
+            text: STRESS_TEXT,
+        });
+        const arrow = "→".codePointAt(0);
+        const bullet = "•".codePointAt(0);
+        expect(resolved.metrics).toBeDefined();
+        expect(resolved.metrics.cmap.getGlyphId(arrow)).toBeGreaterThan(0);
+        expect(resolved.metrics.cmap.getGlyphId(bullet)).toBeGreaterThan(0);
+        const pdfBytes = await renderHtmlToPdf({
+            html: `<div>${STRESS_TEXT}</div>`,
+            css: SELAWIK_CSS,
+            pageWidth: 794,
+            pageHeight: 1123,
+            viewportWidth: 794,
+            viewportHeight: 1123,
+            margins: { top: 0, right: 0, bottom: 0, left: 0 },
+            resourceBaseDir: ASSET_FONTS_DIR,
+            assetRootDir: ASSET_FONTS_DIR,
+            environment,
+        });
+        expect(pdfBytes.byteLength).toBeGreaterThan(1024);
+    });
+});

package/dist/tests/pdf/system-ui-fallback-subset-regression.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/pdf/system-ui-fallback-subset-regression.spec.js

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { PDFParse } from "pdf-parse";
+import { renderHtmlToPdf } from "../../src/html-to-pdf.js";
+describe("system-ui fallback subset regression", () => {
+    it("keeps text readable when fallback font differs from initial stack resolution", async () => {
+        const html = `
+      <!DOCTYPE html>
+      <html lang="pt-BR">
+      <head>
+        <meta charset="utf-8" />
+        <style>
+          :root { --body-font: system-ui, -apple-system, "Segoe UI", Roboto, sans-serif; }
+          body { font-family: var(--body-font); margin: 0; }
+          .title { font-weight: 700; font-size: 14pt; }
+        </style>
+      </head>
+      <body>
+        <div class="title">HTML→PDF Stress</div>
+        <div>Fluxo puro • sem JS • sem fixed/sticky</div>
+      </body>
+      </html>
+    `;
+        const pdfBytes = await renderHtmlToPdf({
+            html,
+            pageWidth: 794,
+            pageHeight: 1123,
+            viewportWidth: 794,
+            viewportHeight: 1123,
+            margins: { top: 0, right: 0, bottom: 0, left: 0 },
+        });
+        const parser = new PDFParse({ data: Buffer.from(pdfBytes) });
+        const extracted = await parser.getText();
+        await parser.destroy();
+        const compact = extracted.text.replace(/\s+/g, " ").trim();
+        expect(compact).toContain("HTML→PDF");
+        expect(compact.toLowerCase()).toContain("stress");
+        expect(compact).not.toContain("GSLK");
+    });
+});

package/dist/tests/pdf/text-renderer-fallback.spec.js

@@ -1,6 +1,7 @@
 import { TextRenderer } from "../../src/pdf/renderers/text-renderer.js";
 import { CoordinateTransformer } from "../../src/pdf/utils/coordinate-transformer.js";
 import { TtfFontMetrics } from "../../src/types/fonts.js";
+import { TextFontResolver } from "../../src/pdf/renderers/text-font-resolver.js";
 describe("text renderer glyph fallback", () => {
     it("rebuilds glyph runs when the resolved font differs from the precomputed one", async () => {
         const marker = "\u25E6";
@@ -103,4 +104,58 @@ describe("text renderer glyph fallback", () => {
         expect(run.glyphs?.glyphIds[0]).toBe(1);
         expect(run.glyphs?.font.metrics.cmap).toBe(presentMetrics.cmap);
     });
+    it("tries default stack when requested family cannot render unicode glyph", async () => {
+        const arrow = "\u2192";
+        const arrowCp = arrow.codePointAt(0);
+        const baseMetrics = {
+            unitsPerEm: 1000,
+            ascender: 0,
+            descender: 0,
+            lineGap: 0,
+            capHeight: 0,
+            xHeight: 0,
+        };
+        const glyphMetrics = new Map([
+            [0, { advanceWidth: 500, leftSideBearing: 0 }],
+            [1, { advanceWidth: 500, leftSideBearing: 0 }],
+        ]);
+        const missingCmap = {
+            getGlyphId: (_codePoint) => 0,
+            hasCodePoint: (_codePoint) => false,
+            unicodeMap: new Map(),
+        };
+        const presentCmap = {
+            getGlyphId: (_codePoint) => 1,
+            hasCodePoint: (_codePoint) => true,
+            unicodeMap: new Map([[arrowCp, 1]]),
+        };
+        const primaryFont = {
+            baseFont: "PrimaryFont",
+            resourceName: "F1",
+            ref: { objectNumber: 1 },
+            isBase14: false,
+            metrics: new TtfFontMetrics(baseMetrics, glyphMetrics, missingCmap),
+        };
+        const fallbackFont = {
+            baseFont: "FallbackFont",
+            resourceName: "F2",
+            ref: { objectNumber: 2 },
+            isBase14: false,
+            metrics: new TtfFontMetrics(baseMetrics, glyphMetrics, presentCmap),
+        };
+        const fontRegistry = {
+            ensureFontResource: async (family) => (family === "FallbackFont" ? fallbackFont : primaryFont),
+            getDefaultFontStack: () => ["FallbackFont"],
+            ensureSubsetForGlyphRun: () => {
+                throw new Error("ensureSubsetForGlyphRun should not be called in this test");
+            },
+        };
+        const resolver = new TextFontResolver(fontRegistry);
+        const resolved = await resolver.ensureFontResource({
+            fontFamily: "PrimaryFont",
+            text: `HTML${arrow}PDF`,
+        });
+        expect(resolved.baseFont).toBe("FallbackFont");
+        expect(resolved.metrics?.cmap.getGlyphId(arrowCp)).toBe(1);
+    });
 });

package/dist/tests/pdf/text-transform-matrix.spec.js

@@ -3,13 +3,14 @@ const TAN_20 = Math.tan((20 * Math.PI) / 180);
 describe("PDF text transforms", () => {
     it("applies skewX to text runs (keeps linear components in CSS space)", async () => {
         const html = `<span style="display:inline-block; font-size:20px; transform: skewX(20deg);">Skewed</span>`;
-        const runs = await renderRuns(html);
-        const skewRun = runs.find((r) => r.text.includes("Skewed"));
-        expect(skewRun).toBeDefined();
-        // lineMatrix remains in CSS coordinates; skewX should set c to tan(20deg)
-        expect(Math.abs((skewRun.lineMatrix?.c ?? 0) - TAN_20)).toBeLessThan(1e-3);
-        expect(skewRun.lineMatrix?.a ?? 1).toBeCloseTo(1);
-        expect(skewRun.lineMatrix?.d ?? 1).toBeCloseTo(1);
+        const tree = await renderTreeForHtml(html);
+        const boxes = collectBoxes(tree.root);
+        const skewedBox = boxes.find((b) => b.transform !== undefined && b.textRuns.some(r => r.text.includes("Skewed")));
+        expect(skewedBox).toBeDefined();
+        // transform matrix in CSS coordinates from the style; skewX should set c to tan(20deg)
+        expect(Math.abs((skewedBox.transform?.c ?? 0) - TAN_20)).toBeLessThan(1e-3);
+        expect(skewedBox.transform?.a ?? 1).toBeCloseTo(1);
+        expect(skewedBox.transform?.d ?? 1).toBeCloseTo(1);
     });
     it("keeps text baseline inside table cell", async () => {
         const html = `

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pagyra-js",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "type": "module",
   "files": [
     "dist"
@@ -37,7 +37,7 @@
     "./dist/src/environment/node-environment.js": "./dist/src/environment/node-environment.browser.js"
   },
   "scripts": {
-    "build": "tsc && tsx scripts/copy-brotli-vendor.ts && tsx scripts/build-browser-bundle.ts --target dist --sourcemap --minify",
+    "build": "tsc && tsx scripts/copy-brotli-vendor.ts && tsx scripts/copy-font-assets.ts && tsx scripts/build-browser-bundle.ts --target dist --sourcemap --minify",
     "check": "tsc --noEmit",
     "start": "npm run playground",
     "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",