@stll/folio-core 0.52.0 → 0.54.0

package/dist/prosemirror/replacedAnnotations.d.ts

@@ -48,6 +48,38 @@ type AnnotatedReplacement = {
 };
 /** `marks` with the carried marks added, each type's exclusions respected. */
 declare const addCarriedMarks: (marks: readonly Mark[], carried: readonly Mark[]) => readonly Mark[];
+/**
+ * The mark sets of a run of text a TRACKED edit inserts at `at` (one set per
+ * piece, in order), with the comments that keep every comment one stretch.
+ *
+ * A tracked replacement keeps the replaced text (as a deletion), and that text
+ * keeps its comments, so a comment carried or inherited onto the insertion
+ * only CONTINUES its range: it stays when, through the run, it reaches the
+ * content directly before or after `at`, and goes otherwise. Between two
+ * pieces that have a comment (the neighbours included), every piece takes
+ * it, or the run would split it in two.
+ */
+declare const commentsForTrackedInsertion: (doc: Node, at: number, pieces: readonly (readonly Mark[])[]) => (readonly Mark[])[];
+/**
+ * Where, within the text a tracked replacement removes (`from` to `to`), each
+ * piece of its new text goes, one position per piece and never decreasing.
+ *
+ * The redline reads the removed text first and the new text after it, so by
+ * default every piece goes at `to`. A piece given a comment goes where that
+ * comment's stretch of removed text ends instead, next to it; the pieces
+ * before it that have no comment go where that stretch begins, and the ones
+ * after it follow it. So each comment stays one stretch, holding the removed
+ * text it held and exactly the new text given it.
+ */
+declare const placeTrackedInsertion: (doc: Node, from: number, to: number, pieces: readonly (readonly Mark[])[]) => number[];
+/**
+ * The comments content inserted at the block boundary `at` must carry: those
+ * covering the content on both sides of it. A comment range is two points in
+ * document order, so what lands between them is covered whether the range
+ * crosses paragraphs, empty paragraphs or a table edge, and the saved package
+ * reopens exactly so. A merge's separator lands on such a boundary too.
+ */
+declare const commentsAcrossBlockBoundary: (doc: Node, at: number) => Mark[];
 /** `content` with the surveyed marks on it and the surveyed anchors around it. */
 declare const annotatedReplacement: ({ annotations: { carried, leading, trailing }, content }: AnnotatedReplacementOptions) => AnnotatedReplacement;
 /**
@@ -56,4 +88,4 @@ declare const annotatedReplacement: ({ annotations: { carried, leading, trailing
  */
 declare const inheritedReplacementMarks: (doc: Node, from: number, to: number) => readonly Mark[];
 //#endregion
-export { NON_INCLUSIVE_MARK_DISPOSITION, ReplacedAnnotations, addCarriedMarks, annotatedReplacement, hasReplacedAnnotations, inheritedReplacementMarks, nonInclusiveMarkNames, surveyReplacedAnnotations };
+export { NON_INCLUSIVE_MARK_DISPOSITION, ReplacedAnnotations, addCarriedMarks, annotatedReplacement, commentsAcrossBlockBoundary, commentsForTrackedInsertion, hasReplacedAnnotations, inheritedReplacementMarks, nonInclusiveMarkNames, placeTrackedInsertion, surveyReplacedAnnotations };

package/dist/prosemirror/replacedAnnotations.js

@@ -4,6 +4,7 @@ import { MOVE_RANGE_BOUNDARY_NODE_NAME } from "./extensions/nodes/MoveRangeBound
 import { RANGE_ANCHOR_NODE_NAME } from "./extensions/nodes/RangeAnchorExtension.js";
 import { TEXT_BOX_ANCHOR_NODE_NAME } from "./extensions/nodes/TextBoxAnchorExtension.js";
 import { readMoveRangeBoundaryAttrs } from "./moveRangeBoundaryAttrs.js";
+import { isZeroWidthAnchor } from "./zeroWidthAnchors.js";
 import { Fragment, Mark } from "prosemirror-model";
 //#region src/prosemirror/replacedAnnotations.ts
 /**
@@ -152,6 +153,174 @@ const addCarriedMarks = (marks, carried) => {
 	for (const mark of carried) next = mark.addToSet(next);
 	return next;
 };
+/**
+* Invariant: a comment mark covers ONE contiguous stretch of a paragraph. A
+* save writes one range start and one range end per comment, so a comment on
+* two stretches reopens covering the text between them as well.
+*
+* Text an edit inserts is where that breaks: it lands next to the text of a
+* comment, or inside it. These pick the comments inserted text takes so that
+* every comment stays one stretch.
+*/
+/**
+* The first (`1`) or last (`-1`) inline content inside `node` that is not a
+* zero-width anchor, descending through every container.
+*/
+const innermostEdge = (node, direction) => {
+	if (node.isInline) return isZeroWidthAnchor(node) ? null : node;
+	for (let index = direction === 1 ? 0 : node.childCount - 1; index >= 0 && index < node.childCount; index += direction) {
+		const found = innermostEdge(node.child(index), direction);
+		if (found) return found;
+	}
+	return null;
+};
+/**
+* The inline content nearest the block boundary `at` on one side, in document
+* order: past empty paragraphs, and into and out of tables, the way a saved
+* range's two points read it.
+*/
+const contentBesideBoundary = (doc, at, direction) => {
+	const $at = doc.resolve(at);
+	for (let depth = $at.depth; depth >= 0; depth--) {
+		const parent = $at.node(depth);
+		const index = $at.index(depth);
+		let child = index + direction;
+		if (depth === $at.depth) child = direction === 1 ? index : index - 1;
+		for (; child >= 0 && child < parent.childCount; child += direction) {
+			const found = innermostEdge(parent.child(child), direction);
+			if (found) return found;
+		}
+	}
+	return null;
+};
+/**
+* The content either side of `at` in its paragraph, past zero-width anchors
+* (a comment's own reference sits between its text and what follows).
+*/
+const neighboursAt = (doc, at) => {
+	const $at = doc.resolve(at);
+	const parent = $at.parent;
+	const neighbour = (direction) => {
+		const adjacent = direction === -1 ? $at.nodeBefore : $at.nodeAfter;
+		if (!adjacent || !isZeroWidthAnchor(adjacent)) return adjacent;
+		for (let index = direction === -1 ? $at.index() - 2 : $at.index() + 1; index >= 0 && index < parent.childCount; index += direction) {
+			const child = parent.child(index);
+			if (!isZeroWidthAnchor(child)) return child;
+		}
+		return null;
+	};
+	return {
+		before: neighbour(-1),
+		after: neighbour(1)
+	};
+};
+/** The comments on both `before` and `after`: text between them must carry them. */
+const commentsAround = (before, after) => before && after ? before.marks.filter((mark) => mark.type.name === "comment" && mark.isInSet(after.marks)) : [];
+/**
+* The mark sets of a run of text a TRACKED edit inserts at `at` (one set per
+* piece, in order), with the comments that keep every comment one stretch.
+*
+* A tracked replacement keeps the replaced text (as a deletion), and that text
+* keeps its comments, so a comment carried or inherited onto the insertion
+* only CONTINUES its range: it stays when, through the run, it reaches the
+* content directly before or after `at`, and goes otherwise. Between two
+* pieces that have a comment (the neighbours included), every piece takes
+* it, or the run would split it in two.
+*/
+const commentsForTrackedInsertion = (doc, at, pieces) => {
+	const { before, after } = neighboursAt(doc, at);
+	const sets = [
+		before?.marks ?? [],
+		...pieces,
+		after?.marks ?? []
+	];
+	const comments = [];
+	for (const set of sets) for (const mark of set) if (mark.type.name === "comment" && !mark.isInSet(comments)) comments.push(mark);
+	const result = pieces.map((set) => set.filter((mark) => mark.type.name !== "comment"));
+	for (const comment of comments) {
+		const covered = sets.flatMap((set, index) => comment.isInSet(set) ? [index] : []);
+		const first = covered[0];
+		const last = covered.at(-1);
+		if (first !== 0 && last !== sets.length - 1) continue;
+		for (let index = Math.max(first, 1); index <= Math.min(last, pieces.length); index++) result[index - 1] = comment.addToSet([...result[index - 1]]);
+	}
+	return result;
+};
+/**
+* Where, within the text a tracked replacement removes (`from` to `to`), each
+* piece of its new text goes, one position per piece and never decreasing.
+*
+* The redline reads the removed text first and the new text after it, so by
+* default every piece goes at `to`. A piece given a comment goes where that
+* comment's stretch of removed text ends instead, next to it; the pieces
+* before it that have no comment go where that stretch begins, and the ones
+* after it follow it. So each comment stays one stretch, holding the removed
+* text it held and exactly the new text given it.
+*/
+const placeTrackedInsertion = (doc, from, to, pieces) => {
+	const stretches = /* @__PURE__ */ new Map();
+	doc.nodesBetween(from, to, (node, position) => {
+		if (!node.isText) return true;
+		for (const mark of node.marks) {
+			if (mark.type.name !== "comment") continue;
+			const known = [...stretches.keys()].find((other) => other.eq(mark)) ?? mark;
+			const start = Math.max(position, from);
+			const end = Math.min(position + node.nodeSize, to);
+			const stretch = stretches.get(known);
+			stretches.set(known, stretch ? {
+				start: stretch.start,
+				end
+			} : {
+				start,
+				end
+			});
+		}
+		return false;
+	});
+	const stretchOf = (set) => {
+		const own = [...stretches].filter(([mark]) => mark.isInSet(set));
+		if (own.length === 0) return;
+		const start = Math.min(...own.map(([, stretch]) => stretch.start));
+		const ascending = (left, right) => left - right;
+		const candidates = [...own.map(([, stretch]) => stretch.end).toSorted(ascending), ...own.map(([, stretch]) => stretch.start).toSorted(ascending)];
+		for (const position of candidates) {
+			const { before, after } = neighboursAt(doc, position);
+			if (own.every(([mark]) => Boolean(before && mark.isInSet(before.marks)) || Boolean(after && mark.isInSet(after.marks)))) return {
+				start,
+				end: position
+			};
+		}
+		return {
+			start,
+			end: Math.min(...own.map(([, stretch]) => stretch.end))
+		};
+	};
+	const anchored = pieces.map(stretchOf);
+	const positions = [];
+	let previous = from;
+	for (const [index, stretch] of anchored.entries()) {
+		let position;
+		if (stretch) position = stretch.end;
+		else {
+			const next = anchored.slice(index + 1).find((candidate) => candidate !== void 0);
+			const placedBefore = anchored.slice(0, index).some((candidate) => candidate !== void 0);
+			position = next && !placedBefore ? next.start : to;
+			if (placedBefore && next) position = previous;
+		}
+		position = Math.max(position, previous);
+		positions.push(position);
+		previous = position;
+	}
+	return positions;
+};
+/**
+* The comments content inserted at the block boundary `at` must carry: those
+* covering the content on both sides of it. A comment range is two points in
+* document order, so what lands between them is covered whether the range
+* crosses paragraphs, empty paragraphs or a table edge, and the saved package
+* reopens exactly so. A merge's separator lands on such a boundary too.
+*/
+const commentsAcrossBlockBoundary = (doc, at) => commentsAround(contentBesideBoundary(doc, at, -1), contentBesideBoundary(doc, at, 1));
 const withCarriedMarks = (node, carried) => node.mark(addCarriedMarks(node.marks, carried));
 /** `content` with the surveyed marks on it and the surveyed anchors around it. */
 const annotatedReplacement = ({ annotations: { carried, leading, trailing }, content }) => {
@@ -180,4 +349,4 @@ const inheritedReplacementMarks = (doc, from, to) => {
 	return (to === from ? $from.marks() : $from.marksAcross(doc.resolve(to))) ?? Mark.none;
 };
 //#endregion
-export { NON_INCLUSIVE_MARK_DISPOSITION, addCarriedMarks, annotatedReplacement, hasReplacedAnnotations, inheritedReplacementMarks, nonInclusiveMarkNames, surveyReplacedAnnotations };
+export { NON_INCLUSIVE_MARK_DISPOSITION, addCarriedMarks, annotatedReplacement, commentsAcrossBlockBoundary, commentsForTrackedInsertion, hasReplacedAnnotations, inheritedReplacementMarks, nonInclusiveMarkNames, placeTrackedInsertion, surveyReplacedAnnotations };

package/dist/prosemirror/runFormattingFromMarks.d.ts

@@ -0,0 +1,18 @@
+import { document_d_exports } from "../types/document.js";
+import { RunStyleResolver } from "./runStyleFormatting.js";
+import { Mark } from "prosemirror-model";
+//#region src/prosemirror/runFormattingFromMarks.d.ts
+/**
+ * Convert ProseMirror marks to TextFormatting
+ */
+type MarksToTextFormattingOptions = {
+  baseParagraphFormatting?: document_d_exports.TextFormatting | undefined;
+  inheritedFormatting?: document_d_exports.TextFormatting | undefined;
+  paragraphMarkFormatting?: document_d_exports.TextFormatting | undefined;
+  paragraphMarkPrecedesStyle?: boolean | undefined;
+  styleResolver?: RunStyleResolver | null | undefined;
+};
+declare const sameFormattingValue: (left: unknown, right: unknown) => boolean;
+declare function marksToTextFormatting(marks: readonly Mark[], options?: MarksToTextFormattingOptions): document_d_exports.TextFormatting;
+//#endregion
+export { MarksToTextFormattingOptions, marksToTextFormatting, sameFormattingValue };