@stll/folio-core 0.53.0 → 0.54.1

package/dist/internal/wholeStoryRevisionResolution.js

@@ -5,21 +5,30 @@ import { inlineBookmarksOf } from "../prosemirror/commands/paragraphBookmarkJoin
 import { resolveAllTableChanges } from "../prosemirror/commands/resolveAllTableChanges.js";
 import { resolveAllNodePropertyChangeAttrs } from "../prosemirror/commands/resolveNodePropertyChangeAttrs.js";
 import { resolveParagraphChangeAttrs } from "../prosemirror/commands/resolveParagraphProperties.js";
+import { rebaseParagraphRunContent } from "../prosemirror/rebaseParagraphRuns.js";
 import { expandRunFormattingCarrier } from "../prosemirror/runFormattingInlineCarriers.js";
 import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "../prosemirror/runFormattingReconciliation.js";
 import { paragraphRunStyleContext } from "../prosemirror/runStyleFormatting.js";
+import { runParagraphsIntoTables, runsIntoFollowingTable } from "../prosemirror/tableRunIn.js";
 import { holdsNoContent } from "../prosemirror/zeroWidthAnchors.js";
 import { recordNodeResolution } from "./revisionResolutionEdits.js";
 import { resolveInlineRevisions } from "./revisionResolutionInline.js";
 import { composeRevisionResolutionMaps } from "./revisionResolutionStep.js";
 import { REVIEW_CARRIERS } from "@stll/docx-core/model";
 import { Fragment, Slice } from "prosemirror-model";
-import { Mapping, ReplaceStep, StepMap } from "prosemirror-transform";
+import { Mapping, ReplaceStep, StepMap, Transform } from "prosemirror-transform";
 //#region src/internal/wholeStoryRevisionResolution.ts
 const resolveProperties = ({ doc, mode, styleResolver, numbering, steps, changedRanges }) => {
 	let structural = false;
+	let runsIntoTable = false;
 	const walk = (node, position) => {
 		if (node.isText) return node;
+		if (!runsIntoTable && !node.isTextblock) {
+			for (let index = 0; index + 1 < node.childCount; index++) if (runsIntoFollowingTable(node.child(index), node.child(index + 1), mode)) {
+				runsIntoTable = true;
+				break;
+			}
+		}
 		const nextAttrs = node.type.name === "paragraph" ? resolveParagraphChangeAttrs({
 			node,
 			mode,
@@ -94,7 +103,8 @@ const resolveProperties = ({ doc, mode, styleResolver, numbering, steps, changed
 	};
 	return {
 		resolved: walk(doc, -1),
-		structural
+		structural,
+		runsIntoTable
 	};
 };
 const structuralReplacementMap = ({ replacements, tables, bookmarkJoins, origin }) => {
@@ -157,11 +167,14 @@ const structuralReplacementMap = ({ replacements, tables, bookmarkJoins, origin
 			const last = ranges.length - 3;
 			const previousStart = ranges.at(last);
 			const previousOldSize = ranges.at(last + 1);
-			if (last >= 0 && previousStart !== void 0 && previousOldSize !== void 0 && ranges.at(last + 2) === 0 && newEnd === newStart && previousStart + previousOldSize === oldStart) {
+			const previousNewSize = ranges.at(last + 2);
+			const newSize = newEnd - newStart;
+			if (last >= 0 && previousStart !== void 0 && previousOldSize !== void 0 && previousNewSize !== void 0 && (previousNewSize === 0 || newSize === 0) && previousStart + previousOldSize === oldStart) {
 				ranges[last + 1] = previousOldSize + oldEnd - oldStart;
+				ranges[last + 2] = previousNewSize + newSize;
 				return;
 			}
-			ranges.push(oldStart, oldEnd - oldStart, newEnd - newStart);
+			ranges.push(oldStart, oldEnd - oldStart, newSize);
 		});
 	};
 	for (const replacement of replacements) {
@@ -228,7 +241,24 @@ const resolveStructure = ({ node, position, context }) => {
 		let final = chain.node;
 		if (chain.chunks.length > 1) {
 			const children = [];
-			for (let index = chain.chunks.length - 1; index >= 0; index--) chain.chunks[index]?.forEach((child) => children.push(child));
+			for (let index = chain.chunks.length - 1; index >= 0; index--) {
+				const chunk = chain.chunks[index];
+				if (!chunk) continue;
+				let content = chunk.type === "paragraph" ? chunk.source.content : chunk.content;
+				if (chunk.type === "paragraph" && chunk.position !== chain.formattingOwnerPosition) content = rebaseParagraphRunContent({
+					paragraph: chunk.source,
+					target: chain.node,
+					position: chunk.position,
+					styleResolver: context.styleResolver,
+					onRebased: ({ before, after, position: runPosition }) => recordNodeResolution({
+						before,
+						after,
+						position: runPosition,
+						steps: context.steps
+					})
+				});
+				content.forEach((child) => children.push(child));
+			}
 			final = recreateProseNodeWithParagraphPropertySource(chain.node, { content: Fragment.fromArray(children) });
 		}
 		if (!chain.before.sameMarkup(final)) context.changedRanges.push({
@@ -313,26 +343,23 @@ const resolveStructure = ({ node, position, context }) => {
 					return null;
 				}
 				bookmarks = Fragment.fromArray(inline);
-				chain.chunks.push(bookmarks);
-				pendingBookmarks = [];
-			}
-			const empty = holdsNoContent(paragraph);
-			const owner = empty ? chain.node : paragraph;
-			const next = chain.node;
-			if (empty) {
-				const displacedToken = getProseParagraphPropertySourceToken(paragraph);
-				const selectedToken = getProseParagraphPropertySourceToken(next);
-				context.transfers.push({
-					displacedToken: typeof displacedToken === "string" ? displacedToken : null,
-					selectedToken: typeof selectedToken === "string" ? selectedToken : null
+				chain.chunks.push({
+					type: "bookmarks",
+					content: bookmarks
 				});
+				pendingBookmarks = [];
 			}
-			chain.node = recreateProseNodeWithParagraphPropertySource(owner, { attrs: {
-				...owner.attrs,
-				pPrMark: next.attrs["pPrMark"],
-				_sectionProperties: next.attrs["_sectionProperties"]
-			} });
-			chain.chunks.push(paragraph.content);
+			const displacedToken = getProseParagraphPropertySourceToken(paragraph);
+			const selectedToken = getProseParagraphPropertySourceToken(chain.node);
+			context.transfers.push({
+				displacedToken: typeof displacedToken === "string" ? displacedToken : null,
+				selectedToken: typeof selectedToken === "string" ? selectedToken : null
+			});
+			chain.chunks.push({
+				type: "paragraph",
+				source: paragraph,
+				position: entry.position
+			});
 			chain.position = entry.position;
 			chain.before = paragraph;
 			chain.joinBoundaries.push({
@@ -357,7 +384,12 @@ const resolveStructure = ({ node, position, context }) => {
 		} }) : paragraph;
 		chain = {
 			node: resolved,
-			chunks: [resolved.content],
+			formattingOwnerPosition: entry.position,
+			chunks: [{
+				type: "paragraph",
+				source: resolved,
+				position: entry.position
+			}],
 			position: entry.position,
 			before: paragraph,
 			joinBoundaries: []
@@ -456,6 +488,42 @@ const resolveStructure = ({ node, position, context }) => {
 	return final;
 };
 const resolveWholeStory = ({ doc, mode, styleResolver, numbering }) => {
+	const { runsIntoTable, ...direct } = resolveStoryRevisions({
+		doc,
+		mode,
+		styleResolver,
+		numbering
+	});
+	if (!runsIntoTable) return direct;
+	const runIn = new Transform(doc);
+	const { targets, maps, transfers } = runParagraphsIntoTables(runIn, mode, styleResolver);
+	if (!runIn.docChanged) return direct;
+	const { runsIntoTable: _rerun, ...result } = resolveStoryRevisions({
+		doc: runIn.doc,
+		mode,
+		styleResolver,
+		numbering
+	});
+	for (const { position, step } of targets) {
+		const from = runIn.mapping.slice(step).map(position);
+		const target = runIn.doc.nodeAt(from);
+		if (target) result.changedRanges.push({
+			from,
+			to: from + target.nodeSize
+		});
+	}
+	let runInMap = StepMap.empty;
+	for (const map of maps) runInMap = composeRevisionResolutionMaps(runInMap, map);
+	const positionMap = composeRevisionResolutionMaps(runInMap, result.positionMap);
+	return {
+		...result,
+		steps: [...runIn.steps, ...result.steps],
+		positionMap,
+		mapping: new Mapping([positionMap]),
+		transfers: [...transfers, ...result.transfers]
+	};
+};
+const resolveStoryRevisions = ({ doc, mode, styleResolver, numbering }) => {
 	const steps = [];
 	const propertyRanges = [];
 	const propertyResult = resolveProperties({
@@ -476,6 +544,7 @@ const resolveWholeStory = ({ doc, mode, styleResolver, numbering }) => {
 	});
 	const context = {
 		mode,
+		styleResolver,
 		steps: [],
 		changedRanges: [],
 		deleted: [],
@@ -523,7 +592,8 @@ const resolveWholeStory = ({ doc, mode, styleResolver, numbering }) => {
 		structural: context.structural,
 		failed: context.failed,
 		removedEndpointCount: context.removedEndpointCount,
-		removedReferences: context.removedReferences
+		removedReferences: context.removedReferences,
+		runsIntoTable: propertyResult.runsIntoTable
 	};
 };
 //#endregion

package/dist/layout-engine/measure/measureParagraph.js

@@ -15,7 +15,7 @@ import { applyDocumentGrid, calculateEmptyParagraphMetrics, calculateTypographyM
 import { getListMarkerInlineWidth } from "./listMarkerWidth.js";
 import { DEFAULT_FONT_FAMILY, buildRunFontStyle, ptToPx } from "./measureHelpers.js";
 import { getFontMetrics, measureRun, measureTextWidth } from "./measureProvider.js";
-import { WIDTH_TOLERANCE, fieldMeasureText, isEmptyTextRun, isFieldRun, isImageRun, isLineBreakRun, isMathRun, isTabRun, isTextRun, runToFontStyle } from "./paragraphMeasureShared.js";
+import { WIDTH_TOLERANCE, canonicalLineWidth, fieldMeasureText, isEmptyTextRun, isFieldRun, isImageRun, isLineBreakRun, isMathRun, isTabRun, isTextRun, runToFontStyle } from "./paragraphMeasureShared.js";
 import { canClampTabToRightEdge, hasFollowingTabOnLine, hasPriorTabOnLine, measureDecimalPrefixWidthAfterTab, measureInlineWidthAfterTab } from "./paragraphTabs.js";
 import { calculateTabWidth, pixelsToTwips } from "./tabCalculator.js";
 //#region src/layout-engine/measure/measureParagraph.ts
@@ -215,7 +215,7 @@ function measureParagraph(block, maxWidth, options) {
 			fromChar: currentLine.fromChar,
 			toRun: currentLine.toRun,
 			toChar: currentLine.toChar,
-			width: Math.max(0, currentLine.width - currentLine.trailingWhitespaceWidth),
+			width: canonicalLineWidth(currentLine.width - currentLine.trailingWhitespaceWidth),
 			...finalTypography,
 			...currentLine.justificationPaint !== void 0 ? { justificationPaint: currentLine.justificationPaint } : {},
 			...currentLine.discretionaryHyphen ? { discretionaryHyphen: currentLine.discretionaryHyphen } : {},

package/dist/layout-engine/measure/paragraphMeasureShared.d.ts

@@ -5,6 +5,17 @@ import { FloatingLineSegmentZone } from "./floatingZones.js";
 declare const DEFAULT_FONT_SIZE = 11;
 declare const DEFAULT_LINE_HEIGHT_MULTIPLIER = 1;
 declare const WIDTH_TOLERANCE = 0.5;
+/**
+ * The width a finished line reports. A line's width is a floating-point sum
+ * of per-token measurements, and the same text can reach it through different
+ * token groupings, e.g. a run split where a hidden revision sat measures
+ * "confirm" + "ation" where the resolved text measures "confirmation". Those
+ * sums agree only up to the last few bits, so the result snaps to a
+ * binary-exact 1/1024 px grid (under 0.0005 px, far below a device pixel):
+ * the same text yields the same width whichever grouping summed it, and the
+ * alignment offsets derived from it agree too.
+ */
+declare const canonicalLineWidth: (width: number) => number;
 /**
  * Typography metrics for a line
  */
@@ -106,4 +117,4 @@ declare function isEmptyTextRun(run: TextRun): boolean;
 declare function isBlockLayoutImageRun(run: ImageRun): boolean;
 declare function isSpaceOrTab(char: string | undefined): boolean;
 //#endregion
-export { DEFAULT_FONT_SIZE, DEFAULT_LINE_HEIGHT_MULTIPLIER, LineState, LineTypography, WIDTH_TOLERANCE, fieldMeasureText, isBlockLayoutImageRun, isEmptyTextRun, isFieldRun, isImageRun, isLineBreakRun, isMathRun, isSpaceOrTab, isTabRun, isTextRun, runToFontStyle };
+export { DEFAULT_FONT_SIZE, DEFAULT_LINE_HEIGHT_MULTIPLIER, LineState, LineTypography, WIDTH_TOLERANCE, canonicalLineWidth, fieldMeasureText, isBlockLayoutImageRun, isEmptyTextRun, isFieldRun, isImageRun, isLineBreakRun, isMathRun, isSpaceOrTab, isTabRun, isTextRun, runToFontStyle };

package/dist/layout-engine/measure/paragraphMeasureShared.js

@@ -4,6 +4,19 @@ import { DEFAULT_FONT_FAMILY, buildRunFontStyle } from "./measureHelpers.js";
 const DEFAULT_FONT_SIZE = 11;
 const DEFAULT_LINE_HEIGHT_MULTIPLIER = 1;
 const WIDTH_TOLERANCE = .5;
+/** Grid a finished line's width snaps to: 1/1024 px, exact in binary floating point. */
+const LINE_WIDTH_GRID = 1024;
+/**
+* The width a finished line reports. A line's width is a floating-point sum
+* of per-token measurements, and the same text can reach it through different
+* token groupings, e.g. a run split where a hidden revision sat measures
+* "confirm" + "ation" where the resolved text measures "confirmation". Those
+* sums agree only up to the last few bits, so the result snaps to a
+* binary-exact 1/1024 px grid (under 0.0005 px, far below a device pixel):
+* the same text yields the same width whichever grouping summed it, and the
+* alignment offsets derived from it agree too.
+*/
+const canonicalLineWidth = (width) => Math.round(Math.max(0, width) * LINE_WIDTH_GRID) / LINE_WIDTH_GRID;
 /**
 * Extract FontStyle from a run that carries RunFormatting (text, tab, or
 * field). All three share the same formatting shape, so they measure the
@@ -79,4 +92,4 @@ function isSpaceOrTab(char) {
 	return char === " " || char === "	";
 }
 //#endregion
-export { DEFAULT_FONT_SIZE, DEFAULT_LINE_HEIGHT_MULTIPLIER, WIDTH_TOLERANCE, fieldMeasureText, isBlockLayoutImageRun, isEmptyTextRun, isFieldRun, isImageRun, isLineBreakRun, isMathRun, isSpaceOrTab, isTabRun, isTextRun, runToFontStyle };
+export { DEFAULT_FONT_SIZE, DEFAULT_LINE_HEIGHT_MULTIPLIER, WIDTH_TOLERANCE, canonicalLineWidth, fieldMeasureText, isBlockLayoutImageRun, isEmptyTextRun, isFieldRun, isImageRun, isLineBreakRun, isMathRun, isSpaceOrTab, isTabRun, isTextRun, runToFontStyle };

package/dist/markdown/escape.d.ts

@@ -7,8 +7,8 @@
  */
 /**
  * Escape only characters that would change markdown structure mid-text:
- *   - backslash, backtick, asterisk, brackets (always)
- *   - underscore: only at word boundaries (emphasis trigger)
+ *   - backslash, backtick, asterisk, brackets, tilde (always)
+ *   - underscore: unless between two letters or digits (emphasis trigger)
  *   - angle brackets: only when they look like a tag/autolink
  *
  * Characters like `.` `-` `+` `#` `(` `)` `!` are only meaningful at line

package/dist/markdown/escape.js

@@ -7,8 +7,8 @@
 */
 /**
 * Escape only characters that would change markdown structure mid-text:
-*   - backslash, backtick, asterisk, brackets (always)
-*   - underscore: only at word boundaries (emphasis trigger)
+*   - backslash, backtick, asterisk, brackets, tilde (always)
+*   - underscore: unless between two letters or digits (emphasis trigger)
 *   - angle brackets: only when they look like a tag/autolink
 *
 * Characters like `.` `-` `+` `#` `(` `)` `!` are only meaningful at line
@@ -16,9 +16,8 @@
 * when to escape those.
 */
 function escapeInline(text) {
-	let out = text.replace(/(?<ch>[\\`*[\]])/gu, "\\$<ch>");
-	out = out.replace(/(?<pre>^|\s)_/gu, "$<pre>\\_");
-	out = out.replace(/_(?<post>\s|$)/gu, "\\_$<post>");
+	let out = text.replace(/(?<ch>[\\`*[\]~])/gu, "\\$<ch>");
+	out = out.replace(/(?<![\p{L}\p{N}])_|_(?![\p{L}\p{N}])/gu, "\\_");
 	out = out.replace(/<(?<tag>\/?[A-Za-z][\w-]*)(?=[\s/>])/gu, "\\<$<tag>");
 	return out;
 }

package/dist/markdown/renderBlock.js

@@ -11,37 +11,103 @@ import { panic } from "better-result";
 * of the same list. Ported from eigenpal/docx-editor PR #595.
 */
 /**
-* In `trackedChanges: "clean"` mode every change is accepted. A paragraph whose
-* end-of-paragraph mark is a pending deletion (`pPrMark.kind === "del"`) loses
-* its break on accept and merges with the following paragraph. Word's join
-* keeps the FIRST paragraph's properties (style, list) and drops the resolved
-* mark; the surviving break is the next paragraph's, so a run of consecutive
-* deletions collapses into one paragraph. A first paragraph with nothing left
-* once its deletions are accepted (a whole deleted paragraph) contributes only
-* the join, so the NEXT paragraph keeps its own properties, as the editor's
-* accept does. A non-paragraph next block (table, SDT) is structurally
-* incompatible and stays unmerged, matching the editor's accept-change join
-* guard (`commands/comments.ts`).
+* In `trackedChanges: "clean"` mode every change is accepted, as the editor's
+* accept-all resolves the story (`internal/wholeStoryRevisionResolution.ts`).
+*
+* A paragraph whose mark is pending deletion loses its break on accept and
+* runs on into the paragraph after it, which is the paragraph left: its mark
+* ends the joined text, and a paragraph's properties (style, list) live on its
+* mark. A run of consecutive deletions collapses into that last paragraph.
+*
+* With a table right after it, its words run on into the table's first cell
+* and lead that cell's first paragraph (`prosemirror/tableRunIn.ts`), unless
+* it ends a section, keeps nothing once accepted, or that cell is pending.
+* Otherwise a paragraph that cannot join keeps its place, or goes when it
+* keeps nothing and something follows it.
 */
 function mergeAcceptedParagraphBreaks(blocks) {
-	const merged = [];
-	for (const block of blocks) {
-		const prev = merged.at(-1);
-		if (prev?.type === "paragraph" && prev.pPrMark?.kind === "del" && block.type === "paragraph") {
-			const next = block.pPrMark;
-			const content = [...prev.content, ...block.content];
-			const joined = cloneParagraphWithoutPropertySource(holdsNothingOnAccept(prev) ? block : prev, {
-				content,
-				...next ? { pPrMark: next } : {}
-			});
-			if (!next) Reflect.deleteProperty(joined, "pPrMark");
-			merged[merged.length - 1] = joined;
+	const reversed = [];
+	let survivor = null;
+	let tableFollows = false;
+	let followed = false;
+	const flush = () => {
+		if (survivor) reversed.push(survivor);
+		survivor = null;
+	};
+	for (let index = blocks.length - 1; index >= 0; index--) {
+		const block = blocks[index];
+		if (!block) continue;
+		if (block.type !== "paragraph") {
+			flush();
+			reversed.push(block);
+			tableFollows = block.type === "table";
+			followed ||= tableFollows;
 			continue;
 		}
-		merged.push(block);
+		const goes = block.pPrMark?.kind === "del" || block.pPrMark?.kind === "moveFrom";
+		if (goes && survivor) {
+			survivor = cloneParagraphWithoutPropertySource(survivor, { content: [...block.content, ...survivor.content] });
+			continue;
+		}
+		const table = reversed.at(-1);
+		if (goes && tableFollows && table?.type === "table") {
+			const ranIn = tableWithParagraphRunIn(table, block);
+			if (ranIn) {
+				reversed[reversed.length - 1] = ranIn;
+				continue;
+			}
+		}
+		flush();
+		tableFollows = false;
+		if (goes && holdsNothingOnAccept(block) && followed && index + reversed.length > 0) continue;
+		survivor = block;
+		followed = true;
 	}
-	return merged;
+	flush();
+	return reversed.reverse();
 }
+/**
+* Whether the cell a paragraph's words would run into is itself pending (its
+* row or the cell, through nested tables' first cells), as
+* `prosemirror/tableRunIn.ts` reads it.
+*/
+const runInCellPending = (table) => {
+	const row = table.rows[0];
+	const cell = row?.cells[0];
+	if (!row || !cell) return false;
+	if (row.structuralChange !== void 0 || cell.structuralChange !== void 0) return true;
+	const first = cell.content[0];
+	return first?.type === "table" && runInCellPending(first);
+};
+/**
+* `table` with `paragraph`'s words leading its first cell's first paragraph,
+* descending into nested tables, or null when the paragraph keeps its place.
+*/
+const tableWithParagraphRunIn = (table, paragraph) => {
+	if (paragraph.sectionProperties !== void 0 || holdsNothingOnAccept(paragraph)) return null;
+	if (runInCellPending(table)) return null;
+	const runIn = (current) => {
+		const [row, ...rows] = current.rows;
+		const [cell, ...cells] = row?.cells ?? [];
+		const [first, ...rest] = cell?.content ?? [];
+		if (!row || !cell || !first) return null;
+		let led = null;
+		if (first.type === "paragraph") led = cloneParagraphWithoutPropertySource(first, { content: [...paragraph.content, ...first.content] });
+		else if (first.type === "table") led = runIn(first);
+		if (!led) return null;
+		return {
+			...current,
+			rows: [{
+				...row,
+				cells: [{
+					...cell,
+					content: [led, ...rest]
+				}, ...cells]
+			}, ...rows]
+		};
+	};
+	return runIn(table);
+};
 /** Paragraph content that shows nothing: range boundaries and anchors. */
 const ZERO_WIDTH_CONTENT = /* @__PURE__ */ new Set([
 	"bookmarkStart",

package/dist/markdown/renderRuns.d.ts

@@ -1,10 +1,19 @@
 import { document_d_exports } from "../types/document.js";
 import { RenderContext } from "./types.js";
 //#region src/markdown/renderRuns.d.ts
+/**
+ * The character beside a run's delimiters: `""` at the paragraph's edge,
+ * `undefined` when it cannot be told (read as a letter, the strictest case).
+ */
+type Neighbor = string | undefined;
+type RunNeighbors = {
+  before: Neighbor;
+  after: Neighbor;
+};
 /**
  * Render the full inline content of a paragraph, tracking comment-range
  * boundaries to apply the configured wrapper.
  */
-declare function renderParagraphInline(ctx: RenderContext, pkg: document_d_exports.DocxPackage | undefined, content: readonly document_d_exports.ParagraphContent[], paraId: string | undefined): string;
+declare function renderParagraphInline(ctx: RenderContext, pkg: document_d_exports.DocxPackage | undefined, content: readonly document_d_exports.ParagraphContent[], paraId: string | undefined, edges?: RunNeighbors): string;
 //#endregion
 export { renderParagraphInline };