@stll/folio-core 0.52.0 → 0.54.0

package/dist/internal/wholeStoryRevisionResolution.js

@@ -0,0 +1,600 @@
+import { getProseParagraphPropertySourceToken, recreateProseNodeWithParagraphPropertySource } from "../docx/paragraphPropertySource.js";
+import { anchoredTextBoxId, droppedTextBoxAnchorIds } from "../prosemirror/anchoredTextBoxes.js";
+import { expectParagraphAttrs } from "../prosemirror/attrs/index.js";
+import { inlineBookmarksOf } from "../prosemirror/commands/paragraphBookmarkJoin.js";
+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, 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,
+			boundaryCovered: true,
+			revisionSet: null,
+			styleResolver,
+			numbering
+		}) : null;
+		let resolved = node;
+		if (nextAttrs) resolved = recreateProseNodeWithParagraphPropertySource(node, { attrs: nextAttrs });
+		else if (node.type.name !== "paragraph") resolved = resolveAllNodePropertyChangeAttrs(node, mode);
+		if (resolved !== node) {
+			if (node.type.name === "paragraph") changedRanges.push({
+				from: position,
+				to: position + node.nodeSize
+			});
+			structural ||= node.type.name !== "paragraph";
+		}
+		if (position >= 0) recordNodeResolution({
+			before: node,
+			after: resolved,
+			position,
+			steps
+		});
+		const rebased = /* @__PURE__ */ new Map();
+		if (node.type.name === "paragraph" && styleResolver && nextAttrs && nextAttrs["styleId"] !== node.attrs["styleId"]) {
+			const previousContext = paragraphRunStyleContext(node, styleResolver);
+			const nextContext = paragraphRunStyleContext(resolved, styleResolver);
+			node.descendants((inline, pos) => {
+				if (!inline.isInline) return true;
+				const carrier = expandRunFormattingCarrier(inline, pos);
+				if (!carrier) return !inline.isAtom;
+				for (const { node: representation } of carrier.representations) {
+					if (mode === "reject" && representation.marks.some(({ type }) => type.name === "deletion") && representation.marks.some(({ type }) => type.name === "runFormattingOverride")) continue;
+					const marks = reconcileRunFormattingMarks({
+						authoredFormatting: readAuthoredRunFormatting({
+							context: previousContext,
+							marks: representation.marks,
+							styleResolver
+						}),
+						context: nextContext,
+						node: representation,
+						styleResolver
+					});
+					rebased.set(representation, representation.mark(marks));
+				}
+				return false;
+			});
+		}
+		const children = [];
+		let changed = false;
+		const visitChild = (child, childPosition) => {
+			const replacement = rebased.get(child) ?? child;
+			if (rebased.size === 0) return walk(replacement, childPosition);
+			recordNodeResolution({
+				before: child,
+				after: replacement,
+				position: childPosition,
+				steps
+			});
+			if (replacement.isLeaf) return replacement;
+			const nested = [];
+			replacement.forEach((inner, offset) => nested.push(visitChild(inner, childPosition + 1 + offset)));
+			return recreateProseNodeWithParagraphPropertySource(replacement, { content: nested });
+		};
+		resolved.forEach((child, offset) => {
+			const result = visitChild(child, position + 1 + offset);
+			children.push(result);
+			changed ||= result !== child;
+		});
+		return changed ? recreateProseNodeWithParagraphPropertySource(resolved, { content: children }) : resolved;
+	};
+	return {
+		resolved: walk(doc, -1),
+		structural,
+		runsIntoTable
+	};
+};
+const structuralReplacementMap = ({ replacements, tables, bookmarkJoins, origin }) => {
+	const tablesByPosition = new Map(tables.map((table) => [table.position, table]));
+	const bookmarkJoinsByPosition = new Map(bookmarkJoins.map((join) => [join.from, join]));
+	const ranges = [];
+	const mapFor = ({ from, to, slice }) => {
+		const table = tablesByPosition.get(from);
+		if (table && table.sourceNodeSize === to - from) {
+			const tableRanges = [];
+			table.positionMap.forEach((oldStart, oldEnd, newStart, newEnd) => {
+				tableRanges.push(from - origin + oldStart, oldEnd - oldStart, newEnd - newStart);
+			});
+			return new StepMap(tableRanges);
+		}
+		const bookmarkJoin = bookmarkJoinsByPosition.get(from);
+		if (bookmarkJoin?.to === to) {
+			const joinRanges = [];
+			bookmarkJoin.positionMap.forEach((oldStart, oldEnd, newStart, newEnd) => {
+				joinRanges.push(from - origin + oldStart, oldEnd - oldStart, newEnd - newStart);
+			});
+			return new StepMap(joinRanges);
+		}
+		return new StepMap([
+			from - origin,
+			to - from,
+			slice.size
+		]);
+	};
+	const isDeletion = ({ from, to, slice }) => slice.size === 0 && !tablesByPosition.has(from) && to > from;
+	const groupMap = (group) => {
+		if (group.every(isDeletion)) {
+			const first = group.at(0);
+			if (!first) return StepMap.empty;
+			let end = first.to;
+			for (const replacement of group.slice(1)) end += replacement.to - replacement.from;
+			return new StepMap([
+				first.from - origin,
+				end - first.from,
+				0
+			]);
+		}
+		let maps = group.toReversed().map(mapFor);
+		while (maps.length > 1) {
+			const combined = [];
+			for (let index = 0; index < maps.length; index += 2) {
+				const first = maps.at(index);
+				const second = maps.at(index + 1);
+				if (!first) break;
+				combined.push(second ? composeRevisionResolutionMaps(first, second) : first);
+			}
+			maps = combined;
+		}
+		return maps.at(0) ?? StepMap.empty;
+	};
+	let group = [];
+	let influenceEnd = -1;
+	const flush = () => {
+		groupMap(group).forEach((oldStart, oldEnd, newStart, newEnd) => {
+			const last = ranges.length - 3;
+			const previousStart = ranges.at(last);
+			const previousOldSize = ranges.at(last + 1);
+			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, newSize);
+		});
+	};
+	for (const replacement of replacements) {
+		if (group.length > 0 && replacement.from >= influenceEnd) {
+			flush();
+			group = [];
+		}
+		if (group.length === 0) {
+			group.push(replacement);
+			influenceEnd = replacement.to;
+			continue;
+		}
+		group.push(replacement);
+		influenceEnd += replacement.to - replacement.from;
+	}
+	if (group.length > 0) flush();
+	return new StepMap(ranges);
+};
+const removedEndpoint = (node, context) => {
+	const properties = expectParagraphAttrs(node)._sectionProperties;
+	if (properties === void 0) return;
+	context.removedEndpointCount++;
+	for (const { type, rId } of properties?.headerReferences ?? []) context.removedReferences.push({
+		part: "header",
+		type,
+		relationshipId: rId
+	});
+	for (const { type, rId } of properties?.footerReferences ?? []) context.removedReferences.push({
+		part: "footer",
+		type,
+		relationshipId: rId
+	});
+};
+const resolveStructure = ({ node, position, context }) => {
+	if (node.isLeaf) return node;
+	const textBoxAnchor = anchoredTextBoxId(node);
+	if (textBoxAnchor !== void 0 && context.droppedTextBoxAnchors.has(textBoxAnchor)) {
+		context.structural = true;
+		return null;
+	}
+	const structuralStart = {
+		steps: context.steps.length,
+		deleted: context.deleted.length,
+		replacements: context.replacements.length,
+		tableRanges: context.tableRanges.length,
+		bookmarkJoins: context.bookmarkJoins.length
+	};
+	const entries = [];
+	node.forEach((child, offset) => entries.push({
+		node: resolveStructure({
+			node: child,
+			position: position + 1 + offset,
+			context
+		}),
+		original: child,
+		position: position + 1 + offset
+	}));
+	const reversed = [];
+	let chain = null;
+	let pendingBookmarks = [];
+	let followingContainerChild = false;
+	const flush = () => {
+		if (!chain) return;
+		let final = chain.node;
+		if (chain.chunks.length > 1) {
+			const children = [];
+			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({
+			from: chain.position,
+			to: chain.position + chain.before.nodeSize
+		});
+		recordNodeResolution({
+			before: chain.before,
+			after: final,
+			position: chain.position,
+			steps: context.steps
+		});
+		for (const { closing, bookmarks } of chain.joinBoundaries) {
+			if (bookmarks.size === 0) {
+				context.deleted.push({
+					from: closing,
+					to: closing + 2
+				});
+				continue;
+			}
+			const to = closing + bookmarks.size + 2;
+			context.replacements.push({
+				from: closing,
+				to,
+				slice: new Slice(bookmarks, 0, 0)
+			});
+			context.bookmarkJoins.push({
+				from: closing,
+				to,
+				positionMap: new StepMap([
+					0,
+					1,
+					0,
+					bookmarks.size + 1,
+					1,
+					0
+				])
+			});
+		}
+		reversed.push(chain.chunks.length === 1 && final.eq(chain.before) ? chain.before : final);
+		chain = null;
+	};
+	const flushBookmarks = () => {
+		flush();
+		for (const bookmark of pendingBookmarks) reversed.push(bookmark);
+		pendingBookmarks = [];
+	};
+	for (let index = entries.length - 1; index >= 0; index--) {
+		const entry = entries[index];
+		if (!entry) continue;
+		let paragraph = entry.node;
+		if (paragraph === null) {
+			const filler = index + reversed.length + pendingBookmarks.length + (chain ? 1 : 0) > 0 ? null : node.type.schema.nodes["paragraph"]?.createAndFill();
+			context.replacements.push({
+				from: entry.position,
+				to: entry.position + entry.original.nodeSize,
+				slice: filler ? new Slice(Fragment.from(filler), 0, 0) : Slice.empty
+			});
+			if (!filler) continue;
+			paragraph = filler;
+		}
+		if (paragraph.type.name !== "paragraph") {
+			if (paragraph.type.name === "blockBookmarkBoundary") {
+				pendingBookmarks.push(paragraph);
+				continue;
+			}
+			flushBookmarks();
+			reversed.push(paragraph);
+			followingContainerChild ||= paragraph.type.spec["tableRole"] === "table";
+			continue;
+		}
+		const marker = expectParagraphAttrs(paragraph).pPrMark;
+		const markWasAdded = marker?.kind === "ins" || marker?.kind === "moveTo";
+		const joins = marker && markWasAdded !== (context.mode === "accept");
+		if (joins && chain) {
+			const boundaries = pendingBookmarks.toReversed();
+			let bookmarks = Fragment.empty;
+			if (boundaries.length > 0) {
+				const inline = inlineBookmarksOf(boundaries);
+				if (!inline) {
+					context.failed = true;
+					return null;
+				}
+				bookmarks = Fragment.fromArray(inline);
+				chain.chunks.push({
+					type: "bookmarks",
+					content: bookmarks
+				});
+				pendingBookmarks = [];
+			}
+			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({
+				closing: entry.position + paragraph.nodeSize - 1,
+				bookmarks
+			});
+			removedEndpoint(paragraph, context);
+			continue;
+		}
+		flushBookmarks();
+		if (joins && holdsNoContent(paragraph) && (markWasAdded || followingContainerChild) && index + reversed.length + 1 > 1) {
+			context.deleted.push({
+				from: entry.position,
+				to: entry.position + paragraph.nodeSize
+			});
+			removedEndpoint(paragraph, context);
+			continue;
+		}
+		const resolved = marker ? recreateProseNodeWithParagraphPropertySource(paragraph, { attrs: {
+			...paragraph.attrs,
+			pPrMark: null
+		} }) : paragraph;
+		chain = {
+			node: resolved,
+			formattingOwnerPosition: entry.position,
+			chunks: [{
+				type: "paragraph",
+				source: resolved,
+				position: entry.position
+			}],
+			position: entry.position,
+			before: paragraph,
+			joinBoundaries: []
+		};
+		followingContainerChild = true;
+	}
+	flushBookmarks();
+	reversed.reverse();
+	if (node.type.name === "doc") {
+		const carrier = reversed.at(-1);
+		if (carrier?.type.name === "paragraph" && carrier.attrs["reviewCarrier"] === REVIEW_CARRIERS.TERMINAL_TABLE) {
+			const table = reversed.findLast((child) => child.type.name === "table");
+			let pending = false;
+			table?.descendants((child) => {
+				pending ||= child.type.name === "tableRow" && child.attrs["trDel"] !== null && typeof child.attrs["trDel"] === "object" || child.type.name !== "tableRow" && child.marks.some((mark) => mark.type.name === "deletion");
+				return !pending;
+			});
+			const entry = entries.at(-1);
+			if (!pending && entry) if (context.mode === "accept") {
+				const cleared = recreateProseNodeWithParagraphPropertySource(carrier, { attrs: {
+					...carrier.attrs,
+					reviewCarrier: void 0
+				} });
+				recordNodeResolution({
+					before: carrier,
+					after: cleared,
+					position: entry.position,
+					steps: context.steps
+				});
+				context.changedRanges.push({
+					from: entry.position,
+					to: entry.position + carrier.nodeSize
+				});
+				reversed[reversed.length - 1] = cleared;
+			} else if (reversed.length > 1) {
+				reversed.pop();
+				context.deleted.push({
+					from: entry.position,
+					to: entry.position + carrier.nodeSize
+				});
+			} else {
+				const filler = node.type.schema.nodes["paragraph"]?.createAndFill();
+				if (filler) {
+					reversed[0] = filler;
+					context.replacements.push({
+						from: entry.position,
+						to: entry.position + carrier.nodeSize,
+						slice: new Slice(Fragment.from(filler), 0, 0)
+					});
+				}
+			}
+		}
+	}
+	const rebuilt = reversed.length === node.childCount && reversed.every((child, index) => child === node.child(index)) ? node : recreateProseNodeWithParagraphPropertySource(node, { content: reversed });
+	if (node.type.spec["tableRole"] !== "table") return rebuilt;
+	const tableResult = resolveAllTableChanges({
+		table: rebuilt,
+		mode: context.mode
+	});
+	context.structural ||= tableResult.structural;
+	context.failed ||= tableResult.failed;
+	const final = tableResult.node;
+	if (final) {
+		const inside = [...context.replacements.slice(structuralStart.replacements), ...context.deleted.slice(structuralStart.deleted).map(({ from, to }) => ({
+			from,
+			to,
+			slice: Slice.empty
+		}))].sort((a, b) => a.from - b.from);
+		const inputMap = structuralReplacementMap({
+			replacements: inside,
+			tables: context.tableRanges.slice(structuralStart.tableRanges),
+			bookmarkJoins: context.bookmarkJoins.slice(structuralStart.bookmarkJoins),
+			origin: position
+		});
+		const positionMap = composeRevisionResolutionMaps(inputMap, tableResult.positionMap);
+		context.tableRanges.push({
+			node: final,
+			inputNode: rebuilt,
+			sourceNodeSize: node.nodeSize,
+			position,
+			inputMap,
+			positionMap,
+			ranges: tableResult.changedParagraphRanges,
+			paragraphOffsets: tableResult.paragraphOffsets
+		});
+	}
+	context.steps.length = structuralStart.steps;
+	context.deleted.length = structuralStart.deleted;
+	context.replacements.length = structuralStart.replacements;
+	context.bookmarkJoins.length = structuralStart.bookmarkJoins;
+	if (final && !node.eq(final)) context.replacements.push({
+		from: position,
+		to: position + node.nodeSize,
+		slice: new Slice(Fragment.from(final), 0, 0)
+	});
+	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({
+		doc,
+		mode,
+		styleResolver,
+		numbering,
+		steps,
+		changedRanges: propertyRanges
+	});
+	const properties = propertyResult.resolved;
+	const inline = resolveInlineRevisions({
+		doc: properties,
+		mode,
+		styleResolver,
+		keepType: doc.type.schema.marks[mode === "accept" ? "insertion" : "deletion"],
+		removeType: doc.type.schema.marks[mode === "accept" ? "deletion" : "insertion"]
+	});
+	const context = {
+		mode,
+		styleResolver,
+		steps: [],
+		changedRanges: [],
+		deleted: [],
+		replacements: [],
+		transfers: [],
+		tableRanges: [],
+		bookmarkJoins: [],
+		structural: propertyResult.structural,
+		failed: false,
+		removedEndpointCount: 0,
+		removedReferences: [],
+		droppedTextBoxAnchors: inline ? droppedTextBoxAnchorIds(properties, inline.resolved) : /* @__PURE__ */ new Set()
+	};
+	const resolved = resolveStructure({
+		node: inline?.resolved ?? properties,
+		position: -1,
+		context
+	}) ?? doc;
+	if (inline) steps.push(...inline.steps);
+	steps.push(...context.steps);
+	const replacements = [...context.replacements, ...context.deleted.map(({ from, to }) => ({
+		from,
+		to,
+		slice: Slice.empty
+	}))].sort((a, b) => a.from - b.from);
+	const structuralMap = structuralReplacementMap({
+		replacements,
+		tables: context.tableRanges,
+		bookmarkJoins: context.bookmarkJoins,
+		origin: 0
+	});
+	for (const { from, to, slice } of replacements.toReversed()) steps.push(new ReplaceStep(from, to, slice));
+	const positionMap = composeRevisionResolutionMaps(inline?.positionMap ?? StepMap.empty, structuralMap);
+	return {
+		resolved,
+		mapping: new Mapping([positionMap]),
+		positionMap,
+		steps,
+		changedRanges: [...propertyRanges, ...inline?.ranges ?? []],
+		inlineMap: inline?.positionMap ?? StepMap.empty,
+		tableRanges: context.tableRanges,
+		transfers: context.transfers,
+		structuralRanges: context.changedRanges,
+		structuralMap,
+		structural: context.structural,
+		failed: context.failed,
+		removedEndpointCount: context.removedEndpointCount,
+		removedReferences: context.removedReferences,
+		runsIntoTable: propertyResult.runsIntoTable
+	};
+};
+//#endregion
+export { resolveWholeStory };

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

@@ -0,0 +1,20 @@
+import { FlowBlock } from "../../layout-engine/types.js";
+import { StepMap } from "prosemirror-transform";
+//#region src/layout-bridge/convert/markupViewFlow.d.ts
+type PositionRange = {
+  from: number;
+  to: number;
+};
+type MarkupViewFlowOptions = {
+  /** Authored (editor) positions to the positions the blocks were built with. */
+  positionMap: StepMap;
+  /** Ranges, in the blocks' positions, whose paragraphs show a change bar. */
+  changeBarRanges: readonly PositionRange[];
+};
+/**
+ * Re-address blocks built from a view projection in editor positions, and mark
+ * the paragraphs the view flags with a change bar.
+ */
+declare function remapMarkupViewBlocks(blocks: readonly FlowBlock[], { positionMap, changeBarRanges }: MarkupViewFlowOptions): FlowBlock[];
+//#endregion
+export { MarkupViewFlowOptions, remapMarkupViewBlocks };