@stll/folio-core 0.0.1-placeholder.0 → 0.1.0

package/dist/layout-bridge/convert/headerFooterLayout.d.ts

@@ -0,0 +1,74 @@
+import { document_d_exports } from "../../types/document.js";
+import { FlowBlock, HeaderFooterContent, ImageRun, Measure, PageMargins } from "../../layout-engine/types.js";
+import { MeasureBlocksFn } from "./footnoteLayout.js";
+import { Node } from "prosemirror-model";
+
+//#region src/layout-bridge/convert/headerFooterLayout.d.ts
+type HeaderFooterMetrics = {
+  section: "header" | "footer";
+  pageSize: {
+    w: number;
+    h: number;
+  };
+  margins: PageMargins;
+};
+declare function normalizeHeaderFooterMeasureBlocks(blocks: FlowBlock[]): FlowBlock[];
+declare function resolveHeaderFooterVisualTop(run: ImageRun, paragraphY: number, flowHeight: number, metrics: HeaderFooterMetrics): number;
+declare function calculateHeaderFooterVisualBounds(blocks: FlowBlock[], measures: Measure[], flowHeight: number, metrics: HeaderFooterMetrics): {
+  visualTop: number;
+  visualBottom: number;
+};
+/**
+ * Compute the header/footer bounds used by `computeHeaderFooterMarginExtender`
+ * to push body margins clear of HF overflow. Excludes anchored/floating objects
+ * (full-page letterheads, watermarks): Word positions them on the page instead
+ * of in the header/footer flow, so they must not reserve body push-down. Keeping
+ * them in `visualBottom` is still correct for the renderer (and for the
+ * page-hash invalidation signal), but the margin extender needs the flow-only
+ * extent.
+ */
+declare function calculateHeaderFooterMarginPushBounds(blocks: FlowBlock[], measures: Measure[], flowHeight: number, metrics: HeaderFooterMetrics): {
+  top: number;
+  bottom: number;
+};
+type ConvertHeaderFooterOptions = {
+  styles?: document_d_exports.StyleDefinitions | null;
+  theme?: document_d_exports.Theme | null;
+  measureBlocks: MeasureBlocksFn; /** Document-wide `w:defaultTabStop` in twips — forwarded to toFlowBlocks. */
+  defaultTabStopTwips?: number;
+  /**
+   * Relationship id of the source HF part. Stamped onto the returned
+   * `HeaderFooterContent.rId` so the painter can emit `data-rid` on the
+   * `.layout-page-header` / `.layout-page-footer` DOM node for the pointer
+   * pipeline (`HiddenHeaderFooterPMs` + `findHfPmSpans`).
+   */
+  rId?: string;
+};
+/**
+ * Convert HeaderFooter (document type) to HeaderFooterContent (render type).
+ *
+ * Routes through the same pipeline as the body: HF.content ->
+ * headerFooterToProseDoc -> toFlowBlocks -> measureBlocks. The inline editor
+ * uses the same conversion chain, so block support (paragraph, table, image,
+ * textBox, fields) and the inline editor's content stay in lockstep.
+ *
+ * No result cache — typing in the body shouldn't recompute HF, but the
+ * upstream cache keyed on `HeaderFooter` identity went stale after inline
+ * edits. The HF pipeline runs at most four times per layout pass and the
+ * paragraph-level measurement cache one layer down covers most of the work.
+ */
+declare function convertHeaderFooterToContent(headerFooter: document_d_exports.HeaderFooter | null | undefined, contentWidth: number, metrics: HeaderFooterMetrics, options: ConvertHeaderFooterOptions): HeaderFooterContent | undefined;
+/**
+ * Same as {@link convertHeaderFooterToContent}, but sourced from a live
+ * ProseMirror document instead of `HeaderFooter.content`. Used by the
+ * persistent hidden HF EditorView pipeline so the painter renders the PM's
+ * current state (Word-style WYSIWYG: every keystroke repaints).
+ *
+ * The pmDoc is expected to be a body-shaped PM doc (the result of
+ * `headerFooterToProseDoc` at mount, plus any user edits applied since).
+ * Theme + styles do NOT need to be threaded again — they only matter for the
+ * initial parse path; subsequent transformations are PM-internal.
+ */
+declare function convertHeaderFooterPmDocToContent(pmDoc: Node | null | undefined, contentWidth: number, metrics: HeaderFooterMetrics, options: Omit<ConvertHeaderFooterOptions, "styles">): HeaderFooterContent | undefined;
+//#endregion
+export { ConvertHeaderFooterOptions, HeaderFooterMetrics, calculateHeaderFooterMarginPushBounds, calculateHeaderFooterVisualBounds, convertHeaderFooterPmDocToContent, convertHeaderFooterToContent, normalizeHeaderFooterMeasureBlocks, resolveHeaderFooterVisualTop };

package/dist/layout-bridge/convert/headerFooterLayout.js

@@ -0,0 +1,432 @@
+import { emuToPixels } from "../../utils/units.js";
+import { isFloatingImageRun, isFloatingTextBoxBlock } from "../../layout-engine/types.js";
+import { toFlowBlocks } from "./toFlowBlocks.js";
+import { headerFooterToProseDoc } from "../../prosemirror/conversion/toProseDoc.js";
+//#region src/layout-bridge/convert/headerFooterLayout.ts
+function isAnchoredImageRun(run) {
+	if (run.kind !== "image") return false;
+	if (run.position) return true;
+	return isFloatingImageRun(run);
+}
+function hasAuthoredVisualContent(block) {
+	if (block.kind !== "paragraph") return false;
+	const attrs = block.attrs;
+	if (!attrs) return false;
+	if (attrs.borders?.top || attrs.borders?.bottom) return true;
+	if (attrs.spacingExplicit?.before || attrs.spacingExplicit?.after) return true;
+	return false;
+}
+function normalizeHeaderFooterMeasureBlocks(blocks) {
+	return normalizeFlowBlockArray(blocks);
+}
+function normalizeFlowBlockArray(blocks) {
+	const trailingEmptyAfterTable = /* @__PURE__ */ new Set();
+	const lastIndex = blocks.length - 1;
+	if (lastIndex > 0) {
+		const cur = blocks[lastIndex];
+		if (blocks[lastIndex - 1]?.kind === "table" && cur?.kind === "paragraph" && cur.runs.length === 0 && !hasAuthoredVisualContent(cur)) trailingEmptyAfterTable.add(lastIndex);
+	}
+	return blocks.map((block, index) => {
+		if (block.kind === "table") return normalizeTableBlock(block);
+		if (block.kind !== "paragraph") return block;
+		const isTrailingEmpty = trailingEmptyAfterTable.has(index);
+		const explicit = block.attrs?.spacingExplicit;
+		const hasResolvedBefore = block.attrs?.spacing?.before != null;
+		const hasResolvedAfter = block.attrs?.spacing?.after != null;
+		const beforeIsInherited = hasResolvedBefore && !explicit?.before;
+		const afterIsInherited = hasResolvedAfter && !explicit?.after;
+		const stripsSpacing = beforeIsInherited || afterIsInherited;
+		const stripsImages = block.runs.some(isAnchoredImageRun);
+		if (!stripsSpacing && !stripsImages && !isTrailingEmpty) return block;
+		let inlineRuns = block.runs;
+		if (stripsImages) {
+			inlineRuns = block.runs.filter((r) => !isAnchoredImageRun(r));
+			if (inlineRuns.length === 0) inlineRuns = [{
+				kind: "text",
+				text: ""
+			}];
+		}
+		let attrs = block.attrs;
+		if (stripsSpacing && attrs?.spacing) {
+			const newSpacing = { ...attrs.spacing };
+			if (!explicit?.before) delete newSpacing.before;
+			if (!explicit?.after) delete newSpacing.after;
+			attrs = {
+				...attrs,
+				spacing: newSpacing
+			};
+		}
+		if (isTrailingEmpty) attrs = {
+			...attrs,
+			suppressEmptyParagraphHeight: true
+		};
+		return attrs ? {
+			...block,
+			runs: inlineRuns,
+			attrs
+		} : {
+			...block,
+			runs: inlineRuns
+		};
+	});
+}
+function normalizeTableBlock(block) {
+	const blockState = { changed: false };
+	const rows = block.rows.map((row) => {
+		const rowState = { changed: false };
+		const cells = row.cells.map((cell) => {
+			const normalizedBlocks = normalizeFlowBlockArray(cell.blocks);
+			if (!normalizedBlocks.some((normalizedBlock, idx) => normalizedBlock !== cell.blocks[idx])) return cell;
+			rowState.changed = true;
+			return {
+				...cell,
+				blocks: normalizedBlocks
+			};
+		});
+		if (!rowState.changed) return row;
+		blockState.changed = true;
+		return {
+			...row,
+			cells
+		};
+	});
+	return blockState.changed ? {
+		...block,
+		rows
+	} : block;
+}
+function getPositionAlignment(axis) {
+	return axis?.align ?? axis?.alignment;
+}
+function resolveHeaderFooterVisualTop(run, paragraphY, flowHeight, metrics) {
+	const flowTop = metrics.section === "header" ? metrics.margins.header ?? 48 : metrics.pageSize.h - (metrics.margins.footer ?? 48) - flowHeight;
+	const vertical = run.position?.vertical;
+	if (!vertical) return paragraphY;
+	const align = getPositionAlignment(vertical);
+	const offsetPx = vertical.posOffset !== void 0 ? emuToPixels(vertical.posOffset) : void 0;
+	if (vertical.relativeTo === "page") {
+		if (offsetPx !== void 0) return offsetPx - flowTop;
+		if (align === "top") return -flowTop;
+		if (align === "bottom") return metrics.pageSize.h - run.height - flowTop;
+		if (align === "center") return (metrics.pageSize.h - run.height) / 2 - flowTop;
+	}
+	if (vertical.relativeTo === "margin") {
+		const marginTop = metrics.margins.top;
+		const marginHeight = metrics.pageSize.h - metrics.margins.top - metrics.margins.bottom;
+		if (offsetPx !== void 0) return marginTop + offsetPx - flowTop;
+		if (align === "top") return marginTop - flowTop;
+		if (align === "bottom") return marginTop + marginHeight - run.height - flowTop;
+		if (align === "center") return marginTop + (marginHeight - run.height) / 2 - flowTop;
+	}
+	if (offsetPx !== void 0) return paragraphY + offsetPx;
+	return paragraphY;
+}
+function resolveHeaderFooterFloatingTableVisualTop(floating, measure, sourceY, flowHeight, metrics) {
+	const flowTop = metrics.section === "header" ? metrics.margins.header ?? 48 : metrics.pageSize.h - (metrics.margins.footer ?? 48) - flowHeight;
+	const vertAnchor = floating.vertAnchor ?? "margin";
+	const vertFrameHeight = vertAnchor === "page" ? metrics.pageSize.h : metrics.pageSize.h - metrics.margins.top - metrics.margins.bottom;
+	const vertFrameOffset = vertAnchor === "page" ? -flowTop : metrics.margins.top - flowTop;
+	if (floating.tblpYSpec === "top") return vertFrameOffset;
+	if (floating.tblpYSpec === "bottom") return vertFrameOffset + vertFrameHeight - measure.totalHeight;
+	if (floating.tblpYSpec === "center") return vertFrameOffset + (vertFrameHeight - measure.totalHeight) / 2;
+	if (floating.tblpY !== void 0) return vertFrameOffset + floating.tblpY;
+	return sourceY;
+}
+function isBehindDocImageBlock(block) {
+	return block.kind === "image" && block.anchor?.behindDoc === true;
+}
+function isPositionedHeaderFooterTextBoxBlock(block) {
+	if (block.displayMode === "block" || block.displayMode === "inline") return false;
+	return isFloatingTextBoxBlock(block);
+}
+function calculateHeaderFooterVisualBounds(blocks, measures, flowHeight, metrics) {
+	let visualTop = 0;
+	let visualBottom = flowHeight;
+	let cursorY = 0;
+	for (let i = 0; i < blocks.length; i++) {
+		const block = blocks[i];
+		const measure = measures[i];
+		if (!block || !measure) continue;
+		if (block.kind === "paragraph" && measure.kind === "paragraph") {
+			const paragraphStartY = cursorY;
+			const paragraphBottomY = paragraphStartY + measure.totalHeight;
+			visualTop = Math.min(visualTop, paragraphStartY);
+			visualBottom = Math.max(visualBottom, paragraphBottomY);
+			for (const run of block.runs) {
+				if (run.kind !== "image") continue;
+				if (!run.position && !isFloatingImageRun(run)) continue;
+				const runTop = resolveHeaderFooterVisualTop(run, paragraphStartY, flowHeight, metrics);
+				visualTop = Math.min(visualTop, runTop);
+				visualBottom = Math.max(visualBottom, runTop + run.height);
+			}
+			cursorY = paragraphBottomY;
+		} else {
+			let blockHeight;
+			let advancesCursor = true;
+			if (block.kind === "table" && measure.kind === "table") {
+				blockHeight = measure.totalHeight;
+				if (block.floating) advancesCursor = false;
+			} else if (block.kind === "image" && measure.kind === "image") blockHeight = measure.height;
+			else if (block.kind === "textBox" && measure.kind === "textBox") {
+				blockHeight = measure.height;
+				if (isPositionedHeaderFooterTextBoxBlock(block)) advancesCursor = false;
+			} else continue;
+			if (advancesCursor) {
+				const blockBottomY = cursorY + blockHeight;
+				visualTop = Math.min(visualTop, cursorY);
+				visualBottom = Math.max(visualBottom, blockBottomY);
+				cursorY = blockBottomY;
+			} else if (block.kind === "table" && block.floating && measure.kind === "table") {
+				const blockTop = resolveHeaderFooterFloatingTableVisualTop(block.floating, measure, cursorY, flowHeight, metrics);
+				visualTop = Math.min(visualTop, blockTop);
+				visualBottom = Math.max(visualBottom, blockTop + blockHeight);
+			} else if (block.kind === "textBox" && isPositionedHeaderFooterTextBoxBlock(block) && measure.kind === "textBox") {
+				visualTop = Math.min(visualTop, cursorY);
+				visualBottom = Math.max(visualBottom, cursorY + measure.height);
+			}
+		}
+	}
+	return {
+		visualTop,
+		visualBottom
+	};
+}
+/**
+* Compute the header/footer bounds used by `computeHeaderFooterMarginExtender`
+* to push body margins clear of HF overflow. Excludes anchored/floating objects
+* (full-page letterheads, watermarks): Word positions them on the page instead
+* of in the header/footer flow, so they must not reserve body push-down. Keeping
+* them in `visualBottom` is still correct for the renderer (and for the
+* page-hash invalidation signal), but the margin extender needs the flow-only
+* extent.
+*/
+function calculateHeaderFooterMarginPushBounds(blocks, measures, flowHeight, metrics) {
+	let top = 0;
+	let bottom = 0;
+	let cursorY = 0;
+	for (let i = 0; i < blocks.length; i++) {
+		const block = blocks[i];
+		const measure = measures[i];
+		if (!block || !measure) continue;
+		if (block.kind === "paragraph" && measure.kind === "paragraph") {
+			const paragraphBottomY = cursorY + measure.totalHeight;
+			top = Math.min(top, cursorY);
+			bottom = Math.max(bottom, paragraphBottomY);
+			cursorY = paragraphBottomY;
+		} else if (isBehindDocImageBlock(block)) continue;
+		else {
+			let blockHeight;
+			let advancesCursor = true;
+			if (block.kind === "table" && measure.kind === "table") {
+				blockHeight = measure.totalHeight;
+				if (block.floating) advancesCursor = false;
+			} else if (block.kind === "image" && measure.kind === "image") {
+				if (block.anchor?.isAnchored) continue;
+				blockHeight = measure.height;
+			} else if (block.kind === "textBox" && measure.kind === "textBox") {
+				if (isPositionedHeaderFooterTextBoxBlock(block)) continue;
+				blockHeight = measure.height;
+			} else continue;
+			if (advancesCursor) {
+				const blockBottomY = cursorY + blockHeight;
+				top = Math.min(top, cursorY);
+				bottom = Math.max(bottom, blockBottomY);
+				cursorY = blockBottomY;
+			} else if (block.kind === "table" && block.floating && measure.kind === "table") {
+				const blockTop = resolveHeaderFooterFloatingTableVisualTop(block.floating, measure, cursorY, flowHeight, metrics);
+				top = Math.min(top, blockTop);
+				bottom = Math.max(bottom, blockTop + blockHeight);
+			}
+		}
+	}
+	return {
+		top,
+		bottom
+	};
+}
+/**
+* Convert HeaderFooter (document type) to HeaderFooterContent (render type).
+*
+* Routes through the same pipeline as the body: HF.content ->
+* headerFooterToProseDoc -> toFlowBlocks -> measureBlocks. The inline editor
+* uses the same conversion chain, so block support (paragraph, table, image,
+* textBox, fields) and the inline editor's content stay in lockstep.
+*
+* No result cache — typing in the body shouldn't recompute HF, but the
+* upstream cache keyed on `HeaderFooter` identity went stale after inline
+* edits. The HF pipeline runs at most four times per layout pass and the
+* paragraph-level measurement cache one layer down covers most of the work.
+*/
+function convertHeaderFooterToContent(headerFooter, contentWidth, metrics, options) {
+	if (!headerFooter || headerFooter.content.length === 0) return;
+	const proseDocOptions = {};
+	if (options.styles) proseDocOptions.styles = options.styles;
+	if (options.theme !== void 0) proseDocOptions.theme = options.theme;
+	const pmDoc = headerFooterToProseDoc(headerFooter.content, proseDocOptions);
+	const flowOptions = {};
+	if (options.theme !== void 0) flowOptions.theme = options.theme;
+	if (options.defaultTabStopTwips !== void 0) flowOptions.defaultTabStopTwips = options.defaultTabStopTwips;
+	return finalizeHeaderFooterContent(toFlowBlocks(pmDoc, flowOptions), contentWidth, metrics, options);
+}
+/**
+* Same as {@link convertHeaderFooterToContent}, but sourced from a live
+* ProseMirror document instead of `HeaderFooter.content`. Used by the
+* persistent hidden HF EditorView pipeline so the painter renders the PM's
+* current state (Word-style WYSIWYG: every keystroke repaints).
+*
+* The pmDoc is expected to be a body-shaped PM doc (the result of
+* `headerFooterToProseDoc` at mount, plus any user edits applied since).
+* Theme + styles do NOT need to be threaded again — they only matter for the
+* initial parse path; subsequent transformations are PM-internal.
+*/
+function convertHeaderFooterPmDocToContent(pmDoc, contentWidth, metrics, options) {
+	if (!pmDoc || pmDoc.content.size === 0) return;
+	const flowOptions = {};
+	if (options.theme !== void 0) flowOptions.theme = options.theme;
+	if (options.defaultTabStopTwips !== void 0) flowOptions.defaultTabStopTwips = options.defaultTabStopTwips;
+	return finalizeHeaderFooterContent(toFlowBlocks(pmDoc, flowOptions), contentWidth, metrics, options);
+}
+function finalizeHeaderFooterContent(blocks, contentWidth, metrics, options) {
+	if (blocks.length === 0) return;
+	const blocksForMeasure = normalizeHeaderFooterMeasureBlocks(blocks);
+	const measures = options.measureBlocks(blocksForMeasure, contentWidth);
+	let flowHeight = 0;
+	for (let i = 0; i < measures.length; i++) {
+		const m = measures[i];
+		const b = blocks[i];
+		if (!m || !b) continue;
+		flowHeight += getHeaderFooterFlowMeasureHeight(b, m);
+	}
+	const { visualTop, visualBottom } = calculateHeaderFooterVisualBounds(blocks, measures, flowHeight, metrics);
+	const { top: marginPushTop, bottom: marginPushBottom } = calculateHeaderFooterMarginPushBounds(blocks, measures, flowHeight, metrics);
+	return {
+		blocks,
+		measures,
+		height: flowHeight,
+		visualTop,
+		visualBottom,
+		marginPushTop,
+		marginPushBottom,
+		textSig: computeHeaderFooterTextSig(blocks),
+		...options.rId ? { rId: options.rId } : {}
+	};
+}
+function getHeaderFooterFlowMeasureHeight(block, measure) {
+	if (block.kind === "paragraph" && measure.kind === "paragraph") return measure.totalHeight;
+	if (block.kind === "table" && measure.kind === "table") {
+		if (block.floating) return 0;
+		return measure.totalHeight;
+	}
+	if (block.kind === "image" && measure.kind === "image") {
+		if (block.anchor?.isAnchored) return 0;
+		return measure.height;
+	}
+	if (block.kind === "textBox" && measure.kind === "textBox") {
+		if (isPositionedHeaderFooterTextBoxBlock(block)) return 0;
+		return measure.height;
+	}
+	return 0;
+}
+/**
+* Cheap content fingerprint for the painter's incremental-render cache. The
+* default fields hashed by `computeOptionsHash` (block count + flow height +
+* visual bounds) miss same-height in-place edits — typing a replacement
+* character, toggling bold, etc. — so the painter's incremental path then
+* skips re-rendering page shells and the user's HF edits stay invisible
+* until something else triggers a full repaint (Codex #487 P1 follow-up:
+* 21:02 review; extended for run formatting + fields per 21:28 review).
+*
+* For each run carry text + every visual-affecting field: text characters,
+* field type (PAGE / NUMPAGES / DATE / TIME), and the full RunFormatting
+* record (bold, italic, color, underline, fontSize, font, etc.). Toggling
+* bold or inserting a PAGE field on existing same-height content now
+* differentiates the signature and forces a repaint. Tables, images, and
+* text boxes are summarised by kind + dims so resize / image swap also
+* invalidate. JSON.stringify is moderately expensive but folio HF is
+* bounded (a handful of paragraphs, max).
+*/
+function computeHeaderFooterTextSig(blocks) {
+	return blocks.map(blockSig).join("|");
+}
+function blockSig(b) {
+	if (b.kind === "paragraph") {
+		let text = `p:${serializeParagraphAttrs(b.attrs)}|`;
+		for (const r of b.runs) if (r.kind === "text") text += `T:${r.text}|${serializeRunFmt(r)};`;
+		else if (r.kind === "tab") text += `\\t|${serializeRunFmt(r)};`;
+		else if (r.kind === "lineBreak") text += "\\n;";
+		else if (r.kind === "image") text += `[i${r.width}x${r.height}|${r.src}|${r.transform ?? ""}|${r.wrapType ?? ""}];`;
+		else if (r.kind === "math") text += `M:${r.display}|${r.ommlXml};`;
+		else text += `F:${r.fieldType}|${serializeRunFmt(r)};`;
+		return text;
+	}
+	if (b.kind === "table") {
+		const cellParts = [];
+		for (const row of b.rows) for (const cell of row.cells) cellParts.push(cell.blocks.map(blockSig).join(","));
+		return `t:${b.rows.length}:${cellParts.join("|")}`;
+	}
+	if (b.kind === "image") return `i:${b.width}x${b.height}|${b.src}|${b.transform ?? ""}|${b.anchor?.behindDoc ? "behind" : ""}`;
+	if (b.kind === "textBox") {
+		const inner = b.blocks;
+		if (Array.isArray(inner) && inner.length > 0) return `tb:${inner.map(blockSig).join(",")}`;
+		return "tb";
+	}
+	return "";
+}
+function serializeParagraphAttrs(attrs) {
+	if (!attrs) return "";
+	const keys = [
+		"alignment",
+		"bidi",
+		"indent",
+		"spacing",
+		"styleId",
+		"borders",
+		"shading",
+		"contextualSpacing",
+		"keepNext",
+		"keepLines",
+		"pageBreakBefore",
+		"numPr",
+		"listMarker",
+		"listIsBullet",
+		"listMarkerHidden",
+		"listMarkerSuffix",
+		"tabs"
+	];
+	const out = {};
+	for (const k of keys) {
+		const v = attrs[k];
+		if (v !== void 0 && v !== null) out[k] = v;
+	}
+	return JSON.stringify(out);
+}
+/**
+* Serialise the RunFormatting fields that actually drive the painter's
+* visual output. The Run type spreads RunFormatting in place, so we project
+* a small shape and JSON-stringify it; properties that are undefined are
+* skipped so the resulting string stays compact for unstyled runs.
+*/
+function serializeRunFmt(run) {
+	const keys = [
+		"bold",
+		"italic",
+		"underline",
+		"strikethrough",
+		"color",
+		"highlightColor",
+		"fontSize",
+		"fontFamily",
+		"verticalAlign",
+		"letterSpacing",
+		"smallCaps",
+		"allCaps"
+	];
+	const out = {};
+	for (const k of keys) {
+		const v = run[k];
+		if (v !== void 0 && v !== null) out[k] = v;
+	}
+	return JSON.stringify(out);
+}
+//#endregion
+export { calculateHeaderFooterMarginPushBounds, calculateHeaderFooterVisualBounds, convertHeaderFooterPmDocToContent, convertHeaderFooterToContent, normalizeHeaderFooterMeasureBlocks, resolveHeaderFooterVisualTop };

package/dist/layout-bridge/convert/templatePreviewFlow.d.ts

@@ -0,0 +1,36 @@
+import { FlowBlock } from "../../layout-engine/types.js";
+import { TemplatePreviewValue } from "../../prosemirror/plugins/templatePreviewValues.js";
+
+//#region src/layout-bridge/convert/templatePreviewFlow.d.ts
+/** One marker→value substitution, in PM doc positions. */
+type TemplatePreviewFlowEntry = {
+  /** Inclusive PM doc position of the marker start. */from: number; /** Exclusive PM doc position of the marker end. */
+  to: number; /** The typed value displayed in place of the marker. */
+  value: TemplatePreviewValue;
+};
+type TemplatePreviewFlowOptions = {
+  entries: readonly TemplatePreviewFlowEntry[]; /** `highlighted` marks substituted runs for the accent-chip CSS. */
+  mode: "highlighted" | "plain";
+};
+/**
+ * Replace each entry's marker range with its preview value across the given
+ * flow blocks (recursing into table cells and text boxes). Returns the input
+ * array unchanged when there is nothing to substitute.
+ */
+declare function applyTemplatePreviewToBlocks(blocks: FlowBlock[], {
+  entries,
+  mode
+}: TemplatePreviewFlowOptions): FlowBlock[];
+/**
+ * PM range covering every substitution that differs between two preview
+ * states (changed, added, or removed entries), or `null` when the
+ * substituted flow content is identical. Feeds the layout pipeline's
+ * dirty-range invalidation so typing a value re-measures only the blocks
+ * hosting the affected markers.
+ */
+declare function templatePreviewDirtyRange(previous: readonly TemplatePreviewFlowEntry[], next: readonly TemplatePreviewFlowEntry[]): {
+  from: number;
+  to: number;
+} | null;
+//#endregion
+export { TemplatePreviewFlowEntry, TemplatePreviewFlowOptions, applyTemplatePreviewToBlocks, templatePreviewDirtyRange };