cvdl-ts 1.0.25 → 1.0.26

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

@@ -359,7 +359,7 @@ function instantiate(e, section, fields, bindings) {
         return e;
     }
     const itemType = fields.find((f) => f.name === e.item);
-    if (itemType.type.tag === "MarkdownString") {
+    if ((itemType === null || itemType === void 0 ? void 0 : itemType.type.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/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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "cvdl-ts",
-	"version": "1.0.25",
+	"version": "1.0.26",
 	"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"
 	}
 }