@stll/folio-core 0.48.0 → 0.50.0

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

@@ -0,0 +1,281 @@
+import { getFontAlternate } from "../../fonts/fontAlternates.js";
+import { expectFieldAttrs, expectImageAttrs, expectMathAttrs, expectParagraphAttrs, expectPreservedXmlAttrs, expectSymbolAttrs } from "../../prosemirror/attrs/index.js";
+import { decodeOoxmlSymbolCharacter } from "../../utils/ooxmlSymbol.js";
+import { tableOfContentsStyleLevel } from "../../utils/tableOfContentsStyle.js";
+import { buildImageRun, constrainImageToPage, hasPaintableImageSource, hasRelationshipBackedImageBox } from "./imageConversion.js";
+import { isNoteReferenceMarkXml } from "./noteReferences.js";
+import { applyCharacterStyleToggleFormatting, markDefaultBlackTextColorSource, mergeRunFormatting } from "./runFormattingMerge.js";
+import { extractRunFormatting } from "./runMarkFormatting.js";
+import { paragraphRunDefaults } from "./textFormattingConversion.js";
+//#region src/layout-bridge/convert/paragraphRuns.ts
+/**
+* In TOC paragraphs, strip the resolved Hyperlink character-style colour and
+* underline so the painter's link fallback doesn't fire. The PM doc keeps the
+* original marks so copy/paste out of a TOC still carries the Hyperlink
+* styling like Word does. Applies to both text and field runs — a TOC entry's
+* page number is a PAGEREF field inside the entry's hyperlink.
+*
+* Mutates `formatting` in place; cheaper than re-cloning per run.
+*/
+function stripTocHyperlinkStyle(formatting) {
+	if (!formatting.hyperlink) return;
+	formatting.hyperlink.noDefaultStyle = true;
+	delete formatting.color;
+	delete formatting.underline;
+}
+const isTrackedRunMark = ({ type }) => type.name === "insertion" || type.name === "deletion";
+/**
+* Inline wrappers own marks that apply to every projected descendant. A
+* descendant's mark of the same type is more specific, and any descendant
+* revision replaces (rather than combines with) an inherited revision.
+*/
+const mergeProjectedInlineMarks = (inheritedMarks, ownMarks) => {
+	if (inheritedMarks.length === 0) return ownMarks;
+	const ownMarkTypes = new Set(ownMarks.map(({ type }) => type));
+	const hasOwnTrackedMark = ownMarks.some(isTrackedRunMark);
+	return [...inheritedMarks.filter((mark) => !ownMarkTypes.has(mark.type) && !(hasOwnTrackedMark && isTrackedRunMark(mark))), ...ownMarks];
+};
+function paragraphToRuns(node, startPos, _options, pageBreaks) {
+	const runs = [];
+	const offset = startPos + 1;
+	const theme = _options.theme;
+	const fontAlternates = _options.fontAlternates;
+	const pmAttrs = expectParagraphAttrs(node);
+	const paraDefaults = paragraphRunDefaults(pmAttrs, theme, fontAlternates);
+	const paragraphStyleId = pmAttrs.styleId;
+	const inTocParagraph = pmAttrs._tableOfContentsLevel !== void 0 || tableOfContentsStyleLevel({ styleId: paragraphStyleId }) !== void 0;
+	let leadingRenderedPageBreakPending = pmAttrs.renderedPageBreakBefore === true;
+	function pushRunsForChild(child, childPos, inheritedMarks = []) {
+		if (child.type.name === "bookmarkBoundary") return;
+		if (child.type.name === "renderedPageBreak") {
+			if (leadingRenderedPageBreakPending) {
+				leadingRenderedPageBreakPending = false;
+				return;
+			}
+			runs.push({
+				kind: "renderedPageBreak",
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize
+			});
+			return;
+		}
+		const effectiveMarks = mergeProjectedInlineMarks(inheritedMarks, child.marks);
+		if (child.type.name === "pageBreakRun") {
+			const trackedChange = extractRunFormatting(effectiveMarks, theme, fontAlternates);
+			if (trackedChange.isDeletion) {
+				runs.push({
+					kind: "text",
+					text: "",
+					isDeletion: true,
+					...trackedChange.changeAuthor !== void 0 ? { changeAuthor: trackedChange.changeAuthor } : {},
+					...trackedChange.changeDate !== void 0 ? { changeDate: trackedChange.changeDate } : {},
+					...trackedChange.changeRevisionId !== void 0 ? { changeRevisionId: trackedChange.changeRevisionId } : {},
+					...trackedChange.isSuggestion === true ? { isSuggestion: true } : {},
+					...trackedChange.suggestionId !== void 0 ? { suggestionId: trackedChange.suggestionId } : {},
+					pmStart: childPos,
+					pmEnd: childPos + child.nodeSize
+				});
+				return;
+			}
+			pageBreaks?.push({
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize,
+				...trackedChange.isInsertion ? { trackedChange: {
+					isInsertion: true,
+					...trackedChange.changeAuthor !== void 0 ? { changeAuthor: trackedChange.changeAuthor } : {},
+					...trackedChange.changeDate !== void 0 ? { changeDate: trackedChange.changeDate } : {},
+					...trackedChange.changeRevisionId !== void 0 ? { changeRevisionId: trackedChange.changeRevisionId } : {},
+					...trackedChange.isSuggestion === true ? { isSuggestion: true } : {},
+					...trackedChange.suggestionId !== void 0 ? { suggestionId: trackedChange.suggestionId } : {}
+				} } : {}
+			});
+			return;
+		}
+		if (child.type.name !== "sdt") leadingRenderedPageBreakPending = false;
+		if (child.isText && child.text) {
+			const formatting = extractRunFormatting(effectiveMarks, theme, fontAlternates);
+			applyCharacterStyleToggleFormatting({
+				formatting,
+				marks: effectiveMarks,
+				paragraphFormatting: pmAttrs.defaultTextFormatting,
+				styleResolver: _options.styleResolver
+			});
+			if (inTocParagraph) stripTocHyperlinkStyle(formatting);
+			const run = {
+				kind: "text",
+				text: child.text,
+				...mergeRunFormatting(paraDefaults, formatting),
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize
+			};
+			runs.push(run);
+			return;
+		}
+		if (child.type.name === "symbol") {
+			const attrs = expectSymbolAttrs(child);
+			const text = decodeOoxmlSymbolCharacter(attrs.char);
+			if (text === null) return;
+			const formatting = extractRunFormatting(effectiveMarks, theme, fontAlternates);
+			applyCharacterStyleToggleFormatting({
+				formatting,
+				marks: effectiveMarks,
+				paragraphFormatting: pmAttrs.defaultTextFormatting,
+				styleResolver: _options.styleResolver
+			});
+			if (inTocParagraph) stripTocHyperlinkStyle(formatting);
+			const alternateFontFamily = getFontAlternate(attrs.font, fontAlternates);
+			formatting.fontFamily = attrs.font;
+			if (alternateFontFamily) formatting.alternateFontFamily = alternateFontFamily;
+			runs.push({
+				kind: "text",
+				text,
+				...mergeRunFormatting(paraDefaults, formatting),
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize
+			});
+			return;
+		}
+		if (child.type.name === "preservedXml") {
+			const { xml, text: capturedText } = expectPreservedXmlAttrs(child);
+			const text = capturedText === "" && _options.noteReferenceMarkText !== void 0 && isNoteReferenceMarkXml(xml) ? _options.noteReferenceMarkText : capturedText;
+			if (text === "") return;
+			const formatting = extractRunFormatting(effectiveMarks, theme, fontAlternates);
+			applyCharacterStyleToggleFormatting({
+				formatting,
+				marks: effectiveMarks,
+				paragraphFormatting: pmAttrs.defaultTextFormatting,
+				styleResolver: _options.styleResolver
+			});
+			runs.push({
+				kind: "text",
+				text,
+				...mergeRunFormatting(paraDefaults, formatting),
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize
+			});
+			return;
+		}
+		if (child.type.name === "hardBreak") {
+			runs.push({
+				kind: "lineBreak",
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize
+			});
+			return;
+		}
+		if (child.type.name === "tab") {
+			const formatting = extractRunFormatting(effectiveMarks, theme, fontAlternates);
+			applyCharacterStyleToggleFormatting({
+				formatting,
+				marks: effectiveMarks,
+				paragraphFormatting: pmAttrs.defaultTextFormatting,
+				styleResolver: _options.styleResolver
+			});
+			const run = {
+				kind: "tab",
+				...mergeRunFormatting(paraDefaults, formatting),
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize
+			};
+			runs.push(run);
+			return;
+		}
+		if (child.type.name === "image") {
+			const attrs = expectImageAttrs(child);
+			if (!hasPaintableImageSource(attrs) && !hasRelationshipBackedImageBox(attrs)) return;
+			const constrained = constrainImageToPage(attrs.width ?? 100, attrs.height ?? 100, _options.pageContentHeight);
+			const trackedFmt = extractRunFormatting(effectiveMarks, theme, fontAlternates);
+			const run = buildImageRun(attrs, constrained, childPos, childPos + child.nodeSize, trackedFmt, _options.forceAnchorLayoutInCell);
+			runs.push(run);
+			return;
+		}
+		if (child.type.name === "structuredField") {
+			let containsPageBreak = false;
+			child.descendants((descendant) => {
+				if (descendant.type.name === "pageBreakRun") {
+					containsPageBreak = true;
+					return false;
+				}
+				return true;
+			});
+			if (containsPageBreak) {
+				const fieldContentStart = childPos + 1;
+				child.forEach((fieldChild, fieldChildOffset) => {
+					pushRunsForChild(fieldChild, fieldContentStart + fieldChildOffset, effectiveMarks);
+				});
+				return;
+			}
+		}
+		if (child.type.name === "field" || child.type.name === "structuredField") {
+			const attrs = expectFieldAttrs(child);
+			const ft = attrs.fieldType;
+			let mappedType = "OTHER";
+			if (ft === "PAGE") mappedType = "PAGE";
+			else if (ft === "NUMPAGES") mappedType = "NUMPAGES";
+			else if (ft === "DATE") mappedType = "DATE";
+			else if (ft === "TIME") mappedType = "TIME";
+			const extractedFieldFormatting = extractRunFormatting(effectiveMarks, theme, fontAlternates);
+			applyCharacterStyleToggleFormatting({
+				formatting: extractedFieldFormatting,
+				marks: effectiveMarks,
+				paragraphFormatting: pmAttrs.defaultTextFormatting,
+				styleResolver: _options.styleResolver
+			});
+			if (inTocParagraph) stripTocHyperlinkStyle(extractedFieldFormatting);
+			const fieldFormatting = markDefaultBlackTextColorSource(extractedFieldFormatting, paraDefaults);
+			const run = {
+				kind: "field",
+				fieldType: mappedType,
+				instruction: attrs.instruction,
+				fallback: _options.numberedRefResults?.get(child) ?? attrs.displayText ?? "",
+				...attrs.fldLock ? { fldLock: true } : {},
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize,
+				...fieldFormatting
+			};
+			runs.push(run);
+			return;
+		}
+		if (child.type.name === "math") {
+			const attrs = expectMathAttrs(child);
+			const plainText = attrs.plainText || "[equation]";
+			runs.push({
+				kind: "math",
+				display: attrs.display ?? "inline",
+				ommlXml: attrs.ommlXml,
+				plainText,
+				italic: true,
+				fontFamily: "Cambria Math",
+				pmStart: childPos,
+				pmEnd: childPos + child.nodeSize
+			});
+			return;
+		}
+		if (child.type.name === "sdt") {
+			const sdtInnerOffset = childPos + 1;
+			child.forEach((sdtChild, sdtChildOffset) => {
+				pushRunsForChild(sdtChild, sdtInnerOffset + sdtChildOffset, effectiveMarks);
+			});
+		}
+	}
+	node.forEach((child, childOffset) => {
+		pushRunsForChild(child, offset + childOffset);
+	});
+	const { defaultFont, defaultSize } = _options;
+	if (defaultFont !== void 0 || defaultSize !== void 0) for (const run of runs) switch (run.kind) {
+		case "text":
+		case "tab":
+		case "renderedPageBreak":
+		case "field":
+		case "math":
+			if (defaultFont !== void 0) run.fontFamily ??= defaultFont;
+			if (defaultSize !== void 0) run.fontSize ??= defaultSize;
+			break;
+		case "image":
+		case "lineBreak": break;
+		default:
+	}
+	return runs;
+}
+//#endregion
+export { paragraphToRuns };

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

@@ -0,0 +1,19 @@
+import { document_d_exports } from "../../types/document.js";
+import { RunFormattingOverrideAttrs } from "../../prosemirror/schema/marks.js";
+import { RunStyleResolver } from "../../prosemirror/runStyleFormatting.js";
+import { RunFormatting } from "../../layout-engine/types.js";
+import { Mark } from "prosemirror-model";
+//#region src/layout-bridge/convert/runFormattingMerge.d.ts
+declare function markDefaultBlackTextColorSource(formatting: RunFormatting, paraDefaults: RunFormatting): RunFormatting;
+declare function mergeRunFormatting(paraDefaults: RunFormatting, formatting: RunFormatting): RunFormatting;
+type ApplyCharacterStyleToggleFormattingOptions = {
+  formatting: RunFormatting;
+  marks: readonly Mark[];
+  paragraphFormatting: document_d_exports.TextFormatting | undefined;
+  styleResolver: RunStyleResolver;
+};
+/** Restore character-style toggle values that plain visual marks cannot represent. */
+declare function applyCharacterStyleToggleFormatting({ formatting, marks, paragraphFormatting, styleResolver }: ApplyCharacterStyleToggleFormattingOptions): void;
+declare function applyRunFormattingOverrides(formatting: RunFormatting, attrs: RunFormattingOverrideAttrs): void;
+//#endregion
+export { applyCharacterStyleToggleFormatting, applyRunFormattingOverrides, markDefaultBlackTextColorSource, mergeRunFormatting };

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

@@ -0,0 +1,167 @@
+import { expectCharacterStyleMarkAttrs } from "../../prosemirror/attrs/index.js";
+import { resolveEffectiveRunStyleFormatting } from "../../prosemirror/runStyleFormatting.js";
+import { STYLE_TOGGLE_KEYS } from "../../utils/textFormattingMerge.js";
+//#region src/layout-bridge/convert/runFormattingMerge.ts
+const DEFAULT_BLACK_TEXT_COLOR_VALUES = /* @__PURE__ */ new Set(["000000", "000"]);
+function normalizeResolvedTextColor(color) {
+	return color.trim().toLowerCase().replace(/^#/u, "");
+}
+function isDefaultBlackResolvedTextColor(color) {
+	return DEFAULT_BLACK_TEXT_COLOR_VALUES.has(normalizeResolvedTextColor(color));
+}
+function areResolvedTextColorsEqual(left, right) {
+	return normalizeResolvedTextColor(left) === normalizeResolvedTextColor(right);
+}
+function markDefaultBlackTextColorSource(formatting, paraDefaults) {
+	if (formatting.textColorSource === "direct" || formatting.color === void 0 || paraDefaults.color === void 0 || !isDefaultBlackResolvedTextColor(formatting.color) || !areResolvedTextColorsEqual(formatting.color, paraDefaults.color)) return formatting;
+	return {
+		...formatting,
+		textColorSource: "paragraphDefault"
+	};
+}
+function mergeRunFormatting(paraDefaults, formatting) {
+	if (formatting.isDeletion && formatting.usesHistoricalFormatting) return formatting;
+	const merged = {
+		...paraDefaults,
+		...markDefaultBlackTextColorSource(formatting, paraDefaults)
+	};
+	if (formatting.fontFamily !== void 0 && formatting.alternateFontFamily === void 0) delete merged.alternateFontFamily;
+	if (formatting.eastAsiaFontFamily !== void 0 && formatting.eastAsiaAlternateFontFamily === void 0) delete merged.eastAsiaAlternateFontFamily;
+	if (formatting.complexScriptFontFamily !== void 0 && formatting.complexScriptAlternateFontFamily === void 0) delete merged.complexScriptAlternateFontFamily;
+	if (merged.letterSpacing === 0) delete merged.letterSpacing;
+	if (formatting.horizontalScale === 100 && paraDefaults.horizontalScale === void 0) delete merged.horizontalScale;
+	return merged;
+}
+const CHARACTER_STYLE_TOGGLE_LAYOUT_PROPERTIES = {
+	allCaps: "allCaps",
+	bold: "bold",
+	boldCs: "complexScriptBold",
+	emboss: "emboss",
+	hidden: "hidden",
+	imprint: "imprint",
+	italic: "italic",
+	italicCs: "complexScriptItalic",
+	outline: "textOutline",
+	shadow: "textShadow",
+	smallCaps: "smallCaps",
+	strike: "strike"
+};
+/** Restore character-style toggle values that plain visual marks cannot represent. */
+function applyCharacterStyleToggleFormatting({ formatting, marks, paragraphFormatting, styleResolver }) {
+	const characterStyleMark = marks.find((mark) => mark.type.name === "characterStyle");
+	const styleRPr = characterStyleMark ? styleResolver.getRunStyleOwnProperties(expectCharacterStyleMarkAttrs(characterStyleMark).styleId) : styleResolver.getDefaultCharacterStyle()?.rPr;
+	if (!styleRPr) return;
+	const effectiveStyleFormatting = resolveEffectiveRunStyleFormatting({
+		marks,
+		paragraphFormatting,
+		styleResolver
+	});
+	for (const property of STYLE_TOGGLE_KEYS) {
+		if (styleRPr[property] === void 0) continue;
+		const layoutProperty = CHARACTER_STYLE_TOGGLE_LAYOUT_PROPERTIES[property];
+		if (formatting[layoutProperty] === void 0) Reflect.set(formatting, layoutProperty, effectiveStyleFormatting?.[property] ?? false);
+	}
+}
+const suppressInheritedRunFormatting = (formatting, property) => {
+	Reflect.set(formatting, property, void 0);
+};
+const RUN_FORMATTING_OVERRIDE_HANDLER_ENTRIES = Object.entries({
+	_authoredOff() {},
+	_authoredOn() {},
+	_authoredValues() {},
+	allCaps(formatting, value) {
+		if (typeof value === "boolean") formatting.allCaps = value;
+	},
+	bold(formatting, value) {
+		if (typeof value === "boolean") formatting.bold = value;
+	},
+	boldCs(formatting, value) {
+		if (typeof value === "boolean") formatting.complexScriptBold = value;
+	},
+	color(formatting, value) {
+		if (value === "auto") {
+			suppressInheritedRunFormatting(formatting, "color");
+			suppressInheritedRunFormatting(formatting, "textColorSource");
+		}
+	},
+	complexScriptPropertyAbsences() {},
+	cs(formatting, value) {
+		if (typeof value === "boolean") formatting.forceComplexScript = value;
+	},
+	directFontProperties() {},
+	doubleStrike(formatting, value) {
+		if (value === false && formatting.strike === void 0) formatting.strike = false;
+	},
+	effect(formatting, value) {
+		if (value === "none") suppressInheritedRunFormatting(formatting, "textEffect");
+	},
+	emboss(formatting, value) {
+		if (typeof value === "boolean") formatting.emboss = value;
+	},
+	emphasisMark(formatting, value) {
+		if (value === "none") suppressInheritedRunFormatting(formatting, "emphasisMark");
+	},
+	fontSizeCs(formatting, value) {
+		if (typeof value === "number") formatting.complexScriptFontSize = value / 2;
+	},
+	noProof() {},
+	hidden(formatting, value) {
+		if (typeof value === "boolean") formatting.hidden = value;
+	},
+	highlight(formatting, value) {
+		if (value === "none") suppressInheritedRunFormatting(formatting, "highlight");
+	},
+	imprint(formatting, value) {
+		if (typeof value === "boolean") formatting.imprint = value;
+	},
+	italic(formatting, value) {
+		if (typeof value === "boolean") formatting.italic = value;
+	},
+	italicCs(formatting, value) {
+		if (typeof value === "boolean") formatting.complexScriptItalic = value;
+	},
+	kerning(formatting, value) {
+		if (value === 0) formatting.kerningMinPt = 0;
+	},
+	outline(formatting, value) {
+		if (typeof value === "boolean") formatting.textOutline = value;
+	},
+	position(formatting, value) {
+		if (value === 0) formatting.positionPx = 0;
+	},
+	rtl(formatting, value) {
+		if (value === false) formatting.rtl = false;
+	},
+	scale(formatting, value) {
+		if (value === 100) formatting.horizontalScale = 100;
+	},
+	shading(formatting, value) {
+		if (typeof value === "object" && value !== null && Reflect.get(value, "pattern") === "nil") suppressInheritedRunFormatting(formatting, "shading");
+	},
+	shadow(formatting, value) {
+		if (typeof value === "boolean") formatting.textShadow = value;
+	},
+	smallCaps(formatting, value) {
+		if (typeof value === "boolean") formatting.smallCaps = value;
+	},
+	spacing(formatting, value) {
+		if (value === 0) formatting.letterSpacing = 0;
+	},
+	strike(formatting, value) {
+		if (typeof value === "boolean") formatting.strike = value;
+	},
+	underline(formatting, value) {
+		if (value === "none") formatting.underline = false;
+	},
+	vertAlign(formatting, value) {
+		if (value === "baseline") {
+			formatting.superscript = false;
+			formatting.subscript = false;
+		}
+	}
+});
+function applyRunFormattingOverrides(formatting, attrs) {
+	for (const [key, handler] of RUN_FORMATTING_OVERRIDE_HANDLER_ENTRIES) handler(formatting, Reflect.get(attrs, key));
+}
+//#endregion
+export { applyCharacterStyleToggleFormatting, applyRunFormattingOverrides, markDefaultBlackTextColorSource, mergeRunFormatting };

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

@@ -0,0 +1,11 @@
+import { document_d_exports } from "../../types/document.js";
+import { RunFormatting } from "../../layout-engine/types.js";
+import { FontAlternates } from "../../fonts/fontAlternates.js";
+import { Mark } from "prosemirror-model";
+//#region src/layout-bridge/convert/runMarkFormatting.d.ts
+/**
+ * Extract run formatting from ProseMirror marks.
+ */
+declare function extractRunFormatting(marks: readonly Mark[], theme?: document_d_exports.Theme | null, fontAlternates?: FontAlternates): RunFormatting;
+//#endregion
+export { extractRunFormatting };