@stll/folio-core 0.48.0 → 0.50.0

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

@@ -0,0 +1,291 @@
+import { getFontAlternate } from "../../fonts/fontAlternates.js";
+import { setHyperlinkInstanceIndex } from "../../layout-engine/measure/hyperlinkInstance.js";
+import { expectCharacterSpacingMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectInlineWrapperMarkAttrs, expectLanguageMarkAttrs, expectRunFormattingOverrideMarkAttrs, expectRunShadingMarkAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs } from "../../prosemirror/attrs/index.js";
+import { runShadingAttrsToShading } from "../../prosemirror/conversion/runShadingMark.js";
+import { resolveColor, resolveHighlightToCss } from "../../utils/colorResolver.js";
+import { resolveShadingFill } from "../../utils/formatToStyle.js";
+import { normalizeHorizontalScalePercent } from "../../utils/horizontalScale.js";
+import { halfPointsToPixels, halfPointsToPoints } from "../../utils/units.js";
+import { twipsToPixels } from "./flowConversionShared.js";
+import { applyRunFormattingOverrides } from "./runFormattingMerge.js";
+import { isAutomaticTextColorValue, resolveComplexScriptThemeFont, resolveEastAsiaThemeFont, resolveWesternThemeFont } from "./textFormattingConversion.js";
+import { panic } from "better-result";
+//#region src/layout-bridge/convert/runMarkFormatting.ts
+/**
+* What the painter does with each mark the schema declares.
+*
+* The switch below used to end in `default: break`, so a mark that reached it
+* was silently not painted whether that was the decision or an omission. The
+* table is total over {@link SchemaMarkName}: a mark added to the schema
+* without a paint decision does not compile, and a mark this table says is
+* painted but the switch does not handle panics rather than disappearing.
+*/
+const MARK_PAINT_DISPOSITIONS = {
+	bold: "runFormatting",
+	italic: "runFormatting",
+	underline: "runFormatting",
+	strike: "runFormatting",
+	textColor: "runFormatting",
+	runShading: "runFormatting",
+	highlight: "runFormatting",
+	fontSize: "runFormatting",
+	fontFamily: "runFormatting",
+	language: "runFormatting",
+	superscript: "runFormatting",
+	subscript: "runFormatting",
+	hyperlink: "runFormatting",
+	allCaps: "runFormatting",
+	smallCaps: "runFormatting",
+	footnoteRef: "runFormatting",
+	characterSpacing: "runFormatting",
+	emboss: "runFormatting",
+	imprint: "runFormatting",
+	hidden: "runFormatting",
+	textShadow: "runFormatting",
+	emphasisMark: "runFormatting",
+	textOutline: "runFormatting",
+	rtl: "runFormatting",
+	textEffect: "runFormatting",
+	runFormattingOverride: "runFormatting",
+	comment: "runFormatting",
+	insertion: "runFormatting",
+	deletion: "runFormatting",
+	inlineWrapper: "runFormatting",
+	characterStyle: "resolvedElsewhere",
+	runIdentity: "notPainted",
+	runPropertyChange: "notPainted"
+};
+const markPaintDisposition = (name) => {
+	return MARK_PAINT_DISPOSITIONS[name];
+};
+/**
+* Whether a layer states how its content is laid out.
+*
+* A smart tag and a custom-XML wrapper name an element in another vocabulary
+* and say nothing about layout, so the painter draws the text exactly as it
+* would without them. The `switch` is here rather than inline so a kind added
+* to the model has to answer the question.
+*/
+const paintedDirection = (layer) => {
+	switch (layer.kind) {
+		case "bidi": return layer.direction === void 0 ? { control: layer.control } : {
+			control: layer.control,
+			direction: layer.direction
+		};
+		case "smartTag":
+		case "customXml": return;
+		default: return;
+	}
+};
+/**
+* The direction the innermost bidirectional layer of a stack lays its content out in.
+*
+* Innermost wins: a bidirectional wrapper inside another is the one the text is
+* laid out in, and the outer layers are what the save leg rebuilds the nesting
+* from. The layers that state no direction are skipped rather than ending the
+* search, so a smart tag inside a `w:dir` still reads right to left.
+*/
+const innermostBidiWrapper = (stack) => {
+	for (const layer of stack.toReversed()) {
+		const direction = paintedDirection(layer);
+		if (direction !== void 0) return direction;
+	}
+};
+/**
+* Extract run formatting from ProseMirror marks.
+*/
+function extractRunFormatting(marks, theme, fontAlternates) {
+	const formatting = {};
+	let hasNoteRef = false;
+	let runFormattingOverride;
+	for (const mark of marks) switch (mark.type.name) {
+		case "bold":
+			formatting.bold = true;
+			break;
+		case "italic":
+			formatting.italic = true;
+			break;
+		case "underline": {
+			const attrs = expectUnderlineMarkAttrs(mark);
+			if (attrs.style || attrs.color) {
+				const underlineObj = {};
+				if (attrs.style) underlineObj.style = attrs.style;
+				if (attrs.color) underlineObj.color = resolveColor(attrs.color, theme);
+				formatting.underline = underlineObj;
+			} else formatting.underline = true;
+			break;
+		}
+		case "strike":
+			formatting.strike = true;
+			break;
+		case "textColor": {
+			const attrs = expectTextColorMarkAttrs(mark);
+			if (attrs.themeColor || attrs.rgb) {
+				const colorArg = {};
+				if (attrs.rgb) colorArg.rgb = attrs.rgb;
+				if (attrs.themeColor) colorArg.themeColor = attrs.themeColor;
+				if (attrs.themeTint) colorArg.themeTint = attrs.themeTint;
+				if (attrs.themeShade) colorArg.themeShade = attrs.themeShade;
+				if (!isAutomaticTextColorValue(colorArg)) {
+					formatting.color = resolveColor(colorArg, theme);
+					formatting.textColorSource = "direct";
+				}
+			}
+			break;
+		}
+		case "highlight":
+			formatting.highlight = resolveHighlightToCss(expectHighlightMarkAttrs(mark).color);
+			break;
+		case "runShading": {
+			const shadingCss = resolveShadingFill(runShadingAttrsToShading(expectRunShadingMarkAttrs(mark)), theme);
+			if (shadingCss) formatting.shading = shadingCss;
+			break;
+		}
+		case "fontSize":
+			formatting.fontSize = expectFontSizeMarkAttrs(mark).size / 2;
+			break;
+		case "fontFamily": {
+			const attrs = expectFontFamilyMarkAttrs(mark);
+			const font = resolveWesternThemeFont(attrs, theme);
+			if (font) {
+				formatting.fontFamily = font;
+				const alternate = getFontAlternate(font, fontAlternates);
+				if (alternate) formatting.alternateFontFamily = alternate;
+			}
+			const eastAsiaFont = resolveEastAsiaThemeFont(attrs, theme);
+			if (eastAsiaFont) {
+				formatting.eastAsiaFontFamily = eastAsiaFont;
+				const alternate = getFontAlternate(eastAsiaFont, fontAlternates);
+				if (alternate) formatting.eastAsiaAlternateFontFamily = alternate;
+			}
+			if (attrs.hint) formatting.eastAsiaHint = attrs.hint === "eastAsia";
+			const complexScriptFont = resolveComplexScriptThemeFont(attrs, theme);
+			if (complexScriptFont) {
+				formatting.complexScriptFontFamily = complexScriptFont;
+				const alternate = getFontAlternate(complexScriptFont, fontAlternates);
+				if (alternate) formatting.complexScriptAlternateFontFamily = alternate;
+			}
+			break;
+		}
+		case "language": {
+			const attrs = expectLanguageMarkAttrs(mark);
+			formatting.language = {
+				...attrs.val ? { val: attrs.val } : {},
+				...attrs.eastAsia ? { eastAsia: attrs.eastAsia } : {},
+				...attrs.bidi ? { bidi: attrs.bidi } : {}
+			};
+			break;
+		}
+		case "characterSpacing": {
+			const attrs = expectCharacterSpacingMarkAttrs(mark);
+			if (attrs.spacing !== void 0) formatting.letterSpacing = twipsToPixels(attrs.spacing);
+			if (attrs.position !== void 0 && attrs.position !== 0) formatting.positionPx = halfPointsToPixels(attrs.position);
+			const horizontalScale = normalizeHorizontalScalePercent(attrs.scale);
+			if (horizontalScale !== void 0) formatting.horizontalScale = horizontalScale;
+			if (attrs.kerning !== void 0 && attrs.kerning > 0) formatting.kerningMinPt = halfPointsToPoints(attrs.kerning);
+			break;
+		}
+		case "allCaps":
+			formatting.allCaps = true;
+			break;
+		case "smallCaps":
+			formatting.smallCaps = true;
+			break;
+		case "emboss":
+			formatting.emboss = true;
+			break;
+		case "imprint":
+			formatting.imprint = true;
+			break;
+		case "hidden":
+			formatting.hidden = true;
+			break;
+		case "textShadow":
+			formatting.textShadow = true;
+			break;
+		case "textOutline":
+			formatting.textOutline = true;
+			break;
+		case "rtl":
+			formatting.rtl = true;
+			break;
+		case "textEffect":
+			formatting.textEffect = expectTextEffectMarkAttrs(mark).effect;
+			break;
+		case "runFormattingOverride":
+			runFormattingOverride = expectRunFormattingOverrideMarkAttrs(mark);
+			break;
+		case "emphasisMark":
+			formatting.emphasisMark = expectEmphasisMarkAttrs(mark).type ?? "dot";
+			break;
+		case "superscript":
+			formatting.superscript = true;
+			break;
+		case "subscript":
+			formatting.subscript = true;
+			break;
+		case "hyperlink": {
+			const attrs = expectHyperlinkMarkAttrs(mark);
+			const link = { href: attrs.href };
+			if (attrs.tooltip !== void 0) link.tooltip = attrs.tooltip;
+			if (attrs._docxHyperlinkIndex !== void 0) setHyperlinkInstanceIndex(link, attrs._docxHyperlinkIndex);
+			formatting.hyperlink = link;
+			break;
+		}
+		case "footnoteRef": {
+			hasNoteRef = true;
+			const attrs = expectFootnoteRefMarkAttrs(mark);
+			if (attrs.vertAlign === "superscript") formatting.superscript = true;
+			const id = typeof attrs.id === "string" ? Number.parseInt(attrs.id, 10) : attrs.id;
+			if (attrs.noteType === "endnote") formatting.endnoteRefId = id;
+			else formatting.footnoteRefId = id;
+			break;
+		}
+		case "comment": {
+			const commentId = expectCommentMarkAttrs(mark).commentId;
+			if (commentId) {
+				if (!formatting.commentIds) formatting.commentIds = [];
+				formatting.commentIds.push(commentId);
+			}
+			break;
+		}
+		case "insertion": {
+			const attrs = expectTrackedChangeMarkAttrs(mark);
+			formatting.isInsertion = true;
+			formatting.changeAuthor = attrs.author;
+			if (attrs.date !== void 0) formatting.changeDate = attrs.date;
+			formatting.changeRevisionId = attrs.revisionId;
+			if (attrs.provenance === "suggested") {
+				formatting.isSuggestion = true;
+				if (attrs.suggestionId) formatting.suggestionId = attrs.suggestionId;
+			}
+			break;
+		}
+		case "deletion": {
+			const attrs = expectTrackedChangeMarkAttrs(mark);
+			formatting.isDeletion = true;
+			if (attrs._historicalFormatting) formatting.usesHistoricalFormatting = true;
+			formatting.changeAuthor = attrs.author;
+			if (attrs.date !== void 0) formatting.changeDate = attrs.date;
+			formatting.changeRevisionId = attrs.revisionId;
+			if (attrs.provenance === "suggested") {
+				formatting.isSuggestion = true;
+				if (attrs.suggestionId) formatting.suggestionId = attrs.suggestionId;
+			}
+			break;
+		}
+		case "inlineWrapper": {
+			const bidiWrapper = innermostBidiWrapper(expectInlineWrapperMarkAttrs(mark).stack);
+			if (bidiWrapper) formatting.bidiWrapper = bidiWrapper;
+			break;
+		}
+		default:
+			if (markPaintDisposition(mark.type.name) === "runFormatting") panic(`Mark ${mark.type.name} is painted as run formatting but has no branch here`);
+			break;
+	}
+	if (runFormattingOverride) applyRunFormattingOverrides(formatting, runFormattingOverride);
+	if (hasNoteRef && formatting.subscript) delete formatting.superscript;
+	return formatting;
+}
+//#endregion
+export { extractRunFormatting };

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

@@ -0,0 +1,35 @@
+import { FlowBlock, SectionBreakBlock } from "../../layout-engine/types.js";
+import { Node } from "prosemirror-model";
+//#region src/layout-bridge/convert/sectionBoundaries.d.ts
+declare function getLastMapKey<K, V>(map: ReadonlyMap<K, V>): K | undefined;
+/**
+ * Translate section-owned start modes into the boundary-owned values consumed
+ * by the paginator. Each flow section break carries the properties for the
+ * section it ends, so its start mode belongs on the preceding boundary.
+ */
+declare function applySectionStartsToBoundaries(blocks: readonly FlowBlock[], finalSectionStart: NonNullable<SectionBreakBlock["type"]> | undefined): FlowBlock[];
+/**
+ * A trailing page break belongs to its section-ending paragraph. When the
+ * paragraph mark stays on the current page, an immediately following
+ * continuous section resumes there too. Accept both the legacy generated
+ * carrier and the inline atom's one-token paragraph-mark fragment; neither is
+ * a physical layout boundary.
+ *
+ * A section break in `breaksWithoutMarker` ends at an empty w:sectPr paragraph
+ * that projected no block, so a page break just before it ends an earlier
+ * paragraph and still starts the next page.
+ */
+declare function coalesceTrailingPageBreakBeforeContinuousSection(blocks: readonly FlowBlock[], splitPageBreakAndParagraphMark: boolean, breaksWithoutMarker: ReadonlySet<SectionBreakBlock["id"]>): FlowBlock[];
+/**
+ * The last section's start mode, off a document attribute the schema types as
+ * `any`. `parseSectionBreakType` owns the enumeration, so a member added to
+ * `ST_SectionMark` reaches the paginator instead of being dropped here.
+ */
+declare function readFinalSectionStart(doc: Node): NonNullable<SectionBreakBlock["type"]> | undefined;
+type SectionDocumentGridOptions = {
+  finalLinePitchTwips: number | undefined;
+  tableCellLinePitch: "sectionGrid" | undefined;
+};
+declare function applySectionDocumentGrid(blocks: FlowBlock[], { finalLinePitchTwips, tableCellLinePitch }: SectionDocumentGridOptions): FlowBlock[];
+//#endregion
+export { applySectionDocumentGrid, applySectionStartsToBoundaries, coalesceTrailingPageBreakBeforeContinuousSection, getLastMapKey, readFinalSectionStart };

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

@@ -0,0 +1,114 @@
+import { parseSectionBreakType } from "../../prosemirror/sectionCarrier.js";
+import { twipsToPixels } from "./flowConversionShared.js";
+//#region src/layout-bridge/convert/sectionBoundaries.ts
+function getLastMapKey(map) {
+	let lastKey;
+	for (const key of map.keys()) lastKey = key;
+	return lastKey;
+}
+/**
+* Translate section-owned start modes into the boundary-owned values consumed
+* by the paginator. Each flow section break carries the properties for the
+* section it ends, so its start mode belongs on the preceding boundary.
+*/
+function applySectionStartsToBoundaries(blocks, finalSectionStart) {
+	const breakIndexes = [];
+	for (let index = 0; index < blocks.length; index += 1) if (blocks[index]?.kind === "sectionBreak") breakIndexes.push(index);
+	if (breakIndexes.length === 0) return [...blocks];
+	const result = [...blocks];
+	for (let index = 0; index < breakIndexes.length; index += 1) {
+		const boundaryIndex = breakIndexes[index];
+		if (boundaryIndex === void 0) continue;
+		const boundary = blocks[boundaryIndex];
+		if (boundary?.kind !== "sectionBreak") continue;
+		const nextBoundaryIndex = breakIndexes[index + 1];
+		const nextBoundary = nextBoundaryIndex === void 0 ? void 0 : blocks[nextBoundaryIndex];
+		const nextStart = nextBoundary?.kind === "sectionBreak" ? nextBoundary.type : finalSectionStart;
+		const translated = { ...boundary };
+		if (nextStart === void 0) delete translated.type;
+		else translated.type = nextStart;
+		result[boundaryIndex] = translated;
+	}
+	return result;
+}
+/**
+* A trailing page break belongs to its section-ending paragraph. When the
+* paragraph mark stays on the current page, an immediately following
+* continuous section resumes there too. Accept both the legacy generated
+* carrier and the inline atom's one-token paragraph-mark fragment; neither is
+* a physical layout boundary.
+*
+* A section break in `breaksWithoutMarker` ends at an empty w:sectPr paragraph
+* that projected no block, so a page break just before it ends an earlier
+* paragraph and still starts the next page.
+*/
+function coalesceTrailingPageBreakBeforeContinuousSection(blocks, splitPageBreakAndParagraphMark, breaksWithoutMarker) {
+	if (splitPageBreakAndParagraphMark) return [...blocks];
+	const result = [];
+	for (let index = 0; index < blocks.length; index += 1) {
+		const block = blocks[index];
+		const carrier = blocks[index + 1];
+		const section = blocks[index + 2];
+		const isLegacyGeneratedCarrier = block?.kind === "pageBreak" && carrier?.kind === "paragraph" && carrier.runs.length === 0 && block.pmStart !== void 0 && block.pmStart === carrier.pmStart && carrier.pmStart === carrier.pmEnd;
+		const isInlineParagraphMarkCarrier = block?.kind === "pageBreak" && carrier?.kind === "paragraph" && carrier.runs.length === 0 && block.pmEnd !== void 0 && carrier.pmStart === block.pmEnd && carrier.pmEnd === block.pmEnd + 1;
+		const isUnresolvedInsertion = block?.kind === "pageBreak" && block.isInsertion === true;
+		if (block?.kind === "pageBreak" && !isUnresolvedInsertion && carrier?.kind === "sectionBreak" && carrier.type === "continuous" && !breaksWithoutMarker.has(carrier.id)) continue;
+		if (block?.kind === "pageBreak" && !isUnresolvedInsertion && (isLegacyGeneratedCarrier || isInlineParagraphMarkCarrier) && section?.kind === "sectionBreak" && section.type === "continuous" && !breaksWithoutMarker.has(section.id)) {
+			index += 1;
+			continue;
+		}
+		if (block) result.push(block);
+	}
+	return result;
+}
+/**
+* The last section's start mode, off a document attribute the schema types as
+* `any`. `parseSectionBreakType` owns the enumeration, so a member added to
+* `ST_SectionMark` reaches the paginator instead of being dropped here.
+*/
+function readFinalSectionStart(doc) {
+	return parseSectionBreakType(doc.attrs["_finalSectionStart"]) ?? void 0;
+}
+function applySectionDocumentGrid(blocks, { finalLinePitchTwips, tableCellLinePitch }) {
+	const result = [...blocks];
+	let sectionStart = 0;
+	const stampSection = (end, linePitchTwips) => {
+		if (linePitchTwips === void 0 || linePitchTwips <= 0) return;
+		const linePitch = twipsToPixels(linePitchTwips);
+		const stampBlock = (block) => {
+			if (block.kind === "paragraph") return {
+				...block,
+				attrs: {
+					...block.attrs,
+					documentGridLinePitch: linePitch
+				}
+			};
+			if (block.kind !== "table" || tableCellLinePitch !== "sectionGrid") return block;
+			return {
+				...block,
+				rows: block.rows.map((row) => ({
+					...row,
+					cells: row.cells.map((cell) => ({
+						...cell,
+						blocks: cell.blocks.map(stampBlock)
+					}))
+				}))
+			};
+		};
+		for (let index = sectionStart; index < end; index += 1) {
+			const block = result[index];
+			if (!block) continue;
+			result[index] = stampBlock(block);
+		}
+	};
+	for (let index = 0; index < blocks.length; index += 1) {
+		const block = blocks[index];
+		if (block?.kind !== "sectionBreak") continue;
+		stampSection(index, block.documentGridLinePitchTwips);
+		sectionStart = index + 1;
+	}
+	stampSection(blocks.length, finalLinePitchTwips);
+	return result;
+}
+//#endregion
+export { applySectionDocumentGrid, applySectionStartsToBoundaries, coalesceTrailingPageBreakBeforeContinuousSection, getLastMapKey, readFinalSectionStart };

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

@@ -0,0 +1,12 @@
+import { TableBlock, TextBoxBlock } from "../../layout-engine/types.js";
+import { FlowConversionOptions } from "./flowConversionShared.js";
+import { Node } from "prosemirror-model";
+//#region src/layout-bridge/convert/tableConversion.d.ts
+/**
+ * Convert a table node to a TableBlock.
+ */
+declare function convertTable(node: Node, startPos: number, options: FlowConversionOptions): TableBlock;
+/** Convert a textBox PM node to a TextBoxBlock. */
+declare function convertTextBoxNode(node: Node, startPos: number, opts: FlowConversionOptions): TextBoxBlock;
+//#endregion
+export { convertTable, convertTextBoxNode };