@pdfme/schemas 6.0.6-dev.9 → 6.1.0

package/dist/index.js

@@ -1,6 +1,6 @@
-import { C as DEFAULT_FONT_COLOR, O as VERTICAL_ALIGN_MIDDLE, a as getColumnStylesPropPanelSchema, c as createSingleTable, i as getCellPropPanelSchema, n as getBody, o as getDefaultCellStyles, p as getFontKitFont, r as getBodyWithRange, s as HEX_COLOR_PATTERN, t as getDynamicHeightsForTable, x as DEFAULT_ALIGNMENT } from "./dynamicTemplate-DxHU9waC.js";
+import { B as VERTICAL_ALIGN_MIDDLE, C as DEFAULT_ALIGNMENT, F as SYNTHETIC_BOLD_CSS_TEXT_SHADOW, T as DEFAULT_FONT_COLOR, a as getColumnStylesPropPanelSchema, c as createSingleTable, i as getCellPropPanelSchema, n as getBody, o as getDefaultCellStyles, p as getFontKitFont, r as getBodyWithRange, s as HEX_COLOR_PATTERN, t as getDynamicHeightsForTable, x as CODE_BACKGROUND_COLOR } from "./dynamicTemplate-Dsrw11aL.js";
+import { a as mapVerticalAlignToFlex, c as Formatter, d as isInlineMarkdownTextSchema, f as resolveFontVariant, i as makeElementPlainTextContentEditable, l as getExtraFormatterSchema, m as parseInlineMarkdown, n as textSchema, o as uiRender$3, p as escapeInlineMarkdown, r as buildStyledTextContainer, s as propPanel$2, t as builtInPlugins, u as pdfRender$3 } from "./builtins-C0BvXHWr.js";
 import { addAlphaToHex, convertForPdfLayoutProps, createErrorElm, createSvgStr, hex2PrintingColor, isEditable, readFile, rotatePoint } from "./utils.js";
-import { a as mapVerticalAlignToFlex, c as Formatter, i as makeElementPlainTextContentEditable, l as getExtraFormatterSchema, n as textSchema, o as uiRender$3, r as buildStyledTextContainer, s as propPanel$2, t as builtInPlugins, u as pdfRender$3 } from "./builtins-KUsYW25j.js";
 import "./tables.js";
 import { DEFAULT_FONT_NAME, ZOOM, b64toUint8Array, getDefaultFont, getFallbackFontName, mm2pt, px2mm } from "@pdfme/common";
 import { Buffer as Buffer$1 } from "buffer";
@@ -35,7 +35,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 //#endregion
 //#region src/multiVariableText/helper.ts
-var substituteVariables = (text, variablesIn) => {
+var substituteVariables = (text, variablesIn, valueMapper = (value) => value) => {
 	if (!text) return "";
 	let substitutedText = text;
 	if (variablesIn) {
@@ -48,12 +48,13 @@ var substituteVariables = (text, variablesIn) => {
 		Object.keys(variables).forEach((variableName) => {
 			const variableForRegex = variableName.replace(/[/\-\\^$*+?.()|[\]{}]/g, "\\$&");
 			const regex = new RegExp("\\{" + variableForRegex + "\\}", "g");
-			substitutedText = substitutedText.replace(regex, variables[variableName]);
+			substitutedText = substitutedText.replace(regex, valueMapper(variables[variableName], variableName));
 		});
 	}
 	substitutedText = substitutedText.replace(/{[^{}]+}/g, "");
 	return substitutedText;
 };
+var substituteVariablesAsInlineMarkdownLiterals = (text, variablesIn) => substituteVariables(text, variablesIn, escapeInlineMarkdown);
 var validateVariables = (value, schema) => {
 	if (schema.variables.length === 0) return true;
 	let values;
@@ -74,7 +75,7 @@ var pdfRender$2 = async (arg) => {
 	const { value, schema, ...rest } = arg;
 	if (!validateVariables(value, schema)) return;
 	await pdfRender$3({
-		value: substituteVariables(schema.text || "", value),
+		value: isInlineMarkdownTextSchema(schema) ? substituteVariablesAsInlineMarkdownLiterals(schema.text || "", value) : substituteVariables(schema.text || "", value),
 		schema,
 		...rest
 	});
@@ -100,13 +101,6 @@ var visitVariables = (content, visitor) => {
 		}
 	}
 };
-var getVariableIndices = (content) => {
-	const indices = /* @__PURE__ */ new Map();
-	visitVariables(content, ({ name, startIndex }) => {
-		indices.set(startIndex, name);
-	});
-	return indices;
-};
 var countUniqueVariableNames = (content) => {
 	const variableNames = /* @__PURE__ */ new Set();
 	visitVariables(content, ({ name }) => {
@@ -193,14 +187,16 @@ var mapDynamicVariables = (props) => {
 var propPanel$1 = {
 	schema: (propPanelProps) => {
 		if (typeof propPanel$2.schema !== "function") throw new Error("Oops, is text schema no longer a function?");
+		const parentSchema = typeof propPanel$2.schema === "function" ? propPanel$2.schema(propPanelProps) : {};
+		const i18n = propPanelProps.i18n;
 		return {
-			...typeof propPanel$2.schema === "function" ? propPanel$2.schema(propPanelProps) : {},
+			...parentSchema,
 			"-------": {
 				type: "void",
 				widget: "Divider"
 			},
 			dynamicVarContainer: {
-				title: "Variables Sample Data",
+				title: i18n("schemas.mvt.variablesSampleData"),
 				type: "string",
 				widget: "Card",
 				span: 24,
@@ -212,7 +208,7 @@ var propPanel$1 = {
 						span: 24
 					},
 					placeholderDynamicVar: {
-						title: "Placeholder Dynamic Variable",
+						title: i18n("schemas.mvt.placeholderDynamicVariable"),
 						type: "string",
 						format: "textarea",
 						props: {
@@ -274,8 +270,9 @@ var uiRender$2 = async (arg) => {
 		await formUiRender(arg);
 		return;
 	}
+	const renderValue = isInlineMarkdownTextSchema(schema) ? substituteVariablesAsInlineMarkdownLiterals(text, value) : substituteVariables(text, value);
 	await uiRender$3({
-		value: isEditable(mode, schema) ? text : substituteVariables(text, value),
+		value: isEditable(mode, schema) ? text : renderValue,
 		schema,
 		mode: mode === "form" ? "viewer" : mode,
 		rootElement,
@@ -314,10 +311,27 @@ var formUiRender = async (arg) => {
 		const parsed = JSON.parse(value);
 		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) variables = parsed;
 	} catch {}
-	const variableIndices = getVariableIndices(rawText);
 	const substitutedText = substituteVariables(rawText, variables);
+	const inlineMarkdownRuns = isInlineMarkdownTextSchema(schema) ? parseInlineMarkdown(rawText) : void 0;
 	const font = options?.font || getDefaultFont();
-	const textBlock = buildStyledTextContainer(arg, await getFontKitFont(schema.fontName, font, _cache), substitutedText);
+	const textBlock = buildStyledTextContainer(arg, await getFontKitFont(schema.fontName, font, _cache), inlineMarkdownRuns ? getInlineMarkdownFormDisplayText(inlineMarkdownRuns, variables) : substitutedText);
+	if (inlineMarkdownRuns) {
+		renderInlineMarkdownVariableSpans({
+			runs: inlineMarkdownRuns,
+			variables,
+			textBlock,
+			schema,
+			font,
+			theme,
+			onChange,
+			stopEditing
+		});
+		return;
+	}
+	const variableIndices = /* @__PURE__ */ new Map();
+	visitVariables(rawText, ({ name, startIndex }) => {
+		variableIndices.set(startIndex, name);
+	});
 	let inVarString = false;
 	for (let i = 0; i < rawText.length; i++) {
 		const variableName = variableIndices.get(i);
@@ -349,6 +363,97 @@ var formUiRender = async (arg) => {
 		}
 	}
 };
+var getInlineMarkdownFormDisplayText = (runs, variables) => runs.map((run) => substituteVariables(run.text, variables)).join("");
+var applyInlineMarkdownStyle = (arg) => {
+	const { element, run, schema, font } = arg;
+	const resolvedFont = resolveFontVariant(run, schema, font);
+	if (resolvedFont.fontName) element.style.fontFamily = `'${resolvedFont.fontName}'`;
+	if (resolvedFont.syntheticBold) {
+		element.style.fontWeight = "800";
+		element.style.textShadow = SYNTHETIC_BOLD_CSS_TEXT_SHADOW;
+	}
+	if (resolvedFont.syntheticItalic) element.style.fontStyle = "italic";
+	if (run.strikethrough) element.style.textDecoration = "line-through";
+	if (run.code) {
+		element.style.backgroundColor = CODE_BACKGROUND_COLOR;
+		element.style.borderRadius = "2px";
+		element.style.padding = "0 0.15em";
+		if (!schema.fontVariants?.code || !font[schema.fontVariants.code]) element.style.fontFamily = resolvedFont.fontName ? `'${resolvedFont.fontName}', monospace` : "monospace";
+	}
+};
+var appendTextSpan = (arg) => {
+	const { textBlock, text, run, schema, font } = arg;
+	if (!text) return;
+	const span = document.createElement("span");
+	span.textContent = text;
+	applyInlineMarkdownStyle({
+		element: span,
+		run,
+		schema,
+		font
+	});
+	textBlock.appendChild(span);
+};
+var appendVariableSpan = (arg) => {
+	const { textBlock, variableName, variables, run, schema, font, theme, onChange, stopEditing } = arg;
+	const span = document.createElement("span");
+	span.style.outline = `${theme.colorPrimary} dashed 1px`;
+	applyInlineMarkdownStyle({
+		element: span,
+		run,
+		schema,
+		font
+	});
+	makeElementPlainTextContentEditable(span);
+	span.textContent = variables[variableName] ?? "";
+	span.addEventListener("blur", (e) => {
+		const newValue = e.target.textContent || "";
+		if (newValue !== variables[variableName]) {
+			variables[variableName] = newValue;
+			if (onChange) onChange({
+				key: "content",
+				value: JSON.stringify(variables)
+			});
+			if (stopEditing) stopEditing();
+		}
+	});
+	textBlock.appendChild(span);
+};
+var renderInlineMarkdownVariableSpans = (arg) => {
+	const { runs, variables, textBlock, schema, font, theme, onChange, stopEditing } = arg;
+	textBlock.innerHTML = "";
+	runs.forEach((run) => {
+		let lastIndex = 0;
+		visitVariables(run.text, ({ name, startIndex, endIndex }) => {
+			appendTextSpan({
+				textBlock,
+				text: run.text.slice(lastIndex, startIndex),
+				run,
+				schema,
+				font
+			});
+			appendVariableSpan({
+				textBlock,
+				variableName: name,
+				variables,
+				run,
+				schema,
+				font,
+				theme,
+				onChange,
+				stopEditing
+			});
+			lastIndex = endIndex + 1;
+		});
+		appendTextSpan({
+			textBlock,
+			text: run.text.slice(lastIndex),
+			run,
+			schema,
+			font
+		});
+	});
+};
 /**
 * An optimisation to try to minimise jank while typing.
 * Only check whether variables were modified based on certain key presses.
@@ -457,7 +562,30 @@ var imageSize = (imgBuffer) => {
 };
 //#endregion
 //#region src/graphics/image.ts
-var getCacheKey = (schema, input) => `${schema.type}${input}`;
+/**
+* Build a short fingerprint for a potentially-large base64 image string.
+* Previously `${schema.type}${input}` was used, pinning multi-MB base64
+* strings in the cache Map forever — every unique image input created a
+* permanent Map key whose byte length matched the image itself.
+*
+* The fingerprint is an FNV-1a 32-bit hash over the full input, combined
+* with the schema type and input byte length. An earlier revision sampled
+* three 16-char regions (first + middle + last) instead of hashing, but
+* the first-16 slice is a constant data-URI prefix for any image of the
+* same MIME type (`data:image/png;b…` / `data:image/jpeg…`), contributing
+* no entropy. Hashing every byte removes that weakness at the same O(n)
+* cost, without retaining any slice of the input as a Map key. Keys stay
+* well under ~40 chars regardless of input size.
+*/
+var getCacheKey = (schema, input) => {
+	let hash = 2166136261;
+	for (let i = 0; i < input.length; i++) {
+		hash ^= input.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	const hex = (hash >>> 0).toString(16).padStart(8, "0");
+	return `${schema.type}:${input.length}:${hex}`;
+};
 var fullSize$1 = {
 	width: "100%",
 	height: "100%"