cvdl-ts 1.0.25 → 1.0.27

package/dist/AnyLayout.d.ts

@@ -28,11 +28,13 @@ export type RenderProps = {
     bindings: Map<string, unknown>;
     storage: Storage;
     fontDict?: FontDict;
+    incremental?: boolean;
 };
+export declare function resetIncrementalCaches(): void;
 export declare class FontDict {
     fonts: Map<string, fontkit.Font>;
     constructor();
     load_fonts(storage: Storage): Promise<this>;
     get_font(name: string): fontkit.Font;
 }
-export declare function render({ resume, layout_schemas, data_schemas, resume_layout, bindings, fontDict, }: RenderProps): Layout.RenderedLayout[];
+export declare function render({ resume, layout_schemas, data_schemas, resume_layout, bindings, fontDict, incremental, }: RenderProps): Layout.RenderedLayout[];

package/dist/AnyLayout.js

@@ -24,10 +24,50 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FontDict = void 0;
+exports.resetIncrementalCaches = resetIncrementalCaches;
 exports.render = render;
 const ResumeLayout_1 = require("./ResumeLayout");
 const fontkit = __importStar(require("fontkit"));
 const Layout = __importStar(require("./Layout"));
+const blockCache = new Map();
+let flowPlacementCache = {
+    order: [],
+    signatures: [],
+    offsets: [],
+    heights: [],
+};
+const stableBindingsSignature = (bindings) => {
+    const sortedEntries = Array.from(bindings.entries()).sort(([a], [b]) => a.localeCompare(b));
+    return JSON.stringify(sortedEntries);
+};
+const stableSignature = (value) => {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+};
+const getOrComputeBlock = (key, signature, compute, stats) => {
+    const cached = blockCache.get(key);
+    if (cached && cached.signature === signature) {
+        stats.hits += 1;
+        return cached.layout;
+    }
+    const layout = compute();
+    blockCache.set(key, { signature, layout });
+    stats.misses += 1;
+    return layout;
+};
+function resetIncrementalCaches() {
+    blockCache.clear();
+    flowPlacementCache = {
+        order: [],
+        signatures: [],
+        offsets: [],
+        heights: [],
+    };
+}
 const cartesian = (...a) => a.reduce((a, b) => a.flatMap((d) => b.map((e) => [d, e].flat())));
 class FontDict {
     constructor() {
@@ -56,7 +96,8 @@ class FontDict {
     }
 }
 exports.FontDict = FontDict;
-function render({ resume, layout_schemas, data_schemas, resume_layout, bindings, fontDict, }) {
+function render({ resume, layout_schemas, data_schemas, resume_layout, bindings, fontDict, incremental = true, }) {
+    var _a;
     // Compute the total usable width by subtracting the margins from the document width
     const width = resume_layout.width -
         (resume_layout.margin.left + resume_layout.margin.right);
@@ -65,6 +106,14 @@ function render({ resume, layout_schemas, data_schemas, resume_layout, bindings,
         ? width
         : width - (0, ResumeLayout_1.vertical_margin)(resume_layout.column_type) / 2.0;
     const layouts = [];
+    const usedKeys = new Set();
+    const stats = { hits: 0, misses: 0 };
+    const blockOrder = [];
+    const blockSignatures = [];
+    const blockHeights = [];
+    const bindingsSignature = stableBindingsSignature(bindings);
+    const fontSignature = stableSignature(Array.from(fontDict.fonts.keys()).sort());
+    let firstDirtyBlock = incremental ? -1 : 0;
     console.info("Rendering sections...");
     for (const section of resume.sections) {
         // Render Section Header
@@ -85,8 +134,33 @@ function render({ resume, layout_schemas, data_schemas, resume_layout, bindings,
         }
         start_time = Date.now();
         // 3. Render the header
-        const layout = Layout.computeBoxes(Layout.normalize(Layout.instantiate(layout_schema.header_layout_schema, section.data, data_schema.header_schema, bindings), column_width, fontDict), fontDict);
+        const headerKey = `${section.section_name}::header`;
+        const headerSignature = stableSignature({
+            column_width,
+            fontSignature,
+            bindingsSignature,
+            layout: layout_schema.header_layout_schema,
+            fields: data_schema.header_schema,
+            data: section.data,
+        });
+        usedKeys.add(headerKey);
+        const blockIndex = blockOrder.length;
+        blockOrder.push(headerKey);
+        blockSignatures.push(headerSignature);
+        if (incremental &&
+            firstDirtyBlock === -1 &&
+            (flowPlacementCache.order[blockIndex] !== headerKey ||
+                flowPlacementCache.signatures[blockIndex] !== headerSignature)) {
+            firstDirtyBlock = blockIndex;
+        }
+        const layout = incremental
+            ? getOrComputeBlock(headerKey, headerSignature, () => Layout.computeBoxes(Layout.normalize(Layout.instantiate(layout_schema.header_layout_schema, section.data, data_schema.header_schema, bindings), column_width, fontDict), fontDict), stats)
+            : (() => {
+                stats.misses += 1;
+                return Layout.computeBoxes(Layout.normalize(Layout.instantiate(layout_schema.header_layout_schema, section.data, data_schema.header_schema, bindings), column_width, fontDict), fontDict);
+            })();
         layout.path = { tag: "section", section: section.section_name };
+        blockHeights.push(layout.bounding_box.height() + layout.margin.top + layout.margin.bottom);
         console.info("Header is computed");
         layouts.push(layout);
         end_time = Date.now();
@@ -94,14 +168,84 @@ function render({ resume, layout_schemas, data_schemas, resume_layout, bindings,
         start_time = Date.now();
         // Render Section Items
         for (const [index, item] of section.items.entries()) {
-            // 3. Render the item
-            const layout = Layout.computeBoxes(Layout.normalize(Layout.instantiate(layout_schema.item_layout_schema, item, data_schema.item_schema, bindings), column_width, fontDict), fontDict);
+            const itemKey = `${section.section_name}::item::${(_a = item.id) !== null && _a !== void 0 ? _a : index}`;
+            const itemSignature = stableSignature({
+                column_width,
+                fontSignature,
+                bindingsSignature,
+                layout: layout_schema.item_layout_schema,
+                fields: data_schema.item_schema,
+                data: item,
+            });
+            usedKeys.add(itemKey);
+            const blockIndex = blockOrder.length;
+            blockOrder.push(itemKey);
+            blockSignatures.push(itemSignature);
+            if (incremental &&
+                firstDirtyBlock === -1 &&
+                (flowPlacementCache.order[blockIndex] !== itemKey ||
+                    flowPlacementCache.signatures[blockIndex] !== itemSignature)) {
+                firstDirtyBlock = blockIndex;
+            }
+            const layout = incremental
+                ? getOrComputeBlock(itemKey, itemSignature, () => Layout.computeBoxes(Layout.normalize(Layout.instantiate(layout_schema.item_layout_schema, item, data_schema.item_schema, bindings), column_width, fontDict), fontDict), stats)
+                : (() => {
+                    stats.misses += 1;
+                    return Layout.computeBoxes(Layout.normalize(Layout.instantiate(layout_schema.item_layout_schema, item, data_schema.item_schema, bindings), column_width, fontDict), fontDict);
+                })();
             layout.path = { tag: "item", section: section.section_name, item: index };
+            blockHeights.push(layout.bounding_box.height() + layout.margin.top + layout.margin.bottom);
             layouts.push(layout);
         }
         end_time = Date.now();
         console.info(`Item rendering time: ${end_time - start_time}ms for section ${section.section_name}`);
     }
+    const hasSameBlockShape = flowPlacementCache.order.length === blockOrder.length &&
+        firstDirtyBlock === -1;
+    if (!incremental || !hasSameBlockShape) {
+        if (firstDirtyBlock === -1) {
+            firstDirtyBlock = Math.min(blockOrder.length, flowPlacementCache.order.length);
+        }
+    }
+    const offsets = new Array(blockOrder.length).fill(0);
+    if (incremental && firstDirtyBlock > 0) {
+        for (let i = 0; i < firstDirtyBlock; i++) {
+            offsets[i] = flowPlacementCache.offsets[i];
+        }
+    }
+    if (!incremental || firstDirtyBlock !== -1) {
+        const start = !incremental ? 0 : Math.max(0, firstDirtyBlock);
+        let cursor = start === 0 ? 0 : offsets[start - 1] + blockHeights[start - 1];
+        for (let i = start; i < blockOrder.length; i++) {
+            offsets[i] = cursor;
+            cursor += blockHeights[i];
+        }
+    }
+    else {
+        for (let i = 0; i < blockOrder.length; i++) {
+            offsets[i] = flowPlacementCache.offsets[i];
+        }
+    }
+    for (let i = 0; i < layouts.length; i++) {
+        layouts[i].flow_offset_y = offsets[i];
+    }
+    if (incremental) {
+        for (const key of Array.from(blockCache.keys())) {
+            if (!usedKeys.has(key)) {
+                blockCache.delete(key);
+            }
+        }
+        flowPlacementCache = {
+            order: blockOrder,
+            signatures: blockSignatures,
+            offsets,
+            heights: blockHeights,
+        };
+        console.info(`Incremental block cache: ${stats.hits} hit(s), ${stats.misses} miss(es), firstDirtyBlock=${firstDirtyBlock}, size=${blockCache.size}`);
+    }
+    else {
+        console.info(`Full render mode: ${stats.misses} block(s) recomputed`);
+    }
     console.log("Position calculations are completed.");
     return layouts;
 }

package/dist/Elem.js

@@ -354,12 +354,13 @@ function bind(t, bindings) {
     return result;
 }
 function instantiate(e, section, fields, bindings) {
+    var _a;
     e = bind(e, bindings);
     if (!e.is_ref) {
         return e;
     }
     const itemType = fields.find((f) => f.name === e.item);
-    if (itemType.type.tag === "MarkdownString") {
+    if (((_a = itemType === null || itemType === void 0 ? void 0 : itemType.type) === null || _a === void 0 ? void 0 : _a.tag) === "MarkdownString") {
         e.is_markdown = true;
     }
     const text = section.fields[e.item];

package/dist/Layout.d.ts

@@ -43,6 +43,7 @@ export type RenderedElem = Elem.t & {
 };
 export type RenderedLayout = (RenderedStack | RenderedRow | RenderedElem) & {
     path?: ElementPath;
+    flow_offset_y?: number;
 };
 export declare function default_(tag: string): Stack.t | Row.t | Elem.t;
 export declare function empty(): Layout;

package/dist/Layout.js

@@ -261,25 +261,27 @@ function computeTextboxPositions(l, top_left, font_dict) {
             top_left = top_left.move_y_by(row.margin.top).move_x_by(row.margin.left);
             const originalTopLeft = top_left;
             let per_elem_space = 0.0;
+            const rowElementsWidth = Row.elementsWidth(row);
             switch (row.alignment) {
                 case "Center":
-                    top_left = top_left.move_x_by((Width.get_fixed_unchecked(row.width) - Row.elementsWidth(row)) /
-                        2.0);
+                    top_left = top_left.move_x_by((Width.get_fixed_unchecked(row.width) - rowElementsWidth) / 2.0);
                     break;
                 case "Right":
-                    top_left = top_left.move_x_by(Width.get_fixed_unchecked(row.width) - Row.elementsWidth(row));
+                    top_left = top_left.move_x_by(Width.get_fixed_unchecked(row.width) - rowElementsWidth);
                     break;
                 case "Justified":
-                    per_elem_space =
-                        (Width.get_fixed_unchecked(row.width) - Row.elementsWidth(row)) /
-                            (row.elements.length - 1);
+                    if (row.elements.length > 1) {
+                        per_elem_space =
+                            (Width.get_fixed_unchecked(row.width) - rowElementsWidth) /
+                                (row.elements.length - 1);
+                    }
                     break;
             }
             const renderedElements = [];
             for (const element of row.elements) {
                 const result = computeTextboxPositions(element, top_left, font_dict);
                 depth = Math.max(depth, result.depth);
-                top_left = top_left.move_x_by(Width.get_fixed_unchecked(element.width) + per_elem_space);
+                top_left = top_left.move_x_by(Row.elementOuterWidth(element) + per_elem_space);
                 renderedElements.push(result.renderedLayout);
             }
             depth += row.margin.bottom;
@@ -304,15 +306,16 @@ function computeTextboxPositions(l, top_left, font_dict) {
                 .move_y_by(elem.margin.top)
                 .move_x_by(elem.margin.left);
             let line = 1;
-            let cursor = top_left.x;
+            let cursor = 0;
+            const maxLineWidth = Width.get_fixed_unchecked(elem.width) - elem.margin.right;
+            const wrapTolerance = 1e-6;
             elem.spans.forEach((span) => {
-                if (cursor - top_left.x + span.width >
-                    Width.get_fixed_unchecked(elem.width) - elem.margin.right ||
+                if (cursor + span.width > maxLineWidth + wrapTolerance ||
                     span.text === "\n\n") {
-                    cursor = top_left.x;
+                    cursor = 0;
                     line += 1;
                 }
-                span.bbox = new Box_1.Box(new Point_1.Point(cursor - top_left.x, (line - 1) * height), new Point_1.Point(cursor + span.width, line * height));
+                span.bbox = new Box_1.Box(new Point_1.Point(cursor, (line - 1) * height), new Point_1.Point(cursor + span.width, line * height));
                 span.line = line;
                 cursor += span.width;
             });

package/dist/PdfLayout.js

@@ -32,7 +32,9 @@ const AnyLayout_1 = require("./AnyLayout");
 const pdfkit_1 = __importDefault(require("pdfkit"));
 const Resume = __importStar(require("./Resume"));
 const _1 = require(".");
+const Box_1 = require("./Box");
 const render = async ({ resume_name, resume, data_schemas, layout_schemas, resume_layout, bindings, storage, fontDict, }) => {
+    var _a;
     let start_time = Date.now();
     if (!resume && !resume_name) {
         throw "Rendering requires either resume_name or resume";
@@ -95,9 +97,12 @@ const render = async ({ resume_name, resume, data_schemas, layout_schemas, resum
         fontDict: fontDict,
     };
     for (const layout of layouts) {
-        (0, exports.renderSectionLayout)(layout, tracker);
-        tracker.height +=
-            layout.bounding_box.height() + layout.margin.top + layout.margin.bottom;
+        const flowOffset = (_a = layout.flow_offset_y) !== null && _a !== void 0 ? _a : tracker.height;
+        (0, exports.renderSectionLayout)(layout, { ...tracker, height: flowOffset });
+        if (layout.flow_offset_y === undefined) {
+            tracker.height +=
+                layout.bounding_box.height() + layout.margin.top + layout.margin.bottom;
+        }
     }
     console.log("Rendering is completed. Saving the document...");
     console.log("Document is saved to output.pdf");
@@ -122,20 +127,38 @@ const getPageContainer = (page, tracker) => {
     return tracker.pageContainer;
 };
 const mergeSpans = (spans) => {
+    if (spans.length === 0) {
+        return [];
+    }
+    const firstSpan = spans[0];
+    if (!firstSpan) {
+        return [];
+    }
     const merged_spans = [];
-    let currentSpan = spans[0];
+    let currentSpan = firstSpan;
     for (let i = 1; i < spans.length; i++) {
-        if (currentSpan.bbox.top_left.y === spans[i].bbox.top_left.y &&
-            currentSpan.font === spans[i].font &&
-            currentSpan.is_code === spans[i].is_code &&
-            currentSpan.is_bold === spans[i].is_bold &&
-            currentSpan.is_italic === spans[i].is_italic) {
-            currentSpan.text += spans[i].text;
-            currentSpan.bbox.bottom_right = spans[i].bbox.bottom_right;
+        const nextSpan = spans[i];
+        if (!nextSpan) {
+            continue;
+        }
+        const hasBothBBoxes = Boolean(currentSpan.bbox && nextSpan.bbox);
+        if (hasBothBBoxes &&
+            currentSpan.bbox.top_left.y === nextSpan.bbox.top_left.y &&
+            currentSpan.font === nextSpan.font &&
+            currentSpan.is_code === nextSpan.is_code &&
+            currentSpan.is_bold === nextSpan.is_bold &&
+            currentSpan.is_italic === nextSpan.is_italic) {
+            currentSpan = {
+                ...currentSpan,
+                text: currentSpan.text + nextSpan.text,
+                bbox: currentSpan.bbox && nextSpan.bbox
+                    ? new Box_1.Box(currentSpan.bbox.top_left, nextSpan.bbox.bottom_right)
+                    : currentSpan.bbox,
+            };
         }
         else {
             merged_spans.push(currentSpan);
-            currentSpan = spans[i];
+            currentSpan = nextSpan;
         }
     }
     merged_spans.push(currentSpan);

package/dist/Row.d.ts

@@ -17,6 +17,7 @@ export declare function from(w: Optional<Row>): Row;
 export declare function row(elements: Layout.t[], margin: Margin.t, alignment: Alignment.t, width: Width.t, is_frozen: boolean, is_fill: boolean): Row;
 export declare function default_(): Row;
 export declare function elementsWidth(r: Row): number;
+export declare function elementOuterWidth(e: Layout.t): number;
 export declare function boundWidth(r: Row, width: number): Row;
 export declare function scaleWidth(r: Row, w: number): Row;
 export {};

package/dist/Row.js

@@ -27,6 +27,7 @@ exports.from = from;
 exports.row = row;
 exports.default_ = default_;
 exports.elementsWidth = elementsWidth;
+exports.elementOuterWidth = elementOuterWidth;
 exports.boundWidth = boundWidth;
 exports.scaleWidth = scaleWidth;
 const Margin = __importStar(require("./Margin"));
@@ -60,9 +61,10 @@ function default_() {
     };
 }
 function elementsWidth(r) {
-    return r.elements
-        .map((e) => Width.get_fixed_unchecked(e.width))
-        .reduce((a, b) => a + b, 0.0);
+    return r.elements.map(elementOuterWidth).reduce((a, b) => a + b, 0.0);
+}
+function elementOuterWidth(e) {
+    return e.margin.left + Width.get_fixed_unchecked(e.width) + e.margin.right;
 }
 function boundWidth(r, width) {
     const bound = r.width.tag === "Absolute"
@@ -73,7 +75,32 @@ function boundWidth(r, width) {
     if (bound === null) {
         throw new Error("Cannot bound width of non-unitized widths!");
     }
-    return row(r.elements.map((e) => Layout.boundWidth(e, bound)), r.margin, r.alignment, Width.absolute(bound), r.is_frozen, Width.is_fill(r.width));
+    const fixedWidths = r.elements.map((e) => {
+        switch (e.width.tag) {
+            case "Fill":
+                return null;
+            case "Absolute":
+                return Math.min(e.width.value, bound);
+            case "Percent":
+                // Row children are usually scaled before bounding, but this keeps
+                // direct boundWidth() calls stable if Percent widths appear.
+                return Math.min((e.width.value * bound) / 100.0, bound);
+        }
+    });
+    const totalFixedOuterWidth = fixedWidths.reduce((acc, next, index) => next === null
+        ? acc
+        : acc + r.elements[index].margin.left + next + r.elements[index].margin.right, 0);
+    const fillElementCount = fixedWidths.filter((next) => next === null).length;
+    const totalFillMargins = fixedWidths.reduce((acc, next, index) => next === null
+        ? acc +
+            r.elements[index].margin.left +
+            r.elements[index].margin.right
+        : acc, 0);
+    const fillWidth = fillElementCount > 0
+        ? Math.max(0, bound - totalFixedOuterWidth - totalFillMargins) /
+            fillElementCount
+        : 0;
+    return row(r.elements.map((e, index) => { var _a; return Layout.boundWidth(e, (_a = fixedWidths[index]) !== null && _a !== void 0 ? _a : fillWidth); }), r.margin, r.alignment, Width.absolute(bound), r.is_frozen, Width.is_fill(r.width));
 }
 function scaleWidth(r, w) {
     return (0, Utils_1.with_)(r, {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cvdl-ts",
-	"version": "1.0.25",
+	"version": "1.0.27",
 	"description": "Typescript Implementation of CVDL Compiler",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -24,6 +24,8 @@
 	"scripts": {
 		"build": "tsc",
 		"start": "ts-node src/index.ts",
-		"cli": "ts-node src/cli.ts"
+		"cli": "ts-node src/cli.ts",
+		"bench:incremental": "npm run build && node scripts/benchmark_incremental.cjs",
+		"bench:incremental:full": "npm run build && BENCH_PROFILE=full node scripts/benchmark_incremental.cjs"
 	}
 }