@jasy/pdf 1.0.0-alpha.1

package/dist/elements/layout/deferred-element.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeferredElement = void 0;
+const fragmentation_1 = require("../../layout/fragmentation");
+const pdf_element_1 = require("../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.
+ */
+class DeferredElement extends pdf_element_1.PDFElement {
+    constructor(resolve) {
+        super();
+        this.resolve = resolve;
+    }
+    build(ctx) {
+        this.composed = this.resolve(ctx);
+        return this.composed;
+    }
+    calculateLayout(constraints, offset, ctx) {
+        return this.build(ctx).calculateLayout(constraints, offset, ctx);
+    }
+    fragment(maxHeight, width, ctx) {
+        const c = this.build(ctx);
+        return (0, fragmentation_1.isFragmentable)(c)
+            ? c.fragment(maxHeight, width, ctx)
+            : { fitted: this, remainder: null };
+    }
+    getProps() {
+        return { composed: this.composed };
+    }
+}
+exports.DeferredElement = DeferredElement;

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

@@ -0,0 +1,30 @@
+import { PDFElement, LayoutContext, FlexiblePDFElement, WithChild, FlexibleElement } from "../pdf-element";
+import { BoxConstraints, Offset, Size } from "../../layout/box-constraints";
+import { Fragmentable, FragmentResult } from "../../layout/fragmentation";
+interface ExpandedElementParams extends FlexibleElement, WithChild {
+}
+export declare class ExpandedElement extends FlexiblePDFElement implements Fragmentable {
+    private child;
+    private x;
+    private y;
+    private width;
+    private height;
+    constructor({ flex, child }: ExpandedElementParams);
+    calculateLayout(constraints: BoxConstraints, offset: Offset, ctx: LayoutContext): Size;
+    /**
+     * When the column paginates, a flex region can't "fill" across pages, so it delegates to
+     * its child: the child splits and each half is re-wrapped in an Expanded (which then
+     * fills the leftover space on whichever page it lands). If the child can't split, the
+     * whole Expanded moves on.
+     */
+    fragment(maxHeight: number, width: number, ctx: LayoutContext): FragmentResult;
+    private cloneWithChild;
+    getProps(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        child: PDFElement;
+    };
+}
+export {};

package/dist/elements/layout/expanded-element.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpandedElement = void 0;
+const element_validator_1 = require("../../validators/element-validator");
+const pdf_element_1 = require("../pdf-element");
+const box_constraints_1 = require("../../layout/box-constraints");
+const fragmentation_1 = require("../../layout/fragmentation");
+class ExpandedElement extends pdf_element_1.FlexiblePDFElement {
+    constructor({ flex, child }) {
+        super({ flex });
+        this.x = 0;
+        this.y = 0;
+        this.width = 0;
+        this.height = 0;
+        this.child = child;
+    }
+    calculateLayout(constraints, offset, ctx) {
+        if (constraints.hasBoundedWidth)
+            this.width = constraints.maxWidth;
+        // Absolute placement from the parent; assignment (not +=) so re-layout is idempotent.
+        this.x = offset.x;
+        this.y = offset.y;
+        element_validator_1.Validator.validateFlexElement(this);
+        if (constraints.hasBoundedHeight) {
+            // A bounded region: fill it - the normal flex behaviour.
+            this.height = constraints.maxHeight;
+            this.child.calculateLayout(box_constraints_1.BoxConstraints.loose(this.width, this.height), { x: this.x, y: this.y }, ctx);
+        }
+        else {
+            // Unbounded (measuring while paginating): there's no leftover space to fill, so
+            // collapse to the child's natural height. This lets an overflowing column flow
+            // instead of the flex silently hiding the overflow.
+            const childSize = this.child.calculateLayout(box_constraints_1.BoxConstraints.loose(this.width, Infinity), { x: this.x, y: this.y }, ctx);
+            this.height = childSize.height;
+        }
+        // Top-left coordinates; the Y-flip now happens once at the IR -> backend seam.
+        return { width: this.width, height: this.height };
+    }
+    /**
+     * When the column paginates, a flex region can't "fill" across pages, so it delegates to
+     * its child: the child splits and each half is re-wrapped in an Expanded (which then
+     * fills the leftover space on whichever page it lands). If the child can't split, the
+     * whole Expanded moves on.
+     */
+    fragment(maxHeight, width, ctx) {
+        if (!(0, fragmentation_1.isFragmentable)(this.child)) {
+            return { fitted: null, remainder: this };
+        }
+        const split = this.child.fragment(maxHeight, width, ctx);
+        return {
+            fitted: split.fitted ? this.cloneWithChild(split.fitted) : null,
+            remainder: split.remainder ? this.cloneWithChild(split.remainder) : null,
+        };
+    }
+    cloneWithChild(child) {
+        return new ExpandedElement({ flex: this.flex, child });
+    }
+    getProps() {
+        return {
+            x: this.x,
+            y: this.y,
+            width: this.width,
+            height: this.height,
+            child: this.child,
+        };
+    }
+}
+exports.ExpandedElement = ExpandedElement;

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

@@ -0,0 +1,29 @@
+import { PDFElement, LayoutContext, WithChild, SizedPDFElement } from "../pdf-element";
+import { BoxConstraints, Offset, Size } from "../../layout/box-constraints";
+import { Fragmentable, FragmentResult } from "../../layout/fragmentation";
+interface PaddingElementParams extends WithChild {
+    margin: [number, number, number, number];
+}
+export declare class PaddingElement extends SizedPDFElement implements Fragmentable {
+    private child;
+    private margin;
+    constructor({ margin, child }: PaddingElementParams);
+    /**
+     * Splits the padded box across pages (box-decoration-break: clone - every fragment
+     * keeps its full top/bottom inset). The child is fragmented into the space left after
+     * reserving the vertical insets; each half is re-wrapped in its own padding. If the
+     * child can't be split, the whole padding moves on as the remainder.
+     */
+    fragment(maxHeight: number, width: number, ctx: LayoutContext): FragmentResult;
+    private cloneWithChild;
+    calculateLayout(constraints: BoxConstraints, offset: Offset, ctx: LayoutContext): Size;
+    getProps(): {
+        x: number;
+        y: number;
+        width: number | undefined;
+        height: number | undefined;
+        margin: [number, number, number, number];
+        child: PDFElement;
+    };
+}
+export {};

package/dist/elements/layout/padding-element.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaddingElement = void 0;
+const element_validator_1 = require("../../validators/element-validator");
+const pdf_element_1 = require("../pdf-element");
+const box_constraints_1 = require("../../layout/box-constraints");
+const fragmentation_1 = require("../../layout/fragmentation");
+class PaddingElement extends pdf_element_1.SizedPDFElement {
+    constructor({ margin, child }) {
+        super({ x: 0, y: 0 });
+        this.child = child;
+        this.margin = margin;
+    }
+    /**
+     * Splits the padded box across pages (box-decoration-break: clone - every fragment
+     * keeps its full top/bottom inset). The child is fragmented into the space left after
+     * reserving the vertical insets; each half is re-wrapped in its own padding. If the
+     * child can't be split, the whole padding moves on as the remainder.
+     */
+    fragment(maxHeight, width, ctx) {
+        if (!(0, fragmentation_1.isFragmentable)(this.child)) {
+            return { fitted: null, remainder: this };
+        }
+        const [marginTop, marginRight, marginBottom, marginLeft] = this.margin;
+        const childWidth = width - marginLeft - marginRight;
+        const childMaxHeight = maxHeight - marginTop - marginBottom;
+        const split = this.child.fragment(childMaxHeight, childWidth, ctx);
+        return {
+            fitted: split.fitted ? this.cloneWithChild(split.fitted) : null,
+            remainder: split.remainder ? this.cloneWithChild(split.remainder) : null,
+        };
+    }
+    cloneWithChild(child) {
+        return new PaddingElement({ margin: this.margin, child });
+    }
+    calculateLayout(constraints, offset, ctx) {
+        var _a;
+        // Padding takes the width it is offered; its height shrink-wraps the child.
+        if (constraints.hasBoundedWidth)
+            this.width = constraints.maxWidth;
+        this.x = offset.x;
+        this.y = offset.y;
+        const [marginTop, marginRight, marginBottom, marginLeft] = this.margin;
+        // The child is inset by the margins: shifted down/right, narrowed by the
+        // horizontal margins, and left height-unbounded so it sizes to its own content.
+        const childOffset = {
+            x: this.x + marginLeft,
+            y: this.y + marginTop,
+        };
+        const childWidth = constraints.hasBoundedWidth
+            ? Math.max(0, constraints.maxWidth - marginLeft - marginRight)
+            : Infinity;
+        const childConstraints = box_constraints_1.BoxConstraints.loose(childWidth, Infinity);
+        const childSize = this.child.calculateLayout(childConstraints, childOffset, ctx);
+        this.height = childSize.height + marginTop + marginBottom;
+        // Unbounded width (e.g. a fixed child in a Row): shrink-wrap to the child + insets,
+        // mirroring how Container/Row shrink-wrap. Bounded width was set above (unchanged).
+        if (!constraints.hasBoundedWidth) {
+            this.width = childSize.width + marginLeft + marginRight;
+        }
+        element_validator_1.Validator.validateSizedElement(this);
+        // Top-left coordinates; the Y-flip now happens once at the IR -> backend seam.
+        return { width: (_a = this.width) !== null && _a !== void 0 ? _a : 0, height: this.height };
+    }
+    getProps() {
+        return {
+            x: this.x,
+            y: this.y,
+            width: this.width,
+            height: this.height,
+            margin: this.margin,
+            child: this.child,
+        };
+    }
+}
+exports.PaddingElement = PaddingElement;

package/dist/elements/layout/repeating-header-element.d.ts

@@ -0,0 +1,29 @@
+import { BoxConstraints, Offset, Size } from "../../layout/box-constraints";
+import { Fragmentable, FragmentResult } from "../../layout/fragmentation";
+import { LayoutContext, PDFElement } from "../pdf-element";
+/**
+ * Stacks a `header` above a `body` and, when it paginates, **repeats the header on every
+ * fragment**. Used by `Table` so column headings reappear at the top of each page. Layout
+ * is just header-then-body (like a 2-row Column); the magic is in `fragment`: it splits the
+ * body and re-wraps each piece with the same header, so every physical page gets its own.
+ */
+export declare class RepeatingHeaderElement extends PDFElement implements Fragmentable {
+    private header;
+    private body;
+    private gap;
+    private x;
+    private y;
+    private width;
+    private height;
+    constructor(header: PDFElement, body: PDFElement, gap?: number);
+    calculateLayout(constraints: BoxConstraints, offset: Offset, ctx: LayoutContext): Size;
+    fragment(maxHeight: number, width: number, ctx: LayoutContext): FragmentResult;
+    getProps(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        header: PDFElement;
+        body: PDFElement;
+    };
+}

package/dist/elements/layout/repeating-header-element.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepeatingHeaderElement = void 0;
+const box_constraints_1 = require("../../layout/box-constraints");
+const fragmentation_1 = require("../../layout/fragmentation");
+const pdf_element_1 = require("../pdf-element");
+/**
+ * Stacks a `header` above a `body` and, when it paginates, **repeats the header on every
+ * fragment**. Used by `Table` so column headings reappear at the top of each page. Layout
+ * is just header-then-body (like a 2-row Column); the magic is in `fragment`: it splits the
+ * body and re-wraps each piece with the same header, so every physical page gets its own.
+ */
+class RepeatingHeaderElement extends pdf_element_1.PDFElement {
+    constructor(header, body, gap = 0) {
+        super();
+        this.header = header;
+        this.body = body;
+        this.gap = gap;
+        this.x = 0;
+        this.y = 0;
+        this.width = 0;
+        this.height = 0;
+    }
+    calculateLayout(constraints, offset, ctx) {
+        this.x = offset.x;
+        this.y = offset.y;
+        const width = constraints.hasBoundedWidth ? constraints.maxWidth : 0;
+        const h = this.header.calculateLayout(box_constraints_1.BoxConstraints.loose(width, Infinity), { x: this.x, y: this.y }, ctx);
+        const b = this.body.calculateLayout(box_constraints_1.BoxConstraints.loose(width, Infinity), { x: this.x, y: this.y + h.height + this.gap }, ctx);
+        this.width = width;
+        this.height = h.height + this.gap + b.height;
+        return { width: this.width, height: this.height };
+    }
+    fragment(maxHeight, width, ctx) {
+        // Reserve the header's height on every page; the body flows in what's left.
+        const headerHeight = this.header.calculateLayout(box_constraints_1.BoxConstraints.loose(width, Infinity), { x: 0, y: 0 }, ctx).height;
+        if (!(0, fragmentation_1.isFragmentable)(this.body))
+            return { fitted: this, remainder: null };
+        const split = this.body.fragment(Math.max(0, maxHeight - headerHeight - this.gap), width, ctx);
+        // Body fits whole → the whole thing fits on this page.
+        if (split.remainder === null)
+            return { fitted: this, remainder: null };
+        // Re-wrap each body piece with the SAME header → it reappears on the next page too.
+        return {
+            fitted: split.fitted ? new RepeatingHeaderElement(this.header, split.fitted, this.gap) : null,
+            remainder: new RepeatingHeaderElement(this.header, split.remainder, this.gap),
+        };
+    }
+    getProps() {
+        return {
+            x: this.x,
+            y: this.y,
+            width: this.width,
+            height: this.height,
+            header: this.header,
+            body: this.body,
+        };
+    }
+}
+exports.RepeatingHeaderElement = RepeatingHeaderElement;

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

@@ -0,0 +1,14 @@
+import { SizedElement, WithChildren, SizedPDFElement, LayoutContext } from "../pdf-element";
+import { BoxConstraints, Offset, Size } from "../../layout/box-constraints";
+interface ContainerElementParams extends SizedElement, WithChildren {
+    color?: [number, number, number];
+    backgroundColor?: [number, number, number];
+    borderWidth?: number;
+}
+export declare class SizedContainerElement extends SizedPDFElement {
+    private children;
+    constructor({ width, height, children }: ContainerElementParams);
+    calculateLayout(constraints: BoxConstraints, offset: Offset, ctx: LayoutContext): Size;
+    getProps(): ContainerElementParams;
+}
+export {};

package/dist/elements/layout/sized-container-element.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SizedContainerElement = void 0;
+const pdf_element_1 = require("../pdf-element");
+const box_constraints_1 = require("../../layout/box-constraints");
+class SizedContainerElement extends pdf_element_1.SizedPDFElement {
+    constructor({ width, height, children }) {
+        super({ x: 0, y: 0, width, height });
+        this.children = children;
+    }
+    calculateLayout(constraints, offset, ctx) {
+        var _a, _b;
+        if (constraints.hasBoundedWidth)
+            this.width = constraints.maxWidth;
+        if (constraints.hasBoundedHeight)
+            this.height = constraints.maxHeight;
+        // Absolute placement from the parent; assignment (not +=) so re-layout is idempotent.
+        this.x = offset.x;
+        this.y = offset.y;
+        const width = (_a = this.width) !== null && _a !== void 0 ? _a : 0;
+        const height = (_b = this.height) !== null && _b !== void 0 ? _b : 0;
+        if (this.children)
+            this.children.forEach((child) => child.calculateLayout(box_constraints_1.BoxConstraints.loose(width, height), { x: this.x, y: this.y }, ctx));
+        // Top-left coordinates; the Y-flip now happens once at the IR -> backend seam.
+        return { width, height };
+    }
+    getProps() {
+        return {
+            x: this.x,
+            y: this.y,
+            width: this.width,
+            height: this.height,
+            children: this.children,
+        };
+    }
+}
+exports.SizedContainerElement = SizedContainerElement;

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

@@ -0,0 +1,31 @@
+import { Color } from "../common/color";
+import { BoxConstraints, Offset, Size } from "../layout/box-constraints";
+import { LayoutContext, SizedElement, SizedPDFElement } from "./pdf-element";
+interface LineElementParams extends SizedElement {
+    color?: Color;
+    strokeWidth?: number;
+    x: number;
+    y: number;
+    xEnd: number;
+    yEnd: number;
+}
+export declare class LineElement extends SizedPDFElement {
+    private color?;
+    private strokeWidth?;
+    private xEnd;
+    private yEnd;
+    private sizeMemory;
+    constructor({ color, strokeWidth, x, y, xEnd, yEnd }: LineElementParams);
+    calculateLayout(constraints: BoxConstraints, offset: Offset, _ctx: LayoutContext): Size;
+    getProps(): {
+        x: number;
+        y: number;
+        xEnd: number;
+        yEnd: number;
+        height: number | undefined;
+        width: number | undefined;
+        color: Color | undefined;
+        strokeWidth: number | undefined;
+    };
+}
+export {};

package/dist/elements/line-element.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LineElement = void 0;
+const color_1 = require("../common/color");
+const pdf_element_1 = require("./pdf-element");
+class LineElement extends pdf_element_1.SizedPDFElement {
+    constructor({ color = new color_1.Color(0, 0, 0), strokeWidth, x, y, xEnd, yEnd }) {
+        super({ x: x, y: y, width: xEnd, height: y + yEnd });
+        this.color = color;
+        this.strokeWidth = strokeWidth ? strokeWidth : 1;
+        this.x = x;
+        this.y = y;
+        this.xEnd = xEnd;
+        this.yEnd = yEnd;
+        this.sizeMemory = { x, y, width: xEnd, height: yEnd };
+    }
+    calculateLayout(constraints, offset, _ctx) {
+        var _a, _b;
+        // Set relative to parent
+        this.x = this.sizeMemory.x + offset.x;
+        this.y = this.sizeMemory.y + offset.y;
+        // The line spans the parent's width, so it needs a bounded width to anchor its end.
+        if (!constraints.hasBoundedWidth) {
+            throw new Error("The LineElement must be placed inside a parent container that defines its width");
+        }
+        this.xEnd = offset.x + constraints.maxWidth - this.sizeMemory.width;
+        this.yEnd = offset.y + this.sizeMemory.height;
+        // Top-left coordinates; the Y-flip happens once at the IR -> backend seam.
+        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,
+            xEnd: this.xEnd,
+            yEnd: this.yEnd,
+            height: this.height,
+            width: this.width,
+            color: this.color,
+            strokeWidth: this.strokeWidth,
+        };
+    }
+}
+exports.LineElement = LineElement;

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

@@ -0,0 +1,58 @@
+import { PageSize } from "../constants/page-sizes";
+import { Orientation } from "../renderer/pdf-config";
+import type { ColorMode, DefaultFont, Margin } from "../renderer";
+import { BoxConstraints, Offset, Size } from "../layout/box-constraints";
+import { LayoutContext, PDFElement, WithChildren } from "./pdf-element";
+import { TextElement } from "./text-element";
+export interface PDFPageConfig {
+    pageSize?: PageSize;
+    orientation?: Orientation;
+    margin?: Margin;
+    colorMode?: ColorMode;
+    defaultFont?: DefaultFont;
+}
+interface PDFPageParams extends WithChildren {
+    config?: PDFPageConfig;
+    /** Laid out at the TOP of the content box, repeated on every physical page. */
+    header?: PDFElement;
+    /** Laid out at the BOTTOM of the content box, repeated on every physical page. */
+    footer?: PDFElement;
+}
+/**
+ * The content box of a page (inside the margins, orientation applied) for a fully
+ * resolved config. Single source of truth, shared by `PageElement` layout and the page
+ * driver so they can never drift.
+ */
+export declare function resolvePageContentBox(config: PDFPageConfig): {
+    origin: Offset;
+    width: number;
+    height: number;
+};
+/** The body region of a page once the (optional) header/footer bands are subtracted. */
+export interface PageBands {
+    bodyOrigin: Offset;
+    bodyWidth: number;
+    bodyHeight: number;
+    headerHeight: number;
+    footerHeight: number;
+}
+/**
+ * Lays out the header (top) and footer (bottom) of a page and returns the body band left
+ * in between. Header/footer take their natural height against the content width; the body
+ * gets `contentHeight - headerHeight - footerHeight`. Shared by `PageElement.calculateLayout`
+ * (placement) and the page driver (so its fragmentation `maxHeight` matches exactly). With
+ * no header/footer the bands are zero and the body equals the full content box - identical
+ * to a page without them.
+ */
+export declare function layoutPageBands(config: PDFPageConfig, header: PDFElement | undefined, footer: PDFElement | undefined, ctx: LayoutContext): PageBands;
+export declare class PageElement extends PDFElement {
+    private config;
+    private children;
+    private header?;
+    private footer?;
+    constructor({ children, config, header, footer }: PDFPageParams);
+    calculateLayout(_constraints: BoxConstraints, _offset: Offset, ctx: LayoutContext): Size;
+    getProps(): PDFPageParams;
+    addTextElement(element: TextElement): this;
+}
+export {};

package/dist/elements/page-element.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageElement = void 0;
+exports.resolvePageContentBox = resolvePageContentBox;
+exports.layoutPageBands = layoutPageBands;
+const page_sizes_1 = require("../constants/page-sizes");
+const pdf_config_1 = require("../renderer/pdf-config");
+const box_constraints_1 = require("../layout/box-constraints");
+const pdf_element_1 = require("./pdf-element");
+/**
+ * The content box of a page (inside the margins, orientation applied) for a fully
+ * resolved config. Single source of truth, shared by `PageElement` layout and the page
+ * driver so they can never drift.
+ */
+function resolvePageContentBox(config) {
+    const margin = config.margin;
+    let width = page_sizes_1.pageFormats[config.pageSize][0] - margin.left - margin.right;
+    let height = page_sizes_1.pageFormats[config.pageSize][1] - margin.top - margin.bottom;
+    if (config.orientation === pdf_config_1.Orientation.landscape) {
+        [width, height] = [height, width];
+    }
+    return { origin: { x: margin.left, y: margin.top }, width, height };
+}
+/**
+ * Lays out the header (top) and footer (bottom) of a page and returns the body band left
+ * in between. Header/footer take their natural height against the content width; the body
+ * gets `contentHeight - headerHeight - footerHeight`. Shared by `PageElement.calculateLayout`
+ * (placement) and the page driver (so its fragmentation `maxHeight` matches exactly). With
+ * no header/footer the bands are zero and the body equals the full content box - identical
+ * to a page without them.
+ */
+function layoutPageBands(config, header, footer, ctx) {
+    const { origin, width, height } = resolvePageContentBox(config);
+    let headerHeight = 0;
+    if (header) {
+        headerHeight = header.calculateLayout(box_constraints_1.BoxConstraints.loose(width, Infinity), origin, ctx).height;
+    }
+    let footerHeight = 0;
+    if (footer) {
+        // Measure first to learn its height, then place it flush against the bottom edge.
+        footerHeight = footer.calculateLayout(box_constraints_1.BoxConstraints.loose(width, Infinity), origin, ctx).height;
+        footer.calculateLayout(box_constraints_1.BoxConstraints.loose(width, Infinity), { x: origin.x, y: origin.y + height - footerHeight }, ctx);
+    }
+    return {
+        bodyOrigin: { x: origin.x, y: origin.y + headerHeight },
+        bodyWidth: width,
+        bodyHeight: Math.max(0, height - headerHeight - footerHeight),
+        headerHeight,
+        footerHeight,
+    };
+}
+class PageElement extends pdf_element_1.PDFElement {
+    constructor({ children, config, header, footer }) {
+        super();
+        this.children = children;
+        this.config = config !== null && config !== void 0 ? config : {};
+        this.header = header;
+        this.footer = footer;
+    }
+    calculateLayout(_constraints, _offset, ctx) {
+        // Merge the document defaults (carried in the context) with this page's overrides,
+        // then hand descendants a context bound to THIS page's geometry. This is what
+        // fixes the old last-page-wins global page-config bug.
+        this.config = Object.assign(Object.assign({}, ctx.pageConfig), this.config);
+        const pageCtx = {
+            metrics: ctx.metrics,
+            pageConfig: this.config,
+        };
+        // Place the header/footer bands; the body gets the region left in between (the whole
+        // content box when there is neither - byte-identical to a plain page).
+        const bands = layoutPageBands(this.config, this.header, this.footer, pageCtx);
+        const childConstraints = box_constraints_1.BoxConstraints.loose(bands.bodyWidth, bands.bodyHeight);
+        this.children.forEach((child) => child.calculateLayout(childConstraints, bands.bodyOrigin, pageCtx));
+        const { width, height } = resolvePageContentBox(this.config);
+        return { width, height };
+    }
+    getProps() {
+        return {
+            children: this.children,
+            config: this.config,
+            header: this.header,
+            footer: this.footer,
+        };
+    }
+    addTextElement(element) {
+        this.children.push(element);
+        return this;
+    }
+}
+exports.PageElement = PageElement;

package/dist/elements/pdf-document-element.d.ts

@@ -0,0 +1,13 @@
+import { PageElement } from "./page-element";
+import { BoxConstraints, Offset, Size } from "../layout/box-constraints";
+import { LayoutContext, PDFElement, WithChildren } from "./pdf-element";
+interface PDFDocumentParams extends WithChildren {
+    children: PageElement[];
+}
+export declare class PDFDocumentElement extends PDFElement {
+    private children;
+    constructor({ children }: PDFDocumentParams);
+    calculateLayout(_constraints: BoxConstraints, _offset: Offset, ctx: LayoutContext): Size;
+    getProps(): PDFDocumentParams;
+}
+export {};

package/dist/elements/pdf-document-element.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PDFDocumentElement = void 0;
+const box_constraints_1 = require("../layout/box-constraints");
+const pdf_element_1 = require("./pdf-element");
+class PDFDocumentElement extends pdf_element_1.PDFElement {
+    constructor({ children }) {
+        super();
+        this.children = children;
+    }
+    calculateLayout(_constraints, _offset, ctx) {
+        // The document is the root: each page derives its own geometry, so it ignores the
+        // incoming constraints/offset. It has no size of its own.
+        const origin = { x: 0, y: 0 };
+        this.children.forEach((child) => child.calculateLayout(new box_constraints_1.BoxConstraints(), origin, ctx));
+        return { width: 0, height: 0 };
+    }
+    getProps() {
+        return { children: this.children };
+    }
+}
+exports.PDFDocumentElement = PDFDocumentElement;