@pdfme/common 6.1.0 → 6.1.1-dev.5

package/dist/dynamicTemplate.d.ts

@@ -1,4 +1,4 @@
-import { Schema, Template, BasePdf, CommonOptions } from './types.js';
+import { Schema, Template, BasePdf, CommonOptions, DynamicLayoutCallbackResult } from './types.js';
 interface ModifyTemplateForDynamicTableArg {
     template: Template;
     input: Record<string, string>;
@@ -9,7 +9,7 @@ interface ModifyTemplateForDynamicTableArg {
         basePdf: BasePdf;
         options: CommonOptions;
         _cache: Map<string | number, unknown>;
-    }) => Promise<number[]>;
+    }) => Promise<DynamicLayoutCallbackResult>;
 }
 /**
  * Process a template containing tables with dynamic heights

package/dist/helper.d.ts

@@ -1,3 +1,4 @@
+import type { PDFDocument, PDFPage } from '@pdfme/pdf-lib';
 import { Template, Font, BasePdf, Plugins, BlankPdf } from './types.js';
 export declare const cloneDeep: typeof structuredClone;
 export declare const getFallbackFontName: (font: Font) => string;
@@ -16,6 +17,35 @@ export declare const getInputFromTemplate: (template: Template) => {
     [key: string]: string;
 }[];
 export declare const isUrlSafeToFetch: (urlString: string) => boolean;
+export type PdfLinkAnnotationRect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export declare const normalizeSafeLinkUri: (uri: string) => string | undefined;
+export declare const getInternalLinkTarget: (href: string) => string | undefined;
+export declare const normalizeInternalLinkHref: (href: string) => string | undefined;
+export declare const normalizeLinkHref: (href: string) => string | undefined;
+export declare const resetInternalLinkAnnotations: (_cache: Map<string | number, unknown>) => void;
+export declare const registerInternalLinkAnchor: (arg: {
+    _cache: Map<string | number, unknown>;
+    name: string;
+    page: PDFPage;
+    x: number;
+    y: number;
+}) => void;
+export declare const registerInternalLinkAnnotation: (arg: {
+    _cache: Map<string | number, unknown>;
+    page: PDFPage;
+    targetName: string;
+    rect: PdfLinkAnnotationRect;
+    borderWidth?: number;
+}) => void;
+export declare const applyInternalLinkAnnotations: (arg: {
+    _cache: Map<string | number, unknown>;
+    pdfDoc: PDFDocument;
+}) => void;
 export declare const getB64BasePdf: (customPdf: ArrayBuffer | Uint8Array | string) => Promise<string>;
 export declare const isBlankPdf: (basePdf: BasePdf) => basePdf is BlankPdf;
 export declare const b64toUint8Array: (base64: string) => Uint8Array<ArrayBuffer>;

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 import { PDFME_VERSION } from './version.js';
 import { MM_TO_PT_RATIO, PT_TO_MM_RATIO, PT_TO_PX_RATIO, BLANK_PDF, BLANK_A4_PDF, CUSTOM_A4_PDF, ZOOM, DEFAULT_FONT_NAME } from './constants.js';
-import type { ChangeSchemaItem, ChangeSchemas, SchemaPageArray, PropPanel, PropPanelSchema, PropPanelWidgetProps, PDFRenderProps, Mode, UIRenderProps, Plugin, Lang, Dict, Size, Schema, SchemaForUI, Font, ColorType, BasePdf, BlankPdf, CustomPdf, Template, CommonOptions, GeneratorOptions, Plugins, PluginRegistry, GenerateProps, UIOptions, UIProps, PreviewProps, DesignerProps } from './types.js';
-import { cloneDeep, getFallbackFontName, getDefaultFont, getB64BasePdf, b64toUint8Array, checkFont, checkInputs, checkUIOptions, checkTemplate, checkUIProps, checkPreviewProps, checkDesignerProps, checkGenerateProps, mm2pt, pt2mm, pt2px, px2mm, isHexValid, getInputFromTemplate, isBlankPdf, isUrlSafeToFetch } from './helper.js';
+import type { ChangeSchemaItem, ChangeSchemas, SchemaPageArray, PropPanel, PropPanelSchema, PropPanelWidgetProps, PDFRenderProps, Mode, UIRenderProps, Plugin, Lang, Dict, Size, Schema, SchemaForUI, Font, ColorType, BasePdf, BlankPdf, CustomPdf, Template, CommonOptions, GeneratorOptions, Plugins, PluginRegistry, GenerateProps, UIOptions, UIProps, PreviewProps, DesignerProps, DynamicLayoutArgs, DynamicLayoutCallbackResult, DynamicLayoutPatchArgs, DynamicLayoutResult, GetDynamicLayout } from './types.js';
+import type { PdfLinkAnnotationRect } from './helper.js';
+import { cloneDeep, getFallbackFontName, getDefaultFont, getB64BasePdf, b64toUint8Array, checkFont, checkInputs, checkUIOptions, checkTemplate, checkUIProps, checkPreviewProps, checkDesignerProps, checkGenerateProps, mm2pt, pt2mm, pt2px, px2mm, isHexValid, getInputFromTemplate, isBlankPdf, isUrlSafeToFetch, getInternalLinkTarget, normalizeInternalLinkHref, normalizeLinkHref, normalizeSafeLinkUri, registerInternalLinkAnchor, registerInternalLinkAnnotation, resetInternalLinkAnnotations, applyInternalLinkAnnotations } from './helper.js';
 import { getDynamicTemplate } from './dynamicTemplate.js';
 import { replacePlaceholders } from './expression.js';
 import { pluginRegistry } from './pluginRegistry.js';
-export { PDFME_VERSION, MM_TO_PT_RATIO, PT_TO_MM_RATIO, PT_TO_PX_RATIO, BLANK_PDF, BLANK_A4_PDF, CUSTOM_A4_PDF, ZOOM, DEFAULT_FONT_NAME, cloneDeep, getFallbackFontName, getDefaultFont, getB64BasePdf, b64toUint8Array, mm2pt, pt2mm, pt2px, px2mm, isHexValid, getInputFromTemplate, isBlankPdf, getDynamicTemplate, replacePlaceholders, checkFont, checkInputs, checkUIOptions, checkTemplate, checkUIProps, checkPreviewProps, checkDesignerProps, checkGenerateProps, pluginRegistry, isUrlSafeToFetch, };
-export type { Lang, Dict, Size, Schema, SchemaForUI, Font, ColorType, BasePdf, BlankPdf, CustomPdf, Template, CommonOptions, GeneratorOptions, Plugin, Plugins, PluginRegistry, GenerateProps, UIOptions, UIProps, PreviewProps, DesignerProps, ChangeSchemaItem, ChangeSchemas, SchemaPageArray, PropPanel, PropPanelSchema, PropPanelWidgetProps, PDFRenderProps, UIRenderProps, Mode, };
+export { PDFME_VERSION, MM_TO_PT_RATIO, PT_TO_MM_RATIO, PT_TO_PX_RATIO, BLANK_PDF, BLANK_A4_PDF, CUSTOM_A4_PDF, ZOOM, DEFAULT_FONT_NAME, cloneDeep, getFallbackFontName, getDefaultFont, getB64BasePdf, b64toUint8Array, mm2pt, pt2mm, pt2px, px2mm, isHexValid, getInputFromTemplate, isBlankPdf, getDynamicTemplate, replacePlaceholders, checkFont, checkInputs, checkUIOptions, checkTemplate, checkUIProps, checkPreviewProps, checkDesignerProps, checkGenerateProps, pluginRegistry, isUrlSafeToFetch, getInternalLinkTarget, normalizeInternalLinkHref, normalizeLinkHref, normalizeSafeLinkUri, registerInternalLinkAnchor, registerInternalLinkAnnotation, resetInternalLinkAnnotations, applyInternalLinkAnnotations, };
+export type { Lang, Dict, Size, Schema, SchemaForUI, Font, ColorType, BasePdf, BlankPdf, CustomPdf, Template, CommonOptions, GeneratorOptions, Plugin, Plugins, PluginRegistry, GenerateProps, UIOptions, UIProps, PreviewProps, DesignerProps, ChangeSchemaItem, ChangeSchemas, SchemaPageArray, PropPanel, PropPanelSchema, PropPanelWidgetProps, PDFRenderProps, UIRenderProps, Mode, DynamicLayoutArgs, DynamicLayoutCallbackResult, DynamicLayoutPatchArgs, DynamicLayoutResult, GetDynamicLayout, PdfLinkAnnotationRect, };

package/dist/index.js

@@ -1,8 +1,9 @@
 import { z } from "zod";
 import { Buffer } from "buffer";
+import { PDFName } from "@pdfme/pdf-lib";
 import * as acorn from "acorn";
 //#region src/version.ts
-var PDFME_VERSION = "6.1.0";
+var PDFME_VERSION = "6.1.1";
 //#endregion
 //#region src/constants.ts
 var PT_TO_PX_RATIO = 1.333;
@@ -133,7 +134,18 @@ z.object({
 	"schemas.date.locale": z.string(),
 	"schemas.select.options": z.string(),
 	"schemas.select.optionPlaceholder": z.string(),
-	"schemas.radioGroup.groupName": z.string()
+	"schemas.radioGroup.groupName": z.string(),
+	"schemas.list.listStyle": z.string(),
+	"schemas.list.bullet": z.string(),
+	"schemas.list.ordered": z.string(),
+	"schemas.list.markerWidth": z.string(),
+	"schemas.list.markerGap": z.string(),
+	"schemas.list.indentSize": z.string(),
+	"schemas.list.itemSpacing": z.string(),
+	"schemas.list.addItem": z.string(),
+	"schemas.list.removeItem": z.string(),
+	"schemas.list.indentItem": z.string(),
+	"schemas.list.outdentItem": z.string()
 });
 z.enum([
 	"viewer",
@@ -163,6 +175,10 @@ var Schema = z.object({
 		start: z.number(),
 		end: z.number().optional()
 	}).optional(),
+	__itemRange: z.object({
+		start: z.number(),
+		end: z.number().optional()
+	}).optional(),
 	__isSplit: z.boolean().optional()
 }).passthrough();
 var SchemaForUIAdditionalInfo = z.object({ id: z.string() });
@@ -350,6 +366,130 @@ var isUrlSafeToFetch = (urlString) => {
 	}
 	return true;
 };
+var SAFE_LINK_URI_PROTOCOLS = new Set([
+	"http:",
+	"https:",
+	"mailto:"
+]);
+var INTERNAL_LINK_CACHE_KEY = "pdfme-internal-link-cache";
+var normalizeSafeLinkUri = (uri) => {
+	const trimmed = uri.trim();
+	if (!trimmed) return void 0;
+	let parsed;
+	try {
+		parsed = new URL(trimmed);
+	} catch {
+		return;
+	}
+	return SAFE_LINK_URI_PROTOCOLS.has(parsed.protocol.toLowerCase()) ? trimmed : void 0;
+};
+var getInternalLinkTarget = (href) => {
+	const trimmed = href.trim();
+	if (!trimmed.startsWith("#") || trimmed.length === 1) return void 0;
+	let target = trimmed.slice(1);
+	try {
+		target = decodeURIComponent(target);
+	} catch {}
+	target = target.trim();
+	if (!target || Array.from(target).some((char) => {
+		const code = char.charCodeAt(0);
+		return code < 32 || code === 127;
+	})) return;
+	return target;
+};
+var normalizeInternalLinkHref = (href) => {
+	const target = getInternalLinkTarget(href);
+	return target ? `#${target}` : void 0;
+};
+var normalizeLinkHref = (href) => normalizeSafeLinkUri(href) ?? normalizeInternalLinkHref(href);
+var getInternalLinkCache = (_cache) => {
+	let cache = _cache.get(INTERNAL_LINK_CACHE_KEY);
+	if (!cache) {
+		cache = {
+			anchors: /* @__PURE__ */ new Map(),
+			annotations: []
+		};
+		_cache.set(INTERNAL_LINK_CACHE_KEY, cache);
+	}
+	return cache;
+};
+var resetInternalLinkAnnotations = (_cache) => {
+	_cache.set(INTERNAL_LINK_CACHE_KEY, {
+		anchors: /* @__PURE__ */ new Map(),
+		annotations: []
+	});
+};
+var registerInternalLinkAnchor = (arg) => {
+	const { _cache, name, page, x, y } = arg;
+	if (!name) return;
+	const cache = getInternalLinkCache(_cache);
+	const anchors = cache.anchors.get(name) ?? [];
+	anchors.push({
+		name,
+		page,
+		x,
+		y
+	});
+	cache.anchors.set(name, anchors);
+};
+var registerInternalLinkAnnotation = (arg) => {
+	const { _cache, page, targetName, rect, borderWidth } = arg;
+	if (!targetName || rect.width <= 0 || rect.height <= 0) return;
+	getInternalLinkCache(_cache).annotations.push({
+		page,
+		targetName,
+		rect,
+		borderWidth
+	});
+};
+var addGoToLinkAnnotation = (arg) => {
+	const { pdfDoc, page, target, rect, borderWidth = 0 } = arg;
+	if (rect.width <= 0 || rect.height <= 0) return;
+	const annotationRef = pdfDoc.context.register(pdfDoc.context.obj({
+		Type: PDFName.of("Annot"),
+		Subtype: PDFName.of("Link"),
+		Rect: [
+			rect.x,
+			rect.y,
+			rect.x + rect.width,
+			rect.y + rect.height
+		],
+		Border: [
+			0,
+			0,
+			borderWidth
+		],
+		A: {
+			Type: PDFName.of("Action"),
+			S: PDFName.of("GoTo"),
+			D: [
+				target.page.ref,
+				PDFName.of("XYZ"),
+				target.x,
+				target.y,
+				null
+			]
+		}
+	}));
+	page.node.addAnnot(annotationRef);
+};
+var applyInternalLinkAnnotations = (arg) => {
+	const { _cache, pdfDoc } = arg;
+	const cache = getInternalLinkCache(_cache);
+	cache.annotations.forEach((annotation) => {
+		const anchors = cache.anchors.get(annotation.targetName) ?? [];
+		if (anchors.length === 0) throw new Error(`[@pdfme/generator] Internal link target "#${annotation.targetName}" was not found.`);
+		if (anchors.length > 1) throw new Error(`[@pdfme/generator] Internal link target "#${annotation.targetName}" is ambiguous because multiple schemas use that name.`);
+		addGoToLinkAnnotation({
+			pdfDoc,
+			page: annotation.page,
+			target: anchors[0],
+			rect: annotation.rect,
+			borderWidth: annotation.borderWidth
+		});
+	});
+	resetInternalLinkAnnotations(_cache);
+};
 var getB64BasePdf = async (customPdf) => {
 	if (typeof customPdf === "string" && !customPdf.startsWith("data:application/pdf;") && typeof window !== "undefined") {
 		if (!isUrlSafeToFetch(customPdf)) throw Error("[@pdfme/common] Invalid or unsafe URL for basePdf. Only http: and https: URLs pointing to public hosts are allowed.");
@@ -451,7 +591,7 @@ function normalizePageSchemas(pageSchemas, paddingTop) {
 			schema: cloneDeep(schema),
 			baseY: localY,
 			height: schema.height,
-			dynamicHeights: [schema.height]
+			dynamicLayout: { heights: [schema.height] }
 		});
 		orderMap.set(schema.name, index);
 	});
@@ -465,20 +605,21 @@ function normalizePageSchemas(pageSchemas, paddingTop) {
 	};
 }
 /**
-* Place rows on pages, splitting across pages as needed.
+* Place height units on pages, splitting across pages as needed.
 * @returns The final global Y coordinate after placement
 */
-function placeRowsOnPages(schema, dynamicHeights, startGlobalY, contentHeight, paddingTop, pages) {
-	let currentRowIndex = 0;
+function placeUnitsOnPages(schema, dynamicLayout, startGlobalY, contentHeight, paddingTop, pages) {
+	const dynamicHeights = dynamicLayout.heights;
+	let currentUnitIndex = 0;
 	let currentPageIndex = Math.floor(startGlobalY / contentHeight);
 	let currentYInPage = startGlobalY % contentHeight;
 	if (currentYInPage < 0) currentYInPage = 0;
 	let actualGlobalEndY = 0;
 	const isSplittable = dynamicHeights.length > 1;
-	while (currentRowIndex < dynamicHeights.length) {
+	while (currentUnitIndex < dynamicHeights.length) {
 		while (pages.length <= currentPageIndex) pages.push([]);
 		const spaceLeft = contentHeight - currentYInPage;
-		if (dynamicHeights[currentRowIndex] > spaceLeft + EPSILON) {
+		if (dynamicHeights[currentUnitIndex] > spaceLeft + EPSILON) {
 			if (!(Math.abs(spaceLeft - contentHeight) <= EPSILON)) {
 				currentPageIndex++;
 				currentYInPage = 0;
@@ -486,40 +627,41 @@ function placeRowsOnPages(schema, dynamicHeights, startGlobalY, contentHeight, p
 			}
 		}
 		let chunkHeight = 0;
-		const startRowIndex = currentRowIndex;
-		while (currentRowIndex < dynamicHeights.length) {
-			const h = dynamicHeights[currentRowIndex];
+		const startUnitIndex = currentUnitIndex;
+		while (currentUnitIndex < dynamicHeights.length) {
+			const h = dynamicHeights[currentUnitIndex];
 			if (currentYInPage + chunkHeight + h <= contentHeight + EPSILON) {
 				chunkHeight += h;
-				currentRowIndex++;
+				currentUnitIndex++;
 			} else break;
 		}
 		const isAtPageTop = currentYInPage <= EPSILON;
-		if (isSplittable && startRowIndex === 0 && currentRowIndex === 1 && dynamicHeights.length > 1 && !isAtPageTop) {
-			currentRowIndex = 0;
+		if (dynamicLayout.avoidFirstUnitOnly && isSplittable && startUnitIndex === 0 && currentUnitIndex === 1 && dynamicHeights.length > 1 && !isAtPageTop) {
+			currentUnitIndex = 0;
 			currentPageIndex++;
 			currentYInPage = 0;
 			continue;
 		}
-		if (currentRowIndex === startRowIndex) {
-			chunkHeight += dynamicHeights[currentRowIndex];
-			currentRowIndex++;
+		if (currentUnitIndex === startUnitIndex) {
+			chunkHeight += dynamicHeights[currentUnitIndex];
+			currentUnitIndex++;
 		}
+		const patch = dynamicLayout.patchSplitSchema?.({
+			schema,
+			start: startUnitIndex,
+			end: currentUnitIndex,
+			isSplit: startUnitIndex > 0,
+			chunkHeight
+		}) ?? {};
 		const newSchema = {
 			...schema,
+			...patch,
 			height: chunkHeight,
 			position: {
 				...schema.position,
 				y: currentYInPage + paddingTop
 			}
 		};
-		if (isSplittable) {
-			newSchema.__bodyRange = {
-				start: startRowIndex === 0 ? 0 : startRowIndex - 1,
-				end: currentRowIndex - 1
-			};
-			newSchema.__isSplit = startRowIndex > 0;
-		}
 		pages[currentPageIndex].push(newSchema);
 		currentYInPage += chunkHeight;
 		if (currentYInPage >= contentHeight - EPSILON) {
@@ -550,12 +692,19 @@ function processDynamicPage(items, orderMap, contentHeight, paddingTop) {
 	let totalYOffset = 0;
 	for (const item of items) {
 		const currentGlobalStartY = item.baseY + totalYOffset;
-		totalYOffset = placeRowsOnPages(item.schema, item.dynamicHeights, currentGlobalStartY, contentHeight, paddingTop, pages) - (item.baseY + item.height);
+		totalYOffset = placeUnitsOnPages(item.schema, item.dynamicLayout, currentGlobalStartY, contentHeight, paddingTop, pages) - (item.baseY + item.height);
 	}
 	sortPagesByOrder(pages, orderMap);
 	removeTrailingEmptyPages(pages);
 	return pages;
 }
+var normalizeDynamicLayoutResult = (result) => {
+	const dynamicLayout = Array.isArray(result) ? { heights: result } : result;
+	return {
+		...dynamicLayout,
+		heights: dynamicLayout.heights.length === 0 ? [0] : dynamicLayout.heights
+	};
+};
 /**
 * Process a template containing tables with dynamic heights
 * and generate a new template with proper page breaks.
@@ -587,9 +736,9 @@ var getDynamicTemplate = async (arg) => {
 					basePdf,
 					options,
 					_cache
-				}).then((heights) => heights.length === 0 ? [0] : heights);
+				}).then(normalizeDynamicLayoutResult);
 			}));
-			for (let j = 0; j < chunkResults.length; j++) items[i + j].dynamicHeights = chunkResults[j];
+			for (let j = 0; j < chunkResults.length; j++) items[i + j].dynamicLayout = chunkResults[j];
 		}
 		const processedPages = processDynamicPage(items, orderMap, contentHeight, paddingTop);
 		resultPages.push(...processedPages);
@@ -961,6 +1110,6 @@ var pluginRegistry = (plugins) => {
 	};
 };
 //#endregion
-export { BLANK_A4_PDF, BLANK_PDF, CUSTOM_A4_PDF, DEFAULT_FONT_NAME, MM_TO_PT_RATIO, PDFME_VERSION, PT_TO_MM_RATIO, PT_TO_PX_RATIO, ZOOM, b64toUint8Array, checkDesignerProps, checkFont, checkGenerateProps, checkInputs, checkPreviewProps, checkTemplate, checkUIOptions, checkUIProps, cloneDeep, getB64BasePdf, getDefaultFont, getDynamicTemplate, getFallbackFontName, getInputFromTemplate, isBlankPdf, isHexValid, isUrlSafeToFetch, mm2pt, pluginRegistry, pt2mm, pt2px, px2mm, replacePlaceholders };
+export { BLANK_A4_PDF, BLANK_PDF, CUSTOM_A4_PDF, DEFAULT_FONT_NAME, MM_TO_PT_RATIO, PDFME_VERSION, PT_TO_MM_RATIO, PT_TO_PX_RATIO, ZOOM, applyInternalLinkAnnotations, b64toUint8Array, checkDesignerProps, checkFont, checkGenerateProps, checkInputs, checkPreviewProps, checkTemplate, checkUIOptions, checkUIProps, cloneDeep, getB64BasePdf, getDefaultFont, getDynamicTemplate, getFallbackFontName, getInputFromTemplate, getInternalLinkTarget, isBlankPdf, isHexValid, isUrlSafeToFetch, mm2pt, normalizeInternalLinkHref, normalizeLinkHref, normalizeSafeLinkUri, pluginRegistry, pt2mm, pt2px, px2mm, registerInternalLinkAnchor, registerInternalLinkAnnotation, replacePlaceholders, resetInternalLinkAnnotations };
 
 //# sourceMappingURL=index.js.map