@jasy/pdf 1.0.0-alpha.1

package/dist/renderer/page-renderer.js

@@ -0,0 +1,81 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageRenderer = void 0;
+const page_sizes_1 = require("../constants/page-sizes");
+const renderer_registry_1 = require("../utils/renderer-registry");
+const pdf_config_1 = require("./pdf-config");
+const pdf_backend_1 = require("./pdf-backend");
+class PageRenderer {
+    static render(page, objectManager) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const { children, config, header, footer } = page.getProps();
+            // Header (top band) and footer (bottom band) sit around the body and repeat on every
+            // physical page; they are placed by `PageElement.calculateLayout` / the page driver.
+            const renderables = [...(header ? [header] : []), ...children, ...(footer ? [footer] : [])];
+            // Page geometry (also the MediaBox below). Needed up front because flipping the
+            // display list to PDF coordinates uses the page height. config is fully resolved
+            // by the layout pass; fall back to the document default rather than asserting.
+            let [width, height] = page_sizes_1.pageFormats[(_a = config === null || config === void 0 ? void 0 : config.pageSize) !== null && _a !== void 0 ? _a : page_sizes_1.PageSize.A4];
+            if ((config === null || config === void 0 ? void 0 : config.orientation) === pdf_config_1.Orientation.landscape) {
+                [width, height] = [height, width];
+            }
+            // Collect the whole page as a display list (top-left coordinates), flip it to PDF
+            // coordinates at this one seam, then serialize once. Serializing registers the
+            // fonts/images used below, so it must run before the resource section.
+            const nodes = [];
+            for (const element of renderables) {
+                const renderer = renderer_registry_1.RendererRegistry.getRenderer(element);
+                if (renderer) {
+                    nodes.push(...(yield renderer(element, objectManager)));
+                }
+            }
+            const pageContent = pdf_backend_1.PdfBackend.serialize(pdf_backend_1.PdfBackend.flipY(nodes, height), objectManager);
+            // Add the page content as a new object (FlateDecode-compressed when enabled). The /Length is
+            // computed inside, with an explicit EOL before `endstream` (PDF/A clause 6.1.7.1).
+            const contentObjectNumber = objectManager.addContentStream(pageContent);
+            // Get the parent object number dynamically (linked with the page object)
+            const parentObjectNumber = objectManager.getParentObjectNumber(); // Get parent object number
+            // Page object with MediaBox
+            // - Get all fonts and add it to the page (reference)
+            objectManager.registerFont("Helvetica");
+            const fontReferences = [];
+            objectManager.getAllFontsRaw().forEach((value, _key) => {
+                const fontRef = `/F${value.fontIndex} ${value.resourceIndex} 0 R`;
+                fontReferences.push(fontRef);
+            });
+            // - Get all images and add it to the page (reference)
+            const imageReferences = [];
+            objectManager.getAllImagesRaw().forEach((value) => {
+                const imageRef = `/IM${value} ${value} 0 R`;
+                imageReferences.push(imageRef);
+            });
+            const imageCode = imageReferences.length > 0
+                ? "/ProcSet [/PDF /Text /ImageB /ImageC /ImageI] /XObject <<\n" +
+                    imageReferences.join("\n") +
+                    "\n>>\n"
+                : "";
+            // - Transparency (ExtGState) references, registered during serialize above
+            const extGStateReferences = [];
+            objectManager.getAllExtGStatesRaw().forEach((objectNumber, name) => {
+                extGStateReferences.push(`/${name} ${objectNumber} 0 R`);
+            });
+            const extGStateCode = extGStateReferences.length > 0
+                ? "/ExtGState <<\n" + extGStateReferences.join("\n") + "\n>>\n"
+                : "";
+            const pageObject = `<< /Type /Page /Parent ${parentObjectNumber} 0 R /Contents ${contentObjectNumber} 0 R /Resources <<\n/Font <<\n${fontReferences.join("\n")}\n>>\n${imageCode}${extGStateCode}>>\n/MediaBox [0 0 ${width} ${height}] >>`;
+            // Add page as new object and return the page number
+            return objectManager.addObject(pageObject);
+        });
+    }
+}
+exports.PageRenderer = PageRenderer;

package/dist/renderer/pdf-backend.d.ts

@@ -0,0 +1,45 @@
+import { IRNode } from "../ir/display-list";
+import { PDFObjectManager } from "../utils/pdf-object-manager";
+/**
+ * PDF backend - turns display-list primitives into content-stream operators.
+ *
+ * This is "the renderer" in the pure sense: it consumes only `IRNode`s and knows
+ * nothing about components. Each primitive maps to the exact operators previously
+ * emitted inline by the per-element renderers, so output stays byte-identical while
+ * the renderers are migrated onto the IR one at a time.
+ */
+export declare class PdfBackend {
+    /**
+     * Flip a display list from the engine's top-left origin (y grows downward) to PDF's
+     * bottom-left origin (y grows upward). This is the ONE place the Y axis is flipped -
+     * elements above this seam are coordinate-system-blind. Each primitive flips around
+     * its own anchor: a rect/image around its bottom edge, a text baseline / line point
+     * directly. (image is migrated in a later slice and still arrives pre-flipped.)
+     */
+    static flipY(nodes: IRNode[], pageHeight: number): IRNode[];
+    /** Serialize a whole display list into one content stream (page-level entry point). */
+    static serialize(nodes: IRNode[], om: PDFObjectManager): string;
+    /**
+     * Escapes a string for a PDF literal string `( ... )`. The backslash must be doubled
+     * first, then the parentheses that delimit the string. Without this, a ")" in the
+     * text closes the string early and the remaining characters leak as raw operators.
+     */
+    static escapePdfString(text: string): string;
+    /**
+     * Returns the `/GSx gs` operator that selects a transparency state, or `""` when both
+     * alphas are fully opaque. Opaque draws emit nothing here, so output stays
+     * byte-identical until transparency is actually used.
+     */
+    private static alphaPrefix;
+    /**
+     * Path operators for a rounded rectangle: bottom-left at (x,y), size w×h, corner
+     * radius `radius` (clamped to half the smaller side). Corners are 90° Bézier arcs
+     * (kappa ≈ 0.5523). Returns m/l/c/h ops WITHOUT the paint operator.
+     */
+    private static roundedRectPath;
+    /**
+     * Serialize a single display-list node to its content-stream operators.
+     * `om` is used only by primitives that allocate PDF resources (images, fonts).
+     */
+    static serializeNode(node: IRNode, om: PDFObjectManager): string;
+}

package/dist/renderer/pdf-backend.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PdfBackend = void 0;
+/**
+ * PDF backend - turns display-list primitives into content-stream operators.
+ *
+ * This is "the renderer" in the pure sense: it consumes only `IRNode`s and knows
+ * nothing about components. Each primitive maps to the exact operators previously
+ * emitted inline by the per-element renderers, so output stays byte-identical while
+ * the renderers are migrated onto the IR one at a time.
+ */
+class PdfBackend {
+    /**
+     * Flip a display list from the engine's top-left origin (y grows downward) to PDF's
+     * bottom-left origin (y grows upward). This is the ONE place the Y axis is flipped -
+     * elements above this seam are coordinate-system-blind. Each primitive flips around
+     * its own anchor: a rect/image around its bottom edge, a text baseline / line point
+     * directly. (image is migrated in a later slice and still arrives pre-flipped.)
+     */
+    static flipY(nodes, pageHeight) {
+        return nodes.map((node) => {
+            switch (node.type) {
+                case "rect":
+                    return Object.assign(Object.assign({}, node), { y: pageHeight - node.y - node.height });
+                case "line":
+                    return Object.assign(Object.assign({}, node), { y1: pageHeight - node.y1, y2: pageHeight - node.y2 });
+                case "text":
+                    // node.y is the baseline measured from the page top; flip it directly.
+                    return Object.assign(Object.assign({}, node), { y: pageHeight - node.y });
+                case "image": {
+                    // Flip the placement box (and the clip frame, if any) around its bottom edge.
+                    const flipped = Object.assign(Object.assign({}, node), { y: pageHeight - node.y - node.height });
+                    if (node.clip) {
+                        flipped.clip = Object.assign(Object.assign({}, node.clip), { y: pageHeight - node.clip.y - node.clip.height });
+                    }
+                    return flipped;
+                }
+                default: {
+                    const unknown = node;
+                    return unknown;
+                }
+            }
+        });
+    }
+    /** Serialize a whole display list into one content stream (page-level entry point). */
+    static serialize(nodes, om) {
+        return nodes.map((node) => PdfBackend.serializeNode(node, om)).join("");
+    }
+    /**
+     * Escapes a string for a PDF literal string `( ... )`. The backslash must be doubled
+     * first, then the parentheses that delimit the string. Without this, a ")" in the
+     * text closes the string early and the remaining characters leak as raw operators.
+     */
+    static escapePdfString(text) {
+        return text.replace(/\\/g, "\\\\").replace(/\(/g, "\\(").replace(/\)/g, "\\)");
+    }
+    /**
+     * Returns the `/GSx gs` operator that selects a transparency state, or `""` when both
+     * alphas are fully opaque. Opaque draws emit nothing here, so output stays
+     * byte-identical until transparency is actually used.
+     */
+    static alphaPrefix(om, fillAlpha, strokeAlpha) {
+        if (fillAlpha >= 1 && strokeAlpha >= 1)
+            return "";
+        return `/${om.registerExtGState(fillAlpha, strokeAlpha)} gs\n`;
+    }
+    /**
+     * Path operators for a rounded rectangle: bottom-left at (x,y), size w×h, corner
+     * radius `radius` (clamped to half the smaller side). Corners are 90° Bézier arcs
+     * (kappa ≈ 0.5523). Returns m/l/c/h ops WITHOUT the paint operator.
+     */
+    static roundedRectPath(x, y, w, h, radius) {
+        const r = Math.min(radius, w / 2, h / 2);
+        const c = r * 0.5523; // control-point offset that approximates a quarter circle
+        const f = (n) => n.toFixed(3);
+        const xr = x + r;
+        const xwr = x + w - r;
+        const xw = x + w;
+        const yr = y + r;
+        const yhr = y + h - r;
+        const yh = y + h;
+        return (`${f(xr)} ${f(y)} m\n` +
+            `${f(xwr)} ${f(y)} l\n` +
+            `${f(xwr + c)} ${f(y)} ${f(xw)} ${f(yr - c)} ${f(xw)} ${f(yr)} c\n` +
+            `${f(xw)} ${f(yhr)} l\n` +
+            `${f(xw)} ${f(yhr + c)} ${f(xwr + c)} ${f(yh)} ${f(xwr)} ${f(yh)} c\n` +
+            `${f(xr)} ${f(yh)} l\n` +
+            `${f(xr - c)} ${f(yh)} ${f(x)} ${f(yhr + c)} ${f(x)} ${f(yhr)} c\n` +
+            `${f(x)} ${f(yr)} l\n` +
+            `${f(x)} ${f(yr - c)} ${f(xr - c)} ${f(y)} ${f(xr)} ${f(y)} c\n` +
+            `h`);
+    }
+    /**
+     * Serialize a single display-list node to its content-stream operators.
+     * `om` is used only by primitives that allocate PDF resources (images, fonts).
+     */
+    static serializeNode(node, om) {
+        var _a, _b, _c, _d, _e;
+        switch (node.type) {
+            case "line":
+                // q/Q isolates the graphics state; "[] 0 d" resets the dash pattern to solid.
+                return (`q\n` +
+                    PdfBackend.alphaPrefix(om, 1, node.stroke.getAlpha()) +
+                    `${node.strokeWidth} w\n` +
+                    `${node.stroke.toPDFColorString()} RG\n` +
+                    `[] 0 d\n` +
+                    `${node.x1} ${node.y1} m\n` +
+                    `${node.x2} ${node.y2} l\n` +
+                    `S\n` +
+                    `Q\n`);
+            case "rect": {
+                // Stroke only with a stroke colour AND a positive width - a 0-width border means
+                // "no border" (e.g. a filled box with no outline). Nothing to paint at all (no
+                // fill, no border) draws nothing. Paint: B = fill+stroke, f = fill, S = stroke.
+                const doStroke = !!node.stroke && ((_a = node.strokeWidth) !== null && _a !== void 0 ? _a : 0) > 0;
+                if (!node.fill && !doStroke)
+                    return "";
+                let ops = "";
+                if (doStroke) {
+                    ops += `${node.strokeWidth} w\n${node.stroke.toPDFColorString()} RG\n`;
+                }
+                if (node.fill)
+                    ops += `${node.fill.toPDFColorString()} rg\n`;
+                const paint = node.fill ? (doStroke ? "B" : "f") : "S";
+                // Rounded corners emit a Bézier path; sharp corners keep the plain `re`
+                // (byte-identical when no radius is set).
+                const path = ((_b = node.radius) !== null && _b !== void 0 ? _b : 0) > 0
+                    ? PdfBackend.roundedRectPath(node.x, node.y, node.width, node.height, node.radius)
+                    : `${node.x} ${node.y} ${node.width} ${node.height} re`;
+                const body = ops + `${path} ${paint}\n`;
+                // Transparency needs an isolating q/Q so the state does not leak; opaque rects
+                // keep their bare operators (byte-identical).
+                const gs = PdfBackend.alphaPrefix(om, (_d = (_c = node.fill) === null || _c === void 0 ? void 0 : _c.getAlpha()) !== null && _d !== void 0 ? _d : 1, doStroke ? node.stroke.getAlpha() : 1);
+                return gs ? `q\n${gs}${body}Q\n` : body;
+            }
+            case "text": {
+                // One self-contained text block per run. The producer has already resolved
+                // absolute position, font and color; the backend only allocates the font
+                // resource and emits the operators. The text is escaped for PDF literal-string
+                // syntax so parentheses/backslashes can't break out of the string.
+                // Embedded (custom) fonts: pick the family variant for this style (falling back to the
+                // family's Normal), select its Identity-H Type0 resource and emit hex glyph ids - both
+                // from the SAME variant. Standard fonts keep the WinAnsi literal string, byte-identical.
+                const isCustom = om.isCustomFont(node.fontFamily, node.fontStyle);
+                const font = isCustom
+                    ? om.getCustomFontResource(node.fontFamily, node.fontStyle)
+                    : om.registerFont(node.fontFamily, node.fontStyle);
+                const textOp = isCustom
+                    ? `<${om.encodeCustomText(node.fontFamily, node.text, node.fontStyle)}>`
+                    : `(${PdfBackend.escapePdfString(node.text)})`;
+                const block = `BT\n` +
+                    `${node.color.toPDFColorString()} rg ` +
+                    `/F${font.fontIndex} ${node.fontSize} Tf ` +
+                    `${node.x.toFixed(3)} ${node.y.toFixed(3)} Td ` +
+                    `${textOp} Tj\n` +
+                    `ET\n`;
+                // Transparent text gets an isolating q/Q + gs; opaque text is byte-identical.
+                const gs = PdfBackend.alphaPrefix(om, node.color.getAlpha(), 1);
+                return gs ? `q\n${gs}${block}Q\n` : block;
+            }
+            case "image": {
+                // The backend owns PDF resource creation: register the XObject (using the
+                // source pixel dimensions) and then place it with a scaling matrix.
+                const ref = om.registerImage(node.intrinsicWidth, node.intrinsicHeight, node.imageType, node.data);
+                const draw = `q\n${node.width} 0 0 ${node.height} ${node.x} ${node.y} cm\n` + `/IM${ref} Do\nQ\n`;
+                if (!node.clip)
+                    return draw;
+                // Clip to the frame (re … W n); rounded when a radius is set. The rectangular
+                // path is byte-identical to before.
+                const c = node.clip;
+                const clipPath = ((_e = node.radius) !== null && _e !== void 0 ? _e : 0) > 0
+                    ? PdfBackend.roundedRectPath(c.x, c.y, c.width, c.height, node.radius)
+                    : `${c.x} ${c.y} ${c.width} ${c.height} re `;
+                return `q\n${clipPath}\nW n \n` + draw + `Q\n`;
+            }
+            default: {
+                // Exhaustiveness guard: if a new IRNode variant is added, this fails to compile.
+                const unknown = node;
+                throw new Error(`PdfBackend: unhandled IR node ${JSON.stringify(unknown)}`);
+            }
+        }
+    }
+}
+exports.PdfBackend = PdfBackend;

package/dist/renderer/pdf-config.d.ts

@@ -0,0 +1,8 @@
+export declare enum Orientation {
+    portrait = "PORTRAIT",
+    landscape = "LANDSCAPE"
+}
+export declare enum ColorMode {
+    color = "COLOR",
+    grayscale = "GRAYSCALE"
+}

package/dist/renderer/pdf-config.js

@@ -0,0 +1,17 @@
+"use strict";
+// Leaf module: no imports, so it can never sit inside an import cycle. The page/color
+// enums live here because they are runtime values used across modules that DO form
+// cycles (object manager <-> document <-> elements); importing them from a cyclic
+// module snapshots them as `undefined` under some load orders.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColorMode = exports.Orientation = void 0;
+var Orientation;
+(function (Orientation) {
+    Orientation["portrait"] = "PORTRAIT";
+    Orientation["landscape"] = "LANDSCAPE";
+})(Orientation || (exports.Orientation = Orientation = {}));
+var ColorMode;
+(function (ColorMode) {
+    ColorMode["color"] = "COLOR";
+    ColorMode["grayscale"] = "GRAYSCALE";
+})(ColorMode || (exports.ColorMode = ColorMode = {}));

package/dist/renderer/pdf-document-class.d.ts

@@ -0,0 +1,42 @@
+import { PageSize } from "../constants/page-sizes";
+import { PDFDocumentElement } from "../elements";
+import { FontStyle, PDFObjectManager } from "../utils/pdf-object-manager";
+import { ColorMode, Orientation } from "./pdf-config";
+export { ColorMode, Orientation } from "./pdf-config";
+export interface Margin {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+export interface DefaultFont {
+    fontFamily: string;
+    fontSize: number;
+    fontStyle: FontStyle;
+}
+export interface MetaData {
+    title?: string;
+    author?: string;
+    keywords: string[];
+}
+export interface PDFConfig {
+    pageSize?: PageSize;
+    orientation?: Orientation;
+    margin?: Margin;
+    colorMode?: ColorMode;
+    defaultFont?: DefaultFont;
+    metaData?: MetaData;
+    /** Register the 14 standard fonts (default true). Set false for PDF/A, where every font must be
+     *  embedded - the non-embeddable standard-14 must not appear in the document at all. */
+    registerStandardFonts?: boolean;
+}
+export declare abstract class PDFDocument {
+    private _objectManager;
+    private child;
+    private registerStandardFonts;
+    constructor(config?: PDFConfig);
+    get objectManager(): PDFObjectManager;
+    abstract build(): PDFDocumentElement;
+    protected beforeRenderer(): void;
+    static render<T extends PDFDocument>(this: new () => T): Promise<string>;
+}

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

@@ -0,0 +1,118 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PDFDocument = exports.Orientation = exports.ColorMode = void 0;
+const pdf_object_manager_1 = require("../utils/pdf-object-manager");
+const pdf_renderer_1 = require("./pdf-renderer");
+// Re-exported so existing `../renderer` consumers keep importing these from here.
+var pdf_config_1 = require("./pdf-config");
+Object.defineProperty(exports, "ColorMode", { enumerable: true, get: function () { return pdf_config_1.ColorMode; } });
+Object.defineProperty(exports, "Orientation", { enumerable: true, get: function () { return pdf_config_1.Orientation; } });
+class PDFDocument {
+    //#region  Helper
+    // Method to register all standard fonts
+    registerStandardFonts(objectManager) {
+        const standardFonts = [
+            {
+                fontName: "Helvetica",
+                fontStyle: pdf_object_manager_1.FontStyle.Normal,
+                fullName: "Helvetica",
+            },
+            {
+                fontName: "Helvetica",
+                fontStyle: pdf_object_manager_1.FontStyle.Bold,
+                fullName: "Helvetica-Bold",
+            },
+            {
+                fontName: "Helvetica",
+                fontStyle: pdf_object_manager_1.FontStyle.Italic,
+                fullName: "Helvetica-Oblique",
+            },
+            {
+                fontName: "Helvetica",
+                fontStyle: pdf_object_manager_1.FontStyle.BoldItalic,
+                fullName: "Helvetica-BoldOblique",
+            },
+            { fontName: "Courier", fontStyle: pdf_object_manager_1.FontStyle.Normal, fullName: "Courier" },
+            {
+                fontName: "Courier",
+                fontStyle: pdf_object_manager_1.FontStyle.Bold,
+                fullName: "Courier-Bold",
+            },
+            {
+                fontName: "Courier",
+                fontStyle: pdf_object_manager_1.FontStyle.Italic,
+                fullName: "Courier-Oblique",
+            },
+            {
+                fontName: "Courier",
+                fontStyle: pdf_object_manager_1.FontStyle.BoldItalic,
+                fullName: "Courier-BoldOblique",
+            },
+            {
+                fontName: "Times-Roman",
+                fontStyle: pdf_object_manager_1.FontStyle.Normal,
+                fullName: "Times-Roman",
+            },
+            {
+                fontName: "Times-Roman",
+                fontStyle: pdf_object_manager_1.FontStyle.Bold,
+                fullName: "Times-Bold",
+            },
+            {
+                fontName: "Times-Roman",
+                fontStyle: pdf_object_manager_1.FontStyle.Italic,
+                fullName: "Times-Italic",
+            },
+            {
+                fontName: "Times-Roman",
+                fontStyle: pdf_object_manager_1.FontStyle.BoldItalic,
+                fullName: "Times-BoldItalic",
+            },
+            {
+                fontName: "Symbol",
+                fontStyle: pdf_object_manager_1.FontStyle.Normal,
+                fullName: "Symbol",
+            },
+            {
+                fontName: "ITC Zapf Dingbats",
+                fontStyle: pdf_object_manager_1.FontStyle.Normal,
+                fullName: "ZapfDingbats",
+            },
+        ];
+        standardFonts.forEach((font) => objectManager.registerFont(font.fontName, font.fontStyle, font.fullName));
+    }
+    //#endregion
+    constructor(config) {
+        // One object manager per document instance - no global singleton. Threaded
+        // explicitly into the renderer.
+        this._objectManager = new pdf_object_manager_1.PDFObjectManager();
+        // Add all standard font families - unless the document is PDF/A, which forbids non-embedded
+        // fonts (the caller then supplies embedded fonts for every name it uses).
+        if ((config === null || config === void 0 ? void 0 : config.registerStandardFonts) !== false) {
+            this.registerStandardFonts(this._objectManager);
+        }
+        if (config)
+            this._objectManager.changePDFConfig(config);
+    }
+    get objectManager() {
+        return this._objectManager;
+    }
+    beforeRenderer() { }
+    static render() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const instance = new this();
+            instance.child = instance.build();
+            return yield pdf_renderer_1.PDFRenderer.render(instance.child, instance._objectManager);
+        });
+    }
+}
+exports.PDFDocument = PDFDocument;

package/dist/renderer/pdf-document-renderer.d.ts

@@ -0,0 +1,20 @@
+import { PDFDocumentElement } from "../elements/pdf-document-element";
+import { LayoutContext } from "../elements/pdf-element";
+import { PDFObjectManager } from "../utils/pdf-object-manager";
+export declare class PDFDocumentRenderer {
+    static render(document: PDFDocumentElement, objectManager: PDFObjectManager, ctx: LayoutContext): Promise<number>;
+    /**
+     * Renders one logical page, paginating it into one or more physical pages.
+     *
+     * Slice 0 only auto-paginates the common shape - a page whose single child is a
+     * fragmentation context (a Container). Anything else renders as a single page on the
+     * unchanged path, so non-overflowing documents stay byte-identical to pre-Slice-0.
+     */
+    private static renderLogicalPage;
+    /**
+     * Lays out one fragment on a fresh page of the same geometry and renders it. The
+     * header/footer are attached to every physical page so they repeat; `PageElement`
+     * re-places them and the body in the band between.
+     */
+    private static renderPhysicalPage;
+}

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

@@ -0,0 +1,104 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PDFDocumentRenderer = void 0;
+const page_element_1 = require("../elements/page-element");
+const box_constraints_1 = require("../layout/box-constraints");
+const fragmentation_1 = require("../layout/fragmentation");
+const page_renderer_1 = require("./page-renderer");
+class PDFDocumentRenderer {
+    static render(document, objectManager, ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pageNumbers = [];
+            // Add the pages object first... we need its object number (resources). The count is
+            // a placeholder; it is replaced below with the real (post-pagination) page count.
+            const pagesObject = `<< /Type /Pages /Kids [] /Count ${document.getProps().children.length} >>`;
+            const pagesObjectNumber = objectManager.addObject(pagesObject);
+            // Now set the given object number all its childs
+            objectManager.setParentObjectNumber(pagesObjectNumber);
+            // The page driver: each logical PageElement may produce SEVERAL physical PDF pages
+            // when its content overflows (Slice 0: whole children reflow to the next page).
+            for (let page of document.getProps().children) {
+                const numbers = yield PDFDocumentRenderer.renderLogicalPage(page, objectManager, ctx);
+                pageNumbers.push(...numbers);
+            }
+            // We must update the pages object with the real physical page numbers and count.
+            const updatedPagesObject = `<< /Type /Pages /Kids [${pageNumbers
+                .map((num) => `${num} 0 R`)
+                .join(" ")}] /Count ${pageNumbers.length} >>`;
+            // Now we must replace it in the object manager
+            objectManager.replaceObject(pagesObjectNumber, updatedPagesObject);
+            return pagesObjectNumber;
+        });
+    }
+    /**
+     * Renders one logical page, paginating it into one or more physical pages.
+     *
+     * Slice 0 only auto-paginates the common shape - a page whose single child is a
+     * fragmentation context (a Container). Anything else renders as a single page on the
+     * unchanged path, so non-overflowing documents stay byte-identical to pre-Slice-0.
+     */
+    static renderLogicalPage(page, objectManager, ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { children, config, header, footer } = page.getProps();
+            if (children.length !== 1 || !(0, fragmentation_1.isFragmentable)(children[0])) {
+                return [yield page_renderer_1.PageRenderer.render(page, objectManager)];
+            }
+            // Header/footer repeat on every physical page, so the body only ever flows into the
+            // band between them. Resolve that band once (config is already merged by pass 1).
+            const pageCtx = { metrics: ctx.metrics, pageConfig: config };
+            const { bodyWidth: width, bodyHeight: height } = (0, page_element_1.layoutPageBands)(config, header, footer, pageCtx);
+            const numbers = [];
+            let region = children[0];
+            let isFirstRegion = true;
+            while (region) {
+                if (!(0, fragmentation_1.isFragmentable)(region)) {
+                    // A non-fragmentable remainder is placed whole on its own page.
+                    numbers.push(yield PDFDocumentRenderer.renderPhysicalPage(config, region, header, footer, objectManager, ctx));
+                    break;
+                }
+                const { fitted, remainder } = region.fragment(height, width, ctx);
+                // Everything fits on one page: render the ORIGINAL page so output is unchanged.
+                // Measuring inside fragment() laid the children out at the origin to size them, so
+                // re-run the page layout first to restore their real positions (deterministic).
+                if (isFirstRegion && remainder === null) {
+                    page.calculateLayout(new box_constraints_1.BoxConstraints(), { x: 0, y: 0 }, ctx);
+                    numbers.push(yield page_renderer_1.PageRenderer.render(page, objectManager));
+                    break;
+                }
+                if (fitted) {
+                    numbers.push(yield PDFDocumentRenderer.renderPhysicalPage(config, fitted, header, footer, objectManager, ctx));
+                }
+                region = remainder;
+                isFirstRegion = false;
+            }
+            return numbers;
+        });
+    }
+    /**
+     * Lays out one fragment on a fresh page of the same geometry and renders it. The
+     * header/footer are attached to every physical page so they repeat; `PageElement`
+     * re-places them and the body in the band between.
+     */
+    static renderPhysicalPage(config, content, header, footer, objectManager, ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const physicalPage = new page_element_1.PageElement({
+                config,
+                header,
+                footer,
+                children: [content],
+            });
+            physicalPage.calculateLayout(new box_constraints_1.BoxConstraints(), { x: 0, y: 0 }, ctx);
+            return page_renderer_1.PageRenderer.render(physicalPage, objectManager);
+        });
+    }
+}
+exports.PDFDocumentRenderer = PDFDocumentRenderer;

package/dist/renderer/pdf-renderer.d.ts

@@ -0,0 +1,5 @@
+import { PDFDocumentElement } from "../elements/pdf-document-element";
+import { PDFObjectManager } from "../utils/pdf-object-manager";
+export declare class PDFRenderer {
+    static render(document: PDFDocumentElement, objectManager: PDFObjectManager): Promise<string>;
+}