@stll/folio-core 0.52.0 → 0.53.0

package/dist/internal/revisionResolutionStep.js

@@ -0,0 +1,282 @@
+import { indexedPositionMap } from "./indexedPositionMap.js";
+import { panic } from "better-result";
+import { Step, StepMap, StepResult } from "prosemirror-transform";
+//#region src/internal/revisionResolutionStep.ts
+const mapThrough = (position, assoc, maps) => {
+	let mapped = position;
+	let deleted = false;
+	let deletedBefore = false;
+	let deletedAfter = false;
+	let deletedAcross = false;
+	for (const map of maps) {
+		const result = map.mapResult(mapped, assoc);
+		mapped = result.pos;
+		deleted ||= result.deleted;
+		deletedBefore ||= result.deletedBefore;
+		deletedAfter ||= result.deletedAfter;
+		deletedAcross ||= result.deletedAcross;
+	}
+	return {
+		pos: mapped,
+		deleted,
+		deletedBefore,
+		deletedAfter,
+		deletedAcross
+	};
+};
+const chainedMap = (maps) => ({
+	map: (position, assoc = 1) => mapThrough(position, assoc, maps).pos,
+	mapResult: (position, assoc = 1) => mapThrough(position, assoc, maps)
+});
+const replaySteps = (doc, steps) => {
+	let current = doc;
+	for (const step of steps) {
+		const result = step.apply(current);
+		if (!result.doc) return result;
+		current = result.doc;
+	}
+	return StepResult.ok(current);
+};
+const isValidMapRanges = (value) => {
+	if (!Array.isArray(value) || value.length % 3 !== 0) return false;
+	let previousEnd = 0;
+	let delta = 0;
+	for (let index = 0; index < value.length; index += 3) {
+		const start = value.at(index);
+		const oldSize = value.at(index + 1);
+		const newSize = value.at(index + 2);
+		if (!Number.isSafeInteger(start) || !Number.isSafeInteger(oldSize) || !Number.isSafeInteger(newSize) || start < previousEnd || oldSize < 0 || newSize < 0) return false;
+		const oldEnd = start + oldSize;
+		const newStart = start + delta;
+		const newEnd = newStart + newSize;
+		if (!Number.isSafeInteger(oldEnd) || !Number.isSafeInteger(newStart) || !Number.isSafeInteger(newEnd) || !Number.isSafeInteger(newEnd - oldEnd) || newStart < 0) return false;
+		previousEnd = oldEnd;
+		delta = newEnd - oldEnd;
+	}
+	return true;
+};
+const indexedStepMapResult = (map) => {
+	const changes = [];
+	map.forEach((oldStart, oldEnd, newStart, newEnd) => {
+		changes.push({
+			oldStart,
+			oldEnd,
+			newStart,
+			newEnd
+		});
+	});
+	return (position, assoc) => {
+		let low = 0;
+		let high = changes.length;
+		while (low < high) {
+			const middle = Math.floor((low + high) / 2);
+			const change = changes[middle];
+			if (change && change.oldEnd < position) low = middle + 1;
+			else high = middle;
+		}
+		const change = changes[low];
+		if (change && change.oldStart <= position) {
+			const oldSize = change.oldEnd - change.oldStart;
+			let side = assoc;
+			if (oldSize > 0 && position === change.oldStart) side = -1;
+			else if (oldSize > 0 && position === change.oldEnd) side = 1;
+			return {
+				pos: side < 0 ? change.newStart : change.newEnd,
+				deleted: assoc < 0 ? position !== change.oldStart : position !== change.oldEnd
+			};
+		}
+		const previous = changes[low - 1];
+		return {
+			pos: position + (previous ? previous.newEnd - previous.oldEnd : 0),
+			deleted: false
+		};
+	};
+};
+/** Compose by retaining precisely the source positions that survive both maps. */
+const composeRevisionResolutionMaps = (first, second) => {
+	const firstResult = indexedStepMapResult(first);
+	const secondResult = indexedStepMapResult(second);
+	const inverseFirst = indexedPositionMap(first.invert());
+	const firstBreakpoints = [0];
+	const secondBreakpoints = [];
+	let lastSecondBoundary;
+	const projectSecondBoundary = (position) => {
+		if (position === lastSecondBoundary) return;
+		secondBreakpoints.push(inverseFirst(position, -1), inverseFirst(position, 1));
+		lastSecondBoundary = position;
+	};
+	first.forEach((oldStart, oldEnd) => {
+		firstBreakpoints.push(oldStart, oldEnd);
+	});
+	second.forEach((oldStart, oldEnd) => {
+		projectSecondBoundary(oldStart);
+		projectSecondBoundary(oldEnd);
+	});
+	const breakpoints = [];
+	let firstIndex = 0;
+	let secondIndex = 0;
+	while (firstIndex < firstBreakpoints.length || secondIndex < secondBreakpoints.length) {
+		const firstPosition = firstBreakpoints[firstIndex];
+		const secondPosition = secondBreakpoints[secondIndex];
+		const takeFirst = secondPosition === void 0 || firstPosition !== void 0 && firstPosition <= secondPosition;
+		const position = takeFirst ? firstPosition : secondPosition;
+		if (takeFirst) firstIndex++;
+		else secondIndex++;
+		if (position !== void 0 && breakpoints.at(-1) !== position) breakpoints.push(position);
+	}
+	const through = (position, assoc) => {
+		const earlier = firstResult(position, assoc);
+		const later = secondResult(earlier.pos, assoc);
+		return {
+			pos: later.pos,
+			deleted: earlier.deleted || later.deleted
+		};
+	};
+	const ranges = [];
+	let oldEnd = 0;
+	let newEnd = 0;
+	const anchor = (position, mapped) => {
+		if (position > oldEnd || mapped > newEnd) ranges.push(oldEnd, position - oldEnd, mapped - newEnd);
+		oldEnd = position;
+		newEnd = mapped;
+	};
+	for (let index = 0; index < breakpoints.length; index++) {
+		const position = breakpoints[index];
+		if (position === void 0) continue;
+		const left = through(position, -1);
+		const right = through(position, 1);
+		if (!left.deleted && !right.deleted) {
+			anchor(position, Math.min(left.pos, right.pos));
+			anchor(position, Math.max(left.pos, right.pos));
+		} else if (!left.deleted) anchor(position, left.pos);
+		else if (!right.deleted) anchor(position, right.pos);
+		const next = breakpoints[index + 1];
+		if (next === void 0) break;
+		const middle = (position + next) / 2;
+		const surviving = through(middle, 1);
+		if (!surviving.deleted) {
+			const offset = surviving.pos - middle;
+			anchor(position, position + offset);
+			oldEnd = next;
+			newEnd = next + offset;
+		}
+	}
+	return new StepMap(ranges);
+};
+/** One transaction step for a bulk resolution, with a granular position map. */
+var RevisionResolutionStep = class RevisionResolutionStep extends Step {
+	materializedSteps;
+	beforeDoc;
+	afterDoc;
+	positionMap;
+	deferredInverse;
+	constructor({ beforeDoc, afterDoc, steps, positionMap, deferredInverse }) {
+		super();
+		this.beforeDoc = beforeDoc;
+		this.afterDoc = afterDoc;
+		this.positionMap = positionMap;
+		this.deferredInverse = deferredInverse ?? null;
+		this.materializedSteps = deferredInverse ? null : steps;
+	}
+	steps() {
+		if (this.materializedSteps) return this.materializedSteps;
+		const deferred = this.deferredInverse;
+		if (!deferred) return panic("Revision resolution has no inverse steps");
+		let doc = deferred.doc;
+		const inverse = [];
+		for (const step of deferred.steps) {
+			inverse.push(step.invert(doc));
+			const result = step.apply(doc);
+			if (!result.doc) return panic(result.failed ?? "Revision resolution cannot invert a failed step");
+			doc = result.doc;
+		}
+		this.materializedSteps = inverse.reverse();
+		return inverse;
+	}
+	apply(doc) {
+		if (doc === this.beforeDoc && this.afterDoc) return StepResult.ok(this.afterDoc);
+		return replaySteps(doc, this.steps());
+	}
+	getMap() {
+		return this.positionMap;
+	}
+	invert(doc) {
+		if (doc === this.beforeDoc && this.afterDoc) return new RevisionResolutionStep({
+			beforeDoc: this.afterDoc,
+			afterDoc: doc,
+			steps: [],
+			positionMap: this.positionMap.invert(),
+			deferredInverse: {
+				doc,
+				steps: this.steps()
+			}
+		});
+		let current = doc;
+		const inverse = [];
+		for (const step of this.steps()) {
+			inverse.push(step.invert(current));
+			const result = step.apply(current);
+			if (!result.doc) return panic(result.failed ?? "Revision resolution cannot invert a failed step");
+			current = result.doc;
+		}
+		return new RevisionResolutionStep({
+			beforeDoc: current,
+			afterDoc: doc,
+			steps: inverse.reverse(),
+			positionMap: this.positionMap.invert()
+		});
+	}
+	map(mapping) {
+		const original = this.steps();
+		const mapped = [];
+		const inverseOriginalMaps = [];
+		const mappedMaps = [];
+		for (const step of original) {
+			const through = chainedMap([
+				...inverseOriginalMaps.toReversed(),
+				mapping,
+				...mappedMaps
+			]);
+			const rebased = step.map(through);
+			if (rebased) {
+				mapped.push(rebased);
+				mappedMaps.push(rebased.getMap());
+			}
+			inverseOriginalMaps.push(step.getMap().invert());
+		}
+		if (mapped.length === 0) return null;
+		let positionMap = StepMap.empty;
+		for (const step of mapped) positionMap = composeRevisionResolutionMaps(positionMap, step.getMap());
+		return new RevisionResolutionStep({
+			beforeDoc: null,
+			afterDoc: null,
+			steps: mapped,
+			positionMap
+		});
+	}
+	toJSON() {
+		const mapRanges = [];
+		this.positionMap.forEach((oldStart, oldEnd, newStart, newEnd) => {
+			mapRanges.push(oldStart, oldEnd - oldStart, newEnd - newStart);
+		});
+		return {
+			stepType: "folioRevisionResolution",
+			steps: this.steps().map((step) => step.toJSON()),
+			mapRanges
+		};
+	}
+	static fromJSON(schema, json) {
+		if (typeof json !== "object" || json === null || !("steps" in json) || !("mapRanges" in json)) throw new RangeError("Invalid revision resolution step JSON");
+		const { steps, mapRanges } = json;
+		if (!Array.isArray(steps) || !isValidMapRanges(mapRanges)) throw new RangeError("Invalid revision resolution step JSON");
+		return new RevisionResolutionStep({
+			beforeDoc: null,
+			afterDoc: null,
+			steps: steps.map((step) => Step.fromJSON(schema, step)),
+			positionMap: new StepMap(mapRanges)
+		});
+	}
+};
+Step.jsonID("folioRevisionResolution", RevisionResolutionStep);
+//#endregion
+export { RevisionResolutionStep, composeRevisionResolutionMaps };

package/dist/internal/revisionResolutionTracking.d.ts

@@ -0,0 +1,11 @@
+import { resolveWholeStory } from "./wholeStoryRevisionResolution.js";
+//#region src/internal/revisionResolutionTracking.d.ts
+type Resolution = ReturnType<typeof resolveWholeStory>;
+type Range = {
+  from: number;
+  to: number;
+};
+/** Map the three resolution phases to precise ranges in the finished story. */
+declare const finalRevisionParagraphRanges: (result: Resolution) => Range[];
+//#endregion
+export { finalRevisionParagraphRanges };

package/dist/internal/revisionResolutionTracking.js

@@ -0,0 +1,124 @@
+import { indexedPositionMap } from "./indexedPositionMap.js";
+import { panic } from "better-result";
+//#region src/internal/revisionResolutionTracking.ts
+const paragraphSizes = (table) => {
+	const sizes = /* @__PURE__ */ new Map();
+	table.descendants((node, position) => {
+		if (node.type.name === "table") return false;
+		if (node.type.name === "paragraph") {
+			sizes.set(position + 1, node.nodeSize);
+			return false;
+		}
+		return true;
+	});
+	return sizes;
+};
+/** Map the three resolution phases to precise ranges in the finished story. */
+const finalRevisionParagraphRanges = (result) => {
+	const tableNodes = new Set(result.tableRanges.map(({ node }) => node));
+	const finalTablePositions = /* @__PURE__ */ new Map();
+	result.resolved.descendants((node, position) => {
+		if (tableNodes.has(node)) finalTablePositions.set(node, position);
+		return true;
+	});
+	const tables = result.tableRanges.map((table) => {
+		const finalPosition = finalTablePositions.get(table.node) ?? null;
+		const sourceSizes = paragraphSizes(table.inputNode);
+		const finalSizes = finalPosition === null ? /* @__PURE__ */ new Map() : paragraphSizes(table.node);
+		const paragraphs = table.paragraphOffsets.map(({ source, final }) => {
+			const sourceSize = sourceSizes.get(source);
+			const finalSize = finalSizes.get(final);
+			if (sourceSize === void 0 || finalPosition !== null && finalSize === void 0) return panic("Resolved table paragraph offsets are inconsistent");
+			return {
+				source,
+				sourceEnd: source + sourceSize,
+				final,
+				finalEnd: final + (finalSize ?? 0)
+			};
+		});
+		paragraphs.sort((left, right) => left.source - right.source);
+		return {
+			...table,
+			finalPosition,
+			parent: null,
+			paragraphs,
+			mapInput: indexedPositionMap(table.inputMap)
+		};
+	}).sort((left, right) => left.position - right.position || right.sourceNodeSize - left.sourceNodeSize);
+	const tableStack = [];
+	for (const table of tables) {
+		for (;;) {
+			const enclosing = tableStack.at(-1);
+			if (!enclosing || table.position < enclosing.position + enclosing.sourceNodeSize) break;
+			tableStack.pop();
+		}
+		table.parent = tableStack.at(-1) ?? null;
+		tableStack.push(table);
+	}
+	const mapInline = indexedPositionMap(result.inlineMap);
+	const mapStructure = indexedPositionMap(result.structuralMap);
+	const finalRanges = [];
+	const tableContaining = (range) => {
+		let low = 0;
+		let high = tables.length;
+		while (low < high) {
+			const middle = Math.floor((low + high) / 2);
+			const candidate = tables.at(middle);
+			if (candidate && candidate.position <= range.from) low = middle + 1;
+			else high = middle;
+		}
+		let table = low === 0 ? null : tables.at(low - 1) ?? null;
+		while (table && range.to > table.position + table.sourceNodeSize) table = table.parent;
+		return table;
+	};
+	const mapAfterInlineRange = ({ from, to }) => {
+		if (to <= from) return;
+		const owningTable = tableContaining({
+			from,
+			to
+		});
+		if (owningTable) {
+			if (owningTable.finalPosition === null) return;
+			const relativeFrom = owningTable.mapInput(from - owningTable.position, 1);
+			const relativeTo = owningTable.mapInput(to - owningTable.position, -1);
+			let low = 0;
+			let high = owningTable.paragraphs.length;
+			while (low < high) {
+				const middle = Math.floor((low + high) / 2);
+				const candidate = owningTable.paragraphs.at(middle);
+				if (candidate && candidate.sourceEnd <= relativeFrom) low = middle + 1;
+				else high = middle;
+			}
+			for (let index = low; index < owningTable.paragraphs.length; index++) {
+				const paragraph = owningTable.paragraphs.at(index);
+				if (!paragraph || paragraph.source >= relativeTo) break;
+				finalRanges.push({
+					from: owningTable.finalPosition + paragraph.final,
+					to: owningTable.finalPosition + paragraph.finalEnd
+				});
+			}
+			return;
+		}
+		const finalFrom = mapStructure(from, 1);
+		const finalTo = mapStructure(to, -1);
+		if (finalTo > finalFrom) finalRanges.push({
+			from: finalFrom,
+			to: finalTo
+		});
+	};
+	for (const range of result.changedRanges) mapAfterInlineRange({
+		from: mapInline(range.from, 1),
+		to: mapInline(range.to, -1)
+	});
+	for (const range of result.structuralRanges) mapAfterInlineRange(range);
+	for (const table of tables) {
+		if (table.finalPosition === null) continue;
+		for (const range of table.ranges) finalRanges.push({
+			from: table.finalPosition + range.from,
+			to: table.finalPosition + range.to
+		});
+	}
+	return finalRanges;
+};
+//#endregion
+export { finalRevisionParagraphRanges };

package/dist/internal/wholeStoryRevisionResolution.d.ts

@@ -0,0 +1,56 @@
+import { RunStyleResolver } from "../prosemirror/runStyleFormatting.js";
+import { NumberingMap } from "../docx/numberingParser.js";
+import { RemovedSectionReference } from "./sectionEndpointResolution.js";
+import { RevisionResolutionMode } from "./revisionResolutionInline.js";
+import { Node } from "prosemirror-model";
+import { Mapping, Step, StepMap } from "prosemirror-transform";
+//#region src/internal/wholeStoryRevisionResolution.d.ts
+/** Resolve a story in linear passes, without rebuilding its root per revision. */
+type ResolveWholeStoryOptions = {
+  doc: Node;
+  mode: RevisionResolutionMode;
+  styleResolver: RunStyleResolver | null;
+  numbering: NumberingMap | null;
+};
+declare const resolveWholeStory: ({ doc, mode, styleResolver, numbering }: ResolveWholeStoryOptions) => {
+  resolved: Node;
+  mapping: Mapping;
+  positionMap: StepMap;
+  steps: Step[];
+  changedRanges: {
+    from: number;
+    to: number;
+  }[];
+  inlineMap: StepMap;
+  tableRanges: {
+    node: Node;
+    inputNode: Node;
+    sourceNodeSize: number;
+    position: number;
+    inputMap: StepMap;
+    positionMap: StepMap;
+    ranges: readonly {
+      from: number;
+      to: number;
+    }[];
+    paragraphOffsets: readonly {
+      source: number;
+      final: number;
+    }[];
+  }[];
+  transfers: {
+    displacedToken: string | null;
+    selectedToken: string | null;
+  }[];
+  structuralRanges: {
+    from: number;
+    to: number;
+  }[];
+  structuralMap: StepMap;
+  structural: boolean;
+  failed: boolean;
+  removedEndpointCount: number;
+  removedReferences: RemovedSectionReference[];
+};
+//#endregion
+export { resolveWholeStory };