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

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

@@ -0,0 +1,176 @@
+import { templatePreviewValueFingerprint } from "../../prosemirror/plugins/templatePreviewValues.js";
+//#region src/layout-bridge/convert/templatePreviewFlow.ts
+/**
+* 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.
+*/
+function applyTemplatePreviewToBlocks(blocks, { entries, mode }) {
+	if (entries.length === 0) return blocks;
+	const sorted = [...entries].sort((a, b) => a.from - b.from);
+	let changed = false;
+	const next = [];
+	for (const block of blocks) {
+		const transformed = transformBlock(block, sorted, mode);
+		changed ||= transformed !== block;
+		next.push(transformed);
+	}
+	return changed ? next : blocks;
+}
+function transformBlock(block, entries, mode) {
+	if (block.kind === "paragraph") return transformParagraph(block, entries, mode);
+	if (block.kind === "table") return transformTable(block, entries, mode);
+	if (block.kind === "textBox") return transformTextBox(block, entries, mode);
+	return block;
+}
+function transformTable(block, entries, mode) {
+	let changed = false;
+	const rows = [];
+	for (const row of block.rows) {
+		let rowChanged = false;
+		const cells = [];
+		for (const cell of row.cells) {
+			let cellChanged = false;
+			const cellBlocks = [];
+			for (const cellBlock of cell.blocks) {
+				const transformed = transformBlock(cellBlock, entries, mode);
+				cellChanged ||= transformed !== cellBlock;
+				cellBlocks.push(transformed);
+			}
+			cells.push(cellChanged ? {
+				...cell,
+				blocks: cellBlocks
+			} : cell);
+			rowChanged ||= cellChanged;
+		}
+		rows.push(rowChanged ? {
+			...row,
+			cells
+		} : row);
+		changed ||= rowChanged;
+	}
+	return changed ? {
+		...block,
+		rows
+	} : block;
+}
+function transformTextBox(block, entries, mode) {
+	let changed = false;
+	const content = [];
+	for (const paragraph of block.content) {
+		const transformed = transformParagraph(paragraph, entries, mode);
+		changed ||= transformed !== paragraph;
+		content.push(transformed);
+	}
+	return changed ? {
+		...block,
+		content
+	} : block;
+}
+function transformParagraph(block, entries, mode) {
+	const blockFrom = block.pmStart;
+	const blockTo = block.pmEnd;
+	if (blockFrom !== void 0 && blockTo !== void 0) {
+		if (!entries.some((entry) => entry.from < blockTo && entry.to > blockFrom)) return block;
+	}
+	const runs = [];
+	let changed = false;
+	for (const run of block.runs) if (transformRun(run, entries, mode, runs)) changed = true;
+	return changed ? {
+		...block,
+		runs
+	} : block;
+}
+/**
+* Push the transformed projection of `run` onto `out`. Returns true when the
+* run was changed (sliced, replaced, or dropped); unchanged runs are pushed
+* by reference.
+*/
+function transformRun(run, entries, mode, out) {
+	const pmStart = run.pmStart;
+	const pmEnd = run.pmEnd;
+	if (pmStart === void 0 || pmEnd === void 0) {
+		out.push(run);
+		return false;
+	}
+	const overlapping = entries.filter((entry) => entry.from < pmEnd && entry.to > pmStart);
+	if (overlapping.length === 0) {
+		out.push(run);
+		return false;
+	}
+	if (run.kind !== "text") return true;
+	let cursor = pmStart;
+	for (const entry of overlapping) {
+		if (entry.from > cursor) out.push(sliceTextRun(run, pmStart, cursor, entry.from));
+		if (entry.from >= pmStart) out.push(...buildValueRuns(run, entry, mode));
+		cursor = Math.min(entry.to, pmEnd);
+	}
+	if (cursor < pmEnd) out.push(sliceTextRun(run, pmStart, cursor, pmEnd));
+	return true;
+}
+/** Slice `run` to the PM range [from, to); positions map 1:1 onto chars. */
+function sliceTextRun(run, base, from, to) {
+	return {
+		...run,
+		text: run.text.slice(from - base, to - base),
+		pmStart: from,
+		pmEnd: to
+	};
+}
+/**
+* The value run(s) replacing a marker. A plain value is one run carrying the
+* host run's formatting; a rich value emits one run per span, each layering
+* its own bold/italic over the host formatting (host bold stays bold, a
+* span's flags OR in). Every run keeps the marker's full PM range so
+* click-to-position keeps resolving into the marker.
+*/
+function buildValueRuns(host, entry, mode) {
+	if (typeof entry.value === "string") return [{
+		...host,
+		text: entry.value,
+		pmStart: entry.from,
+		pmEnd: entry.to,
+		templatePreview: mode
+	}];
+	return entry.value.runs.map((span) => {
+		const valueRun = {
+			...host,
+			text: span.text,
+			pmStart: entry.from,
+			pmEnd: entry.to,
+			templatePreview: mode
+		};
+		if (span.bold === true) valueRun.bold = true;
+		if (span.italic === true) valueRun.italic = true;
+		return valueRun;
+	});
+}
+const entryKey = (entry) => `${entry.from}:${entry.to}:${templatePreviewValueFingerprint(entry.value)}`;
+/**
+* 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.
+*/
+function templatePreviewDirtyRange(previous, next) {
+	const previousKeys = new Set(previous.map(entryKey));
+	const nextKeys = new Set(next.map(entryKey));
+	let from = Number.POSITIVE_INFINITY;
+	let to = Number.NEGATIVE_INFINITY;
+	for (const entry of previous) if (!nextKeys.has(entryKey(entry))) {
+		from = Math.min(from, entry.from);
+		to = Math.max(to, entry.to);
+	}
+	for (const entry of next) if (!previousKeys.has(entryKey(entry))) {
+		from = Math.min(from, entry.from);
+		to = Math.max(to, entry.to);
+	}
+	if (from === Number.POSITIVE_INFINITY) return null;
+	return {
+		from,
+		to
+	};
+}
+//#endregion
+export { applyTemplatePreviewToBlocks, templatePreviewDirtyRange };

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

@@ -0,0 +1,65 @@
+import { document_d_exports } from "../../types/document.js";
+import { BorderStyle, FlowBlock } from "../../layout-engine/types.js";
+import { Node } from "prosemirror-model";
+
+//#region src/layout-bridge/convert/toFlowBlocks.d.ts
+/**
+ * Options for the conversion.
+ */
+type ToFlowBlocksOptions = {
+  /** Default font family. */defaultFont?: string; /** Default font size in points. */
+  defaultSize?: number; /** Theme for resolving theme colors. */
+  theme?: document_d_exports.Theme | null; /** Page content height in pixels (pageHeight - marginTop - marginBottom). Images taller than this are scaled down to fit. */
+  pageContentHeight?: number; /** Shared list counters for nested containers. */
+  listCounters?: Map<number, number[]>; /** Latest concrete counters by abstract numbering definition. */
+  listAbstractCounters?: Map<number, number[]>; /** Shared startOverride state for nested containers. */
+  listSeenNumIds?: Set<string>;
+  /**
+   * Parallel counter state for the "original" (pre-revision) document, used to
+   * number tracked-deletion list items. Word numbers inserted and deleted list
+   * runs as if they never coexist: insertions get final-document numbering,
+   * deletions keep their original numbering. Without a separate stream a deleted
+   * item continues the counter of the inserted item before it (a, b → c, d, e
+   * instead of a, b and a, b, c). Normal items advance both streams.
+   */
+  originalListCounters?: Map<number, number[]>; /** Latest concrete original-stream counters by abstract numbering definition. */
+  originalListAbstractCounters?: Map<number, number[]>; /** Original-stream startOverride state. */
+  originalListSeenNumIds?: Set<string>;
+  /**
+   * Document-wide `w:defaultTabStop` (§17.6.13) in twips. Stamped onto
+   * every paragraph block so paragraph-local layout helpers (list marker
+   * tab-stop math) can read it without taking a `Document` reference.
+   * Defaults to the OOXML 720-twip value when absent.
+   */
+  defaultTabStopTwips?: number;
+};
+declare function formatCounter(value: number, format: document_d_exports.NumberFormat | undefined): string;
+declare function resolveListTemplate(template: string, counters: number[], levelFormats: document_d_exports.NumberFormat[] | undefined, forceDecimal?: boolean): string;
+/**
+ * Reset the block ID counter (useful for testing).
+ */
+declare function resetBlockIdCounter(): void;
+/**
+ * Convert an OOXML BorderSpec to a layout-engine BorderStyle.
+ * Shared by paragraph borders, cell borders, and header/footer borders.
+ */
+declare function convertBorderSpecToLayout(border: {
+  style?: string;
+  size?: number;
+  space?: number;
+  color?: {
+    rgb?: string;
+    themeColor?: string;
+    themeTint?: string;
+    themeShade?: string;
+  };
+}, theme?: document_d_exports.Theme | null): BorderStyle | undefined;
+/**
+ * Convert a ProseMirror document to FlowBlock array.
+ *
+ * Walks the document tree, converting each node to the appropriate block type.
+ * Tracks pmStart/pmEnd positions for each block for click-to-position mapping.
+ */
+declare function toFlowBlocks(doc: Node, options?: ToFlowBlocksOptions): FlowBlock[];
+//#endregion
+export { ToFlowBlocksOptions, convertBorderSpecToLayout, formatCounter, resetBlockIdCounter, resolveListTemplate, toFlowBlocks };