@jasy/pdf 1.0.0-alpha.1

package/dist/common/color.d.ts

@@ -0,0 +1,37 @@
+export declare class Color {
+    private r;
+    private g;
+    private b;
+    private alpha;
+    constructor(r: number, g: number, b: number, alpha?: number);
+    /** Opacity in 0..1 (1 = opaque). */
+    getAlpha(): number;
+    /** True when the color is not fully opaque and needs an ExtGState to render. */
+    isTransparent(): boolean;
+    /**
+     * Ensures that the color value is between 0 and 255. If the value is outside of this range,
+     * it is clamped to the nearest valid value (0 or 255), and a warning is logged.
+     *
+     * @param value The color value to be clamped.
+     * @param channel The color channel being adjusted ('r', 'g', or 'b').
+     * @returns The clamped value between 0 and 255.
+     */
+    private clampColorValue;
+    /**
+     * Converts the current color to grayscale based on the perceived luminance of the color.
+     *
+     * The method uses a weighted sum to calculate the grayscale value, accounting for the
+     * human eye's sensitivity to different colors:
+     * - Red (R) contributes 30% to the overall brightness.
+     * - Green (G) contributes 59% to the overall brightness.
+     * - Blue (B) contributes 11% to the overall brightness.
+     *
+     * The resulting grayscale value is applied equally to the red, green, and blue channels,
+     * producing a shade of gray that represents the original color's perceived brightness.
+     *
+     * @returns {string} A PDF compatible color string
+     */
+    toGrayscale(): string;
+    toArray(): [number, number, number];
+    toPDFColorString(): string;
+}

package/dist/common/color.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Color = void 0;
+class Color {
+    constructor(r, g, b, alpha = 1) {
+        this.r = this.clampColorValue(r, "r");
+        this.g = this.clampColorValue(g, "g");
+        this.b = this.clampColorValue(b, "b");
+        this.alpha = Math.max(0, Math.min(1, alpha));
+    }
+    /** Opacity in 0..1 (1 = opaque). */
+    getAlpha() {
+        return this.alpha;
+    }
+    /** True when the color is not fully opaque and needs an ExtGState to render. */
+    isTransparent() {
+        return this.alpha < 1;
+    }
+    /**
+     * Ensures that the color value is between 0 and 255. If the value is outside of this range,
+     * it is clamped to the nearest valid value (0 or 255), and a warning is logged.
+     *
+     * @param value The color value to be clamped.
+     * @param channel The color channel being adjusted ('r', 'g', or 'b').
+     * @returns The clamped value between 0 and 255.
+     */
+    clampColorValue(value, channel) {
+        if (value < 0 || value > 255) {
+            console.warn(`Warning: ${channel} value ${value} is out of range (0-255). Clamping to valid range.`);
+        }
+        return Math.max(0, Math.min(255, value));
+    }
+    /**
+     * Converts the current color to grayscale based on the perceived luminance of the color.
+     *
+     * The method uses a weighted sum to calculate the grayscale value, accounting for the
+     * human eye's sensitivity to different colors:
+     * - Red (R) contributes 30% to the overall brightness.
+     * - Green (G) contributes 59% to the overall brightness.
+     * - Blue (B) contributes 11% to the overall brightness.
+     *
+     * The resulting grayscale value is applied equally to the red, green, and blue channels,
+     * producing a shade of gray that represents the original color's perceived brightness.
+     *
+     * @returns {string} A PDF compatible color string
+     */
+    toGrayscale() {
+        const [r, g, b] = JSON.parse(JSON.stringify(this.toArray())); // JSON because its better to deep clone it here
+        const gray = Math.round(0.3 * r + 0.59 * g + 0.11 * b);
+        return `${(gray / 255).toFixed(3)} ${(gray / 255).toFixed(3)} ${(gray / 255).toFixed(3)}`;
+    }
+    // Returns the color as array `[number, number, number]`
+    toArray() {
+        return [this.r, this.g, this.b];
+    }
+    // Returns a PDF compatible color string
+    toPDFColorString() {
+        const [r, g, b] = this.toArray();
+        return `${(r / 255).toFixed(3)} ${(g / 255).toFixed(3)} ${(b / 255).toFixed(3)}`;
+    }
+}
+exports.Color = Color;

package/dist/constants/page-sizes.d.ts

@@ -0,0 +1,44 @@
+export declare enum PageSize {
+    A0 = "a0",
+    A1 = "a1",
+    A2 = "a2",
+    A3 = "a3",
+    A4 = "a4",
+    A5 = "a5",
+    A6 = "a6",
+    A7 = "a7",
+    A8 = "a8",
+    A9 = "a9",
+    A10 = "a10",
+    B0 = "b0",
+    B1 = "b1",
+    B2 = "b2",
+    B3 = "b3",
+    B4 = "b4",
+    B5 = "b5",
+    B6 = "b6",
+    B7 = "b7",
+    B8 = "b8",
+    B9 = "b9",
+    B10 = "b10",
+    C0 = "c0",
+    C1 = "c1",
+    C2 = "c2",
+    C3 = "c3",
+    C4 = "c4",
+    C5 = "c5",
+    C6 = "c6",
+    C7 = "c7",
+    C8 = "c8",
+    C9 = "c9",
+    C10 = "c10",
+    DL = "dl",
+    LETTER = "letter",
+    GOVERNMENT_LETTER = "government-letter",
+    LEGAL = "legal",
+    JUNIOR_LEGAL = "junior-legal",
+    LEDGER = "ledger",
+    TABLOID = "tabloid",
+    CREDIT_CARD = "credit-card"
+}
+export declare const pageFormats: Record<PageSize, [number, number]>;

package/dist/constants/page-sizes.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pageFormats = exports.PageSize = void 0;
+// Definition of all possible page sizes
+var PageSize;
+(function (PageSize) {
+    PageSize["A0"] = "a0";
+    PageSize["A1"] = "a1";
+    PageSize["A2"] = "a2";
+    PageSize["A3"] = "a3";
+    PageSize["A4"] = "a4";
+    PageSize["A5"] = "a5";
+    PageSize["A6"] = "a6";
+    PageSize["A7"] = "a7";
+    PageSize["A8"] = "a8";
+    PageSize["A9"] = "a9";
+    PageSize["A10"] = "a10";
+    PageSize["B0"] = "b0";
+    PageSize["B1"] = "b1";
+    PageSize["B2"] = "b2";
+    PageSize["B3"] = "b3";
+    PageSize["B4"] = "b4";
+    PageSize["B5"] = "b5";
+    PageSize["B6"] = "b6";
+    PageSize["B7"] = "b7";
+    PageSize["B8"] = "b8";
+    PageSize["B9"] = "b9";
+    PageSize["B10"] = "b10";
+    PageSize["C0"] = "c0";
+    PageSize["C1"] = "c1";
+    PageSize["C2"] = "c2";
+    PageSize["C3"] = "c3";
+    PageSize["C4"] = "c4";
+    PageSize["C5"] = "c5";
+    PageSize["C6"] = "c6";
+    PageSize["C7"] = "c7";
+    PageSize["C8"] = "c8";
+    PageSize["C9"] = "c9";
+    PageSize["C10"] = "c10";
+    PageSize["DL"] = "dl";
+    PageSize["LETTER"] = "letter";
+    PageSize["GOVERNMENT_LETTER"] = "government-letter";
+    PageSize["LEGAL"] = "legal";
+    PageSize["JUNIOR_LEGAL"] = "junior-legal";
+    PageSize["LEDGER"] = "ledger";
+    PageSize["TABLOID"] = "tabloid";
+    PageSize["CREDIT_CARD"] = "credit-card";
+})(PageSize || (exports.PageSize = PageSize = {}));
+// Definition of page formats
+exports.pageFormats = {
+    [PageSize.A0]: [2383.94, 3370.39],
+    [PageSize.A1]: [1683.78, 2383.94],
+    [PageSize.A2]: [1190.55, 1683.78],
+    [PageSize.A3]: [841.89, 1190.55],
+    [PageSize.A4]: [595.28, 841.89],
+    [PageSize.A5]: [419.53, 595.28],
+    [PageSize.A6]: [297.64, 419.53],
+    [PageSize.A7]: [209.76, 297.64],
+    [PageSize.A8]: [147.4, 209.76],
+    [PageSize.A9]: [104.88, 147.4],
+    [PageSize.A10]: [73.7, 104.88],
+    [PageSize.B0]: [2834.65, 4008.19],
+    [PageSize.B1]: [2004.09, 2834.65],
+    [PageSize.B2]: [1417.32, 2004.09],
+    [PageSize.B3]: [1000.63, 1417.32],
+    [PageSize.B4]: [708.66, 1000.63],
+    [PageSize.B5]: [498.9, 708.66],
+    [PageSize.B6]: [354.33, 498.9],
+    [PageSize.B7]: [249.45, 354.33],
+    [PageSize.B8]: [175.75, 249.45],
+    [PageSize.B9]: [124.72, 175.75],
+    [PageSize.B10]: [87.87, 124.72],
+    [PageSize.C0]: [2599.37, 3676.54],
+    [PageSize.C1]: [1836.85, 2599.37],
+    [PageSize.C2]: [1298.27, 1836.85],
+    [PageSize.C3]: [918.43, 1298.27],
+    [PageSize.C4]: [649.13, 918.43],
+    [PageSize.C5]: [459.21, 649.13],
+    [PageSize.C6]: [323.15, 459.21],
+    [PageSize.C7]: [229.61, 323.15],
+    [PageSize.C8]: [161.57, 229.61],
+    [PageSize.C9]: [113.39, 161.57],
+    [PageSize.C10]: [79.37, 113.39],
+    [PageSize.DL]: [311.81, 623.62],
+    [PageSize.LETTER]: [612, 792],
+    [PageSize.GOVERNMENT_LETTER]: [576, 756],
+    [PageSize.LEGAL]: [612, 1008],
+    [PageSize.JUNIOR_LEGAL]: [576, 360],
+    [PageSize.LEDGER]: [1224, 792],
+    [PageSize.TABLOID]: [792, 1224],
+    [PageSize.CREDIT_CARD]: [153, 243],
+};

package/dist/constants/pdf-parts.d.ts

@@ -0,0 +1,5 @@
+export declare const PDF_PARTS: {
+    HEADER: string;
+    TRAILER: (size: number) => string;
+    XREF: string;
+};

package/dist/constants/pdf-parts.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PDF_PARTS = void 0;
+exports.PDF_PARTS = {
+    HEADER: "%PDF-1.3",
+    TRAILER: (size) => `trailer\n<< /Size ${size} >>\nstartxref\n%%EOF`,
+    XREF: "xref", // Placeholder for xref elements
+};

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

@@ -0,0 +1,35 @@
+import { MainAlign, CrossAlign } from "../utils/flex-layout";
+import { BoxConstraints, Offset, Size } from "../layout/box-constraints";
+import { Fragmentable, FragmentResult } from "../layout/fragmentation";
+import { LayoutContext, SizedElement, SizedPDFElement, WithChildren } from "./pdf-element";
+interface ContainerElementParams extends SizedElement, WithChildren {
+    /** Space between children. */
+    gap?: number;
+    /** Vertical distribution of the children (main axis). */
+    main?: MainAlign;
+    /** Horizontal alignment of each child (cross axis); defaults to `stretch`. */
+    cross?: CrossAlign;
+}
+export declare class ContainerElement extends SizedPDFElement implements Fragmentable {
+    private children;
+    private gap;
+    private main;
+    private cross;
+    constructor({ x, y, width, height, children, gap, main, cross }: ContainerElementParams);
+    /**
+     * Splits the vertical stack across pages. Children are measured against the content
+     * width and packed until one would exceed `maxHeight`. That straddling child is itself
+     * fragmented if it can be (Slice 1: a text paragraph splits at line boxes); otherwise
+     * it moves whole. Everything after the break spills into the remainder. Progress is
+     * guaranteed: if nothing fit on the page, the straddling child is forced on (it
+     * overflows) so the next region always makes headway.
+     *
+     * Flex children make the container absorb the leftover space, so it never overflows -
+     * in that case we don't fragment and hand the whole container back as `fitted`.
+     */
+    fragment(maxHeight: number, width: number, ctx: LayoutContext): FragmentResult;
+    private cloneWithChildren;
+    calculateLayout(constraints: BoxConstraints, offset: Offset, ctx: LayoutContext): Size;
+    getProps(): ContainerElementParams;
+}
+export {};

package/dist/elements/container-element.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerElement = void 0;
+const flex_layout_1 = require("../utils/flex-layout");
+const fragmentation_1 = require("../layout/fragmentation");
+const pdf_element_1 = require("./pdf-element");
+class ContainerElement extends pdf_element_1.SizedPDFElement {
+    constructor({ x, y, width, height, children, gap, main, cross }) {
+        super({ x, y, width, height });
+        this.children = children;
+        this.gap = gap !== null && gap !== void 0 ? gap : 0;
+        this.main = main !== null && main !== void 0 ? main : "start";
+        this.cross = cross !== null && cross !== void 0 ? cross : "stretch";
+    }
+    /**
+     * Splits the vertical stack across pages. Children are measured against the content
+     * width and packed until one would exceed `maxHeight`. That straddling child is itself
+     * fragmented if it can be (Slice 1: a text paragraph splits at line boxes); otherwise
+     * it moves whole. Everything after the break spills into the remainder. Progress is
+     * guaranteed: if nothing fit on the page, the straddling child is forced on (it
+     * overflows) so the next region always makes headway.
+     *
+     * Flex children make the container absorb the leftover space, so it never overflows -
+     * in that case we don't fragment and hand the whole container back as `fitted`.
+     */
+    fragment(maxHeight, width, ctx) {
+        const { fitted, remainder } = (0, fragmentation_1.packChildren)(this.children, maxHeight, width, ctx, this.gap);
+        // Fits as one region: hand the whole container back so the page renders unchanged
+        // (its normal layout distributes flex / fills the page).
+        if (remainder.length === 0)
+            return { fitted: this, remainder: null };
+        return {
+            fitted: this.cloneWithChildren(fitted),
+            remainder: this.cloneWithChildren(remainder),
+        };
+    }
+    cloneWithChildren(children) {
+        return new ContainerElement({
+            x: this.x,
+            y: this.y,
+            width: this.width,
+            height: this.height,
+            children,
+            gap: this.gap,
+            main: this.main,
+            cross: this.cross,
+        });
+    }
+    calculateLayout(constraints, offset, ctx) {
+        // The container fills the width/height it is offered; when an axis is unbounded it
+        // shrink-wraps to its children instead (mirrors how Row shrink-wraps). Width unbounded
+        // happens for a Column nested in a Row (the Row offers its fixed children unbounded
+        // width); passing 0 there would collapse every child to width 0.
+        if (constraints.hasBoundedWidth)
+            this.width = constraints.maxWidth;
+        if (constraints.hasBoundedHeight)
+            this.height = constraints.maxHeight;
+        this.x = offset.x;
+        this.y = offset.y;
+        const crossAvail = constraints.hasBoundedWidth ? this.width : Infinity;
+        const mainAvail = constraints.hasBoundedHeight ? this.height : Infinity;
+        let result = { mainUsed: 0, crossUsed: 0 };
+        if (this.children) {
+            // Vertical flex stack (main = height, cross = width). The shared helper measures
+            // fixed children, distributes the leftover to flex children, and places everything
+            // in source order.
+            result = flex_layout_1.FlexLayoutHelper.layout(this.children, flex_layout_1.VERTICAL_AXIS, mainAvail, crossAvail, this.y, this.x, { gap: this.gap, main: this.main, cross: this.cross }, ctx);
+        }
+        // Bounded: fill the offered extent. Unbounded: shrink to the children (height = the
+        // stack, width = the widest child). Top-left coordinates; the container draws nothing,
+        // and the Y-flip happens once at the IR -> backend seam.
+        const width = constraints.hasBoundedWidth ? this.width : result.crossUsed;
+        const height = constraints.hasBoundedHeight ? this.height : result.mainUsed;
+        this.width = width;
+        this.height = height;
+        return { width, height };
+    }
+    getProps() {
+        return {
+            x: this.x,
+            y: this.y,
+            width: this.width,
+            height: this.height,
+            children: this.children,
+            gap: this.gap,
+            main: this.main,
+            cross: this.cross,
+        };
+    }
+}
+exports.ContainerElement = ContainerElement;

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

@@ -0,0 +1,56 @@
+import { BoxConstraints, Offset, Size } from "../layout/box-constraints";
+import { LayoutContext, SizedPDFElement } from "./pdf-element";
+export declare enum BoxFit {
+    none = "NONE",
+    contain = "CONTAIN",
+    cover = "COVER",
+    fill = "FILL"
+}
+export declare abstract class CustomImage {
+    abstract init(): void | Promise<void>;
+    abstract getImageType(): string | Promise<string>;
+    abstract getFileData(): string | Promise<string>;
+    abstract getImageDimensions(): Promise<{
+        width: number;
+        height: number;
+    }>;
+}
+export declare class CustomLocalImage extends CustomImage {
+    private imagePath;
+    private fileBuffer;
+    private fileRawData;
+    constructor(imagePath: string);
+    init(): Promise<void>;
+    getImageType(): Promise<string>;
+    private loadImage;
+    getFileData(): string;
+    getImageDimensions(): Promise<{
+        width: number;
+        height: number;
+    }>;
+}
+interface ImageElementParams {
+    image: CustomImage;
+    width?: number;
+    height?: number;
+    fit?: BoxFit;
+    /** Corner radius in points; rounds the image box (0 = sharp, default). */
+    radius?: number;
+}
+export declare class ImageElement extends SizedPDFElement {
+    private image;
+    private fit;
+    private radius;
+    constructor({ image, width, height, fit, radius }: ImageElementParams);
+    calculateLayout(constraints: BoxConstraints, offset: Offset, _ctx: LayoutContext): Size;
+    getProps(): {
+        x: number;
+        y: number;
+        width: number | undefined;
+        height: number | undefined;
+        image: CustomImage;
+        fit: BoxFit;
+        radius: number;
+    };
+}
+export {};

package/dist/elements/image-element.js

@@ -0,0 +1,151 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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.ImageElement = exports.CustomLocalImage = exports.CustomImage = exports.BoxFit = void 0;
+const image_helper_1 = require("../utils/image-helper");
+const pdf_element_1 = require("./pdf-element");
+var BoxFit;
+(function (BoxFit) {
+    BoxFit["none"] = "NONE";
+    BoxFit["contain"] = "CONTAIN";
+    BoxFit["cover"] = "COVER";
+    BoxFit["fill"] = "FILL";
+})(BoxFit || (exports.BoxFit = BoxFit = {}));
+class CustomImage {
+}
+exports.CustomImage = CustomImage;
+class CustomLocalImage extends CustomImage {
+    constructor(imagePath) {
+        super();
+        this.imagePath = imagePath;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Loading image and convert it to base64
+                yield this.loadImage(this.imagePath);
+            }
+            catch (error) {
+                console.error("Error loading image:", error);
+            }
+        });
+    }
+    getImageType() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const path = yield Promise.resolve().then(() => __importStar(require("path"))); // Dynamic import
+            const ext = path.extname(this.imagePath).toLowerCase();
+            switch (ext) {
+                case ".jpg":
+                case ".jpeg":
+                    return "DCTDecode"; // For JPEG
+                case ".png":
+                    return "FlateDecode"; // For PNG
+                case ".bmp":
+                    throw new Error("BMP is not directly supported. Please convert to PNG or JPEG.");
+                case ".webp":
+                    throw new Error("WebP is not directly supported. Please convert to PNG or JPEG.");
+                default:
+                    throw new Error(`Unsupported image format: ${ext}`);
+            }
+        });
+    }
+    loadImage(imagePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fs = yield Promise.resolve().then(() => __importStar(require("fs/promises"))); // Dynamic import
+            const result = yield fs.readFile(imagePath);
+            //const result = await convertImageToGrayscaleBuffer(imagePath);
+            this.fileBuffer = result;
+            this.fileRawData = result.toString("binary");
+            return result;
+        });
+    }
+    getFileData() {
+        return this.fileRawData;
+    }
+    getImageDimensions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.fileBuffer) {
+                throw new Error("You must first call the `loadAndConvertImage` method");
+            }
+            // Since now (30.09.2024) we using "Jimp" - So we don't need our custom method to get the image dimension.
+            // But at the moment I let it still here...
+            const dimensions = yield (0, image_helper_1.getImageDimensions)(this.fileBuffer);
+            return dimensions;
+        });
+    }
+}
+exports.CustomLocalImage = CustomLocalImage;
+class ImageElement extends pdf_element_1.SizedPDFElement {
+    constructor({ image, width, height, fit = BoxFit.none, radius }) {
+        super({ x: 0, y: 0, width });
+        this.image = image;
+        this.height = height;
+        this.fit = fit;
+        this.radius = radius !== null && radius !== void 0 ? radius : 0;
+    }
+    calculateLayout(constraints, offset, _ctx) {
+        var _a, _b;
+        this.x = offset.x;
+        this.y = offset.y;
+        // A bounded axis overrides the intrinsic/explicit size; otherwise keep our own.
+        if (constraints.hasBoundedWidth)
+            this.width = constraints.maxWidth;
+        if (constraints.hasBoundedHeight)
+            this.height = constraints.maxHeight;
+        // Top-left coordinates; the fit logic (renderer) and the Y-flip (seam) run later.
+        return { width: (_a = this.width) !== null && _a !== void 0 ? _a : 0, height: (_b = this.height) !== null && _b !== void 0 ? _b : 0 };
+    }
+    getProps() {
+        return {
+            x: this.x,
+            y: this.y,
+            width: this.width,
+            height: this.height,
+            image: this.image,
+            fit: this.fit,
+            radius: this.radius,
+        };
+    }
+}
+exports.ImageElement = ImageElement;

package/dist/elements/index.d.ts

@@ -0,0 +1,10 @@
+export { PDFElement } from "./pdf-element";
+export * from "./text-element";
+export * from "./pdf-document-element";
+export * from "./page-element";
+export * from "./rectangle-element";
+export * from "./image-element";
+export * from "./layout/expanded-element";
+export * from "./layout/padding-element";
+export * from "./line-element";
+export * from "./row-element";

package/dist/elements/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PDFElement = void 0;
+var pdf_element_1 = require("./pdf-element"); // the base element type - public for composing custom layouts
+Object.defineProperty(exports, "PDFElement", { enumerable: true, get: function () { return pdf_element_1.PDFElement; } });
+__exportStar(require("./text-element"), exports);
+__exportStar(require("./pdf-document-element"), exports);
+__exportStar(require("./page-element"), exports);
+__exportStar(require("./rectangle-element"), exports);
+__exportStar(require("./image-element"), exports);
+__exportStar(require("./layout/expanded-element"), exports);
+__exportStar(require("./layout/padding-element"), exports);
+__exportStar(require("./line-element"), exports);
+__exportStar(require("./row-element"), exports);

package/dist/elements/layout/deferred-element.d.ts

@@ -0,0 +1,19 @@
+import { BoxConstraints, Offset, Size } from "../../layout/box-constraints";
+import { Fragmentable, FragmentResult } from "../../layout/fragmentation";
+import { LayoutContext, PDFElement } from "../pdf-element";
+/**
+ * Builds its subtree at layout time via `resolve(ctx)`, so the tree can depend on font
+ * metrics (e.g. a Table resolving `"auto"` column widths from cell content). The engine
+ * stays table-agnostic - the closure comes from the API layer.
+ */
+export declare class DeferredElement extends PDFElement implements Fragmentable {
+    private resolve;
+    private composed?;
+    constructor(resolve: (ctx: LayoutContext) => PDFElement);
+    private build;
+    calculateLayout(constraints: BoxConstraints, offset: Offset, ctx: LayoutContext): Size;
+    fragment(maxHeight: number, width: number, ctx: LayoutContext): FragmentResult;
+    getProps(): {
+        composed: PDFElement | undefined;
+    };
+}