@stll/folio-core 0.36.0 → 0.37.1

package/dist/internal/pageBreakRunPartition.js

@@ -0,0 +1,35 @@
+//#region src/internal/pageBreakRunPartition.ts
+/** Partition ordered runs with one monotonic cursor; each run is consumed once and peeked once. */
+const partitionRunsAtPageBreaks = (runs, pageBreaks) => {
+	const partitions = [];
+	let nextRunIndex = 0;
+	for (const pageBreak of pageBreaks) {
+		const before = [];
+		while (nextRunIndex < runs.length) {
+			const run = runs[nextRunIndex];
+			if (!run) break;
+			if (run.pmEnd !== void 0 && run.pmEnd <= pageBreak.pmStart) {
+				before.push(run);
+				nextRunIndex += 1;
+				continue;
+			}
+			if (run.pmStart !== void 0 && run.pmStart >= pageBreak.pmEnd) break;
+			return {
+				type: "overlap",
+				pageBreak,
+				run
+			};
+		}
+		partitions.push({
+			before,
+			pageBreak
+		});
+	}
+	return {
+		type: "partitioned",
+		partitions,
+		remaining: runs.slice(nextRunIndex)
+	};
+};
+//#endregion
+export { partitionRunsAtPageBreaks };

package/dist/internal/pageBreakRunSourceDescendantIndex.d.ts

@@ -0,0 +1,15 @@
+import { document_d_exports } from "../types/document.js";
+//#region src/internal/pageBreakRunSourceDescendantIndex.d.ts
+type PageBreakRunSourceDescendantIndex = {
+  containsPageBreakRun: (content: readonly document_d_exports.BlockContent[]) => boolean;
+  paragraphFeatures: (paragraph: document_d_exports.Paragraph) => PageBreakRunSourceParagraphFeatures;
+};
+type PageBreakRunSourceParagraphFeatures = {
+  hasPageBreakRun: boolean;
+  hasTextBoxShape: boolean;
+  pageBreakSharesTextBoxShape: boolean;
+};
+/** Index authored page-break descendants once for one source conversion. */
+declare const buildPageBreakRunSourceDescendantIndex: (rootContent: readonly document_d_exports.BlockContent[]) => PageBreakRunSourceDescendantIndex;
+//#endregion
+export { PageBreakRunSourceDescendantIndex, PageBreakRunSourceParagraphFeatures, buildPageBreakRunSourceDescendantIndex };

package/dist/internal/pageBreakRunSourceDescendantIndex.js

@@ -0,0 +1,126 @@
+import { panic } from "better-result";
+//#region src/internal/pageBreakRunSourceDescendantIndex.ts
+const SOURCE_FLAGS = {
+	containsPageBreak: 1,
+	paragraphPageBreak: 2,
+	paragraphTextBoxShape: 4,
+	pageBreakSharesTextBoxShape: 8
+};
+const hasFlag = (flags, flag) => (flags & flag) !== 0;
+/** Index authored page-break descendants once for one source conversion. */
+const buildPageBreakRunSourceDescendantIndex = (rootContent) => {
+	const flagsByObject = /* @__PURE__ */ new WeakMap();
+	const inspectObject = (node, inspectChildren) => {
+		const cached = flagsByObject.get(node);
+		if (cached !== void 0) return cached;
+		flagsByObject.set(node, 0);
+		const flags = inspectChildren();
+		flagsByObject.set(node, flags);
+		return flags;
+	};
+	const inspectMany = (items, inspect) => {
+		let flags = 0;
+		for (const item of items) flags |= inspect(item);
+		return flags;
+	};
+	const inspectRunContent = (content) => inspectObject(content, () => {
+		switch (content.type) {
+			case "break": return content.breakType === "page" ? SOURCE_FLAGS.containsPageBreak | SOURCE_FLAGS.paragraphPageBreak : 0;
+			case "shape": {
+				const { textBody } = content.shape;
+				if (!textBody) return 0;
+				return inspectBlocks(textBody.content) & SOURCE_FLAGS.containsPageBreak | SOURCE_FLAGS.paragraphTextBoxShape;
+			}
+			case "drawing":
+			case "endnoteRef":
+			case "fieldChar":
+			case "footnoteRef":
+			case "instrText":
+			case "noBreakHyphen":
+			case "renderedPageBreak":
+			case "softHyphen":
+			case "symbol":
+			case "tab":
+			case "text": return 0;
+			default: return content;
+		}
+	});
+	const inspectRun = (run) => inspectObject(run, () => {
+		const flags = inspectMany(run.content, inspectRunContent);
+		if (hasFlag(flags, SOURCE_FLAGS.paragraphPageBreak) && hasFlag(flags, SOURCE_FLAGS.paragraphTextBoxShape)) return flags | SOURCE_FLAGS.pageBreakSharesTextBoxShape;
+		return flags;
+	});
+	const inspectParagraphContent = (content) => {
+		if (content.type === "run") return inspectRun(content);
+		return inspectObject(content, () => {
+			switch (content.type) {
+				case "hyperlink": return inspectMany(content.children, inspectParagraphContent);
+				case "insertion":
+				case "deletion":
+				case "moveFrom":
+				case "moveTo":
+				case "inlineSdt": return inspectMany(content.content, inspectParagraphContent);
+				case "simpleField": {
+					const fieldResultFlags = inspectMany(content.content, inspectParagraphContent);
+					if (hasFlag(fieldResultFlags, SOURCE_FLAGS.paragraphPageBreak) && hasFlag(fieldResultFlags, SOURCE_FLAGS.paragraphTextBoxShape)) return fieldResultFlags | SOURCE_FLAGS.pageBreakSharesTextBoxShape;
+					return fieldResultFlags;
+				}
+				case "complexField": {
+					const fieldCodeFlags = inspectMany(content.fieldCode, inspectRun);
+					const fieldResultFlags = inspectMany(content.fieldResult, inspectRun);
+					const fieldFlags = fieldCodeFlags | fieldResultFlags;
+					if (hasFlag(fieldResultFlags, SOURCE_FLAGS.paragraphPageBreak) && hasFlag(fieldResultFlags, SOURCE_FLAGS.paragraphTextBoxShape)) return fieldFlags | SOURCE_FLAGS.pageBreakSharesTextBoxShape;
+					return fieldFlags;
+				}
+				case "bookmarkStart":
+				case "bookmarkEnd":
+				case "commentRangeStart":
+				case "commentRangeEnd":
+				case "commentReference":
+				case "moveFromRangeStart":
+				case "moveFromRangeEnd":
+				case "moveToRangeStart":
+				case "moveToRangeEnd":
+				case "mathEquation": return 0;
+				default: return content;
+			}
+		});
+	};
+	const inspectTableCell = (cell) => inspectObject(cell, () => inspectBlocks(cell.content));
+	const inspectTableRow = (row) => inspectObject(row, () => inspectMany(row.cells, inspectTableCell));
+	const inspectBlock = (block) => inspectObject(block, () => {
+		switch (block.type) {
+			case "paragraph": return inspectMany(block.content, inspectParagraphContent);
+			case "table": return inspectMany(block.rows, inspectTableRow);
+			case "blockSdt": return inspectBlocks(block.content);
+			default: return block;
+		}
+	});
+	function inspectBlocks(content) {
+		const cached = flagsByObject.get(content);
+		if (cached !== void 0) return cached;
+		flagsByObject.set(content, 0);
+		const flags = inspectMany(content, inspectBlock);
+		flagsByObject.set(content, flags);
+		return flags;
+	}
+	inspectBlocks(rootContent);
+	return {
+		containsPageBreakRun: (content) => {
+			const flags = flagsByObject.get(content);
+			if (flags === void 0) panic("Page-break source ownership was queried outside its conversion index");
+			return hasFlag(flags, SOURCE_FLAGS.containsPageBreak);
+		},
+		paragraphFeatures: (paragraph) => {
+			const flags = flagsByObject.get(paragraph);
+			if (flags === void 0) panic("Page-break paragraph ownership was queried outside its conversion index");
+			return {
+				hasPageBreakRun: hasFlag(flags, SOURCE_FLAGS.paragraphPageBreak),
+				hasTextBoxShape: hasFlag(flags, SOURCE_FLAGS.paragraphTextBoxShape),
+				pageBreakSharesTextBoxShape: hasFlag(flags, SOURCE_FLAGS.pageBreakSharesTextBoxShape)
+			};
+		}
+	};
+};
+//#endregion
+export { buildPageBreakRunSourceDescendantIndex };

package/dist/internal/sectionEndpointResolution.d.ts

@@ -0,0 +1,32 @@
+import { document_d_exports } from "../types/document.js";
+//#region src/internal/sectionEndpointResolution.d.ts
+type RemovedSectionReference = {
+  part: "header" | "footer";
+  type: document_d_exports.HeaderFooterType;
+  relationshipId: string;
+};
+/**
+ * Exact resolution evidence produced when tracked-change resolution removes
+ * section endpoints. The tracker binds this count transition to exact endpoint
+ * fingerprints; removed references bind the only relationship losses that the
+ * same resolution may legitimately cause during package serialization.
+ */
+type TrackedSectionEndpointRemoval = {
+  type: "tracked-section-endpoint-removal";
+  sourceParagraphEndpointCount: number;
+  expectedParagraphEndpointCount: number;
+  sourceEndpointFingerprint: string;
+  expectedEndpointFingerprint: string;
+  removedReferences: readonly RemovedSectionReference[];
+};
+type WithTrackedSectionEndpointRemovalOptions<T> = {
+  document: document_d_exports.Document;
+  resolution: TrackedSectionEndpointRemoval;
+  repack: () => Promise<T>;
+};
+/** Run one repack with an exact authorization that no public save API accepts. */
+declare const withTrackedSectionEndpointRemoval: <T>({ document, resolution, repack }: WithTrackedSectionEndpointRemovalOptions<T>) => Promise<T>;
+/** @internal Consume the active authorization once for the exact document object. */
+declare const consumeTrackedSectionEndpointRemoval: (document: document_d_exports.Document) => TrackedSectionEndpointRemoval | null;
+//#endregion
+export { RemovedSectionReference, TrackedSectionEndpointRemoval, consumeTrackedSectionEndpointRemoval, withTrackedSectionEndpointRemoval };

package/dist/internal/sectionEndpointResolution.js

@@ -0,0 +1,38 @@
+import { panic } from "better-result";
+//#region src/internal/sectionEndpointResolution.ts
+const activeSectionEndpointRepacks = /* @__PURE__ */ new WeakMap();
+const snapshotAuthorization = (authorization) => {
+	const removedReferences = Object.freeze(authorization.removedReferences.map((reference) => Object.freeze({ ...reference })));
+	return Object.freeze({
+		...authorization,
+		removedReferences
+	});
+};
+/** Run one repack with an exact authorization that no public save API accepts. */
+const withTrackedSectionEndpointRemoval = async ({ document, resolution, repack }) => {
+	if (activeSectionEndpointRepacks.has(document)) panic("A tracked section-endpoint repack is already active for this document");
+	const snapshot = snapshotAuthorization(resolution);
+	activeSectionEndpointRepacks.set(document, {
+		status: "available",
+		authorization: snapshot
+	});
+	try {
+		const result = await repack();
+		if (activeSectionEndpointRepacks.get(document)?.status !== "consumed") panic("Tracked section-endpoint repack did not consume its authorization");
+		return result;
+	} finally {
+		activeSectionEndpointRepacks.delete(document);
+	}
+};
+/** @internal Consume the active authorization once for the exact document object. */
+const consumeTrackedSectionEndpointRemoval = (document) => {
+	const active = activeSectionEndpointRepacks.get(document);
+	if (!active || active.status === "consumed") return null;
+	activeSectionEndpointRepacks.set(document, {
+		status: "consumed",
+		authorization: active.authorization
+	});
+	return active.authorization;
+};
+//#endregion
+export { consumeTrackedSectionEndpointRemoval, withTrackedSectionEndpointRemoval };

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

@@ -197,6 +197,7 @@ function convertFootnoteToContent(footnote, displayNumber, contentWidth, options
 	if (options.theme !== void 0) proseOptions.theme = options.theme;
 	const pmDoc = footnoteToProseDoc(footnote.content, proseOptions);
 	const flowOptions = {};
+	if (options.styles) flowOptions.styles = options.styles;
 	if (options.theme !== void 0) flowOptions.theme = options.theme;
 	if (options.fontAlternates !== void 0) flowOptions.fontAlternates = options.fontAlternates;
 	if (options.defaultTabStopTwips !== void 0) flowOptions.defaultTabStopTwips = options.defaultTabStopTwips;

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

@@ -79,9 +79,21 @@ declare function convertHeaderFooterToContent(headerFooter: document_d_exports.H
  *
  * 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.
+ * Theme and styles are threaded again because effective character-style
+ * toggles cannot all be represented by the flattened ProseMirror marks.
  */
-declare function convertHeaderFooterPmDocToContent(pmDoc: Node | null | undefined, contentWidth: number, metrics: HeaderFooterMetrics, options: Omit<ConvertHeaderFooterOptions, "styles">): HeaderFooterContent | undefined;
+declare function convertHeaderFooterPmDocToContent(pmDoc: Node | null | undefined, contentWidth: number, metrics: HeaderFooterMetrics, options: ConvertHeaderFooterOptions): HeaderFooterContent | undefined;
+/**
+ * A paragraph-relative wrapping image that spans the whole story width leaves
+ * no side on which following content can flow. Retain the host paragraph's
+ * line box and reserve the complete anchored extent after it.
+ */
+type ReserveHeaderFooterFullWidthWrapBandsOptions = {
+  blocks: FlowBlock[];
+  measures: Measure[];
+  contentWidth: number;
+  metrics: HeaderFooterMetrics;
+};
+declare function reserveHeaderFooterFullWidthWrapBands({ blocks, measures, contentWidth, metrics }: ReserveHeaderFooterFullWidthWrapBandsOptions): Measure[];
 //#endregion
-export { ConvertHeaderFooterOptions, HeaderFooterMetrics, calculateHeaderFooterBodyTopClearance, calculateHeaderFooterMarginPushBounds, calculateHeaderFooterVisualBounds, convertHeaderFooterPmDocToContent, convertHeaderFooterToContent, normalizeHeaderFooterMeasureBlocks, resolveHeaderFooterPositionedVisualTop, resolveHeaderFooterVisualTop };
+export { ConvertHeaderFooterOptions, HeaderFooterMetrics, calculateHeaderFooterBodyTopClearance, calculateHeaderFooterMarginPushBounds, calculateHeaderFooterVisualBounds, convertHeaderFooterPmDocToContent, convertHeaderFooterToContent, normalizeHeaderFooterMeasureBlocks, reserveHeaderFooterFullWidthWrapBands, resolveHeaderFooterPositionedVisualTop, resolveHeaderFooterVisualTop };

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

@@ -1,5 +1,5 @@
 import { cloneParagraphWithPropertySource } from "../../docx/paragraphPropertySource.js";
-import { isFloatingImageRun, isFloatingTextBoxBlock } from "../../layout-engine/types.js";
+import { isFloatingImageRun, isFloatingTextBoxBlock, isTextWrappingFloatingImageRun } from "../../layout-engine/types.js";
 import { headerFooterToProseDoc } from "../../prosemirror/conversion/toProseDoc.js";
 import { emuToPixels } from "../../utils/units.js";
 import { toFlowBlocks } from "./toFlowBlocks.js";
@@ -342,6 +342,7 @@ function convertHeaderFooterToContent(headerFooter, contentWidth, metrics, optio
 	if (options.theme !== void 0) proseDocOptions.theme = options.theme;
 	const pmDoc = headerFooter.watermarkBlockIndex === void 0 ? headerFooterToProseDoc(headerFooter.content, proseDocOptions) : headerFooterToProseDocWithDetachedWatermarkHost(headerFooter, proseDocOptions);
 	const flowOptions = {};
+	if (options.styles) flowOptions.styles = options.styles;
 	if (options.theme !== void 0) flowOptions.theme = options.theme;
 	if (options.fontAlternates !== void 0) flowOptions.fontAlternates = options.fontAlternates;
 	if (options.defaultTabStopTwips !== void 0) flowOptions.defaultTabStopTwips = options.defaultTabStopTwips;
@@ -359,12 +360,13 @@ function convertHeaderFooterToContent(headerFooter, contentWidth, metrics, optio
 *
 * 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.
+* Theme and styles are threaded again because effective character-style
+* toggles cannot all be represented by the flattened ProseMirror marks.
 */
 function convertHeaderFooterPmDocToContent(pmDoc, contentWidth, metrics, options) {
 	if (!pmDoc || pmDoc.content.size === 0) return;
 	const flowOptions = {};
+	if (options.styles) flowOptions.styles = options.styles;
 	if (options.theme !== void 0) flowOptions.theme = options.theme;
 	if (options.fontAlternates !== void 0) flowOptions.fontAlternates = options.fontAlternates;
 	if (options.defaultTabStopTwips !== void 0) flowOptions.defaultTabStopTwips = options.defaultTabStopTwips;
@@ -374,10 +376,51 @@ function convertHeaderFooterPmDocToContent(pmDoc, contentWidth, metrics, options
 	if (options.automaticHyphenation) flowOptions.automaticHyphenation = options.automaticHyphenation;
 	return finalizeHeaderFooterContent(toFlowBlocks(pmDoc, flowOptions), contentWidth, metrics, options);
 }
+function horizontalImageLeft({ run, contentWidth, metrics }) {
+	const horizontal = run.position?.horizontal;
+	if (horizontal?.posOffset !== void 0) return (horizontal.relativeTo === "page" ? -metrics.margins.left : 0) + emuToPixels(horizontal.posOffset);
+	const alignment = getPositionAlignment(horizontal);
+	const frameWidth = horizontal?.relativeTo === "page" ? metrics.pageSize.w : contentWidth;
+	const frameLeft = horizontal?.relativeTo === "page" ? -metrics.margins.left : 0;
+	if (alignment === "center") return frameLeft + (frameWidth - run.width) / 2;
+	if (alignment === "right" || alignment === "outside") return frameLeft + frameWidth - run.width;
+	return frameLeft;
+}
+function reserveHeaderFooterFullWidthWrapBands({ blocks, measures, contentWidth, metrics }) {
+	return measures.map((measure, index) => {
+		const block = blocks[index];
+		if (block?.kind !== "paragraph" || measure.kind !== "paragraph") return measure;
+		let reservedHeight = 0;
+		for (const run of block.runs) {
+			if (run.kind !== "image" || !isTextWrappingFloatingImageRun(run)) continue;
+			const relativeTo = run.position?.vertical?.relativeTo;
+			if (relativeTo !== void 0 && relativeTo !== "paragraph" && relativeTo !== "line") continue;
+			const distLeft = run.distLeft ?? 0;
+			const left = horizontalImageLeft({
+				run,
+				contentWidth,
+				metrics
+			}) - distLeft;
+			const right = left + run.width + distLeft + (run.distRight ?? 0);
+			if (left > 0 || right < contentWidth) continue;
+			const offset = emuToPixels(run.position?.vertical?.posOffset ?? 0);
+			reservedHeight = Math.max(reservedHeight, Math.max(0, offset) + run.height + (run.distBottom ?? 0));
+		}
+		return reservedHeight > 0 ? {
+			...measure,
+			totalHeight: measure.totalHeight + reservedHeight
+		} : measure;
+	});
+}
 function finalizeHeaderFooterContent(blocks, contentWidth, metrics, options) {
 	if (blocks.length === 0) return;
 	const blocksForMeasure = normalizeHeaderFooterMeasureBlocks(blocks, metrics.section);
-	const measures = options.measureBlocks(blocksForMeasure, contentWidth);
+	const measures = reserveHeaderFooterFullWidthWrapBands({
+		blocks,
+		measures: options.measureBlocks(blocksForMeasure, contentWidth),
+		contentWidth,
+		metrics
+	});
 	let flowHeight = 0;
 	for (let i = 0; i < measures.length; i++) {
 		const m = measures[i];
@@ -532,4 +575,4 @@ function serializeRunFmt(run) {
 	return JSON.stringify(out);
 }
 //#endregion
-export { calculateHeaderFooterBodyTopClearance, calculateHeaderFooterMarginPushBounds, calculateHeaderFooterVisualBounds, convertHeaderFooterPmDocToContent, convertHeaderFooterToContent, normalizeHeaderFooterMeasureBlocks, resolveHeaderFooterPositionedVisualTop, resolveHeaderFooterVisualTop };
+export { calculateHeaderFooterBodyTopClearance, calculateHeaderFooterMarginPushBounds, calculateHeaderFooterVisualBounds, convertHeaderFooterPmDocToContent, convertHeaderFooterToContent, normalizeHeaderFooterMeasureBlocks, reserveHeaderFooterFullWidthWrapBands, resolveHeaderFooterPositionedVisualTop, resolveHeaderFooterVisualTop };

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

@@ -14,10 +14,14 @@ type ToFlowBlocksOptions = {
   defaultSize?: number;
   /** Theme for resolving theme colors. */
   theme?: document_d_exports.Theme | null;
+  /** Document styles used to resolve character-style toggles without per-run copies. */
+  styles?: document_d_exports.StyleDefinitions;
   /** Document-scoped OOXML primary-font to `w:altName` lookup. */
   fontAlternates?: FontAlternates;
   /** Page content height in pixels (pageHeight - marginTop - marginBottom). Images taller than this are scaled down to fit. */
   pageContentHeight?: number;
+  /** Whether a trailing page break moves its paragraph mark to the next page. */
+  splitPageBreakAndParagraphMark?: boolean;
   /** Shared list counters for nested containers. */
   listCounters?: Map<number, number[]>;
   /** Latest concrete counters by abstract numbering definition. */