@stll/folio-core 0.53.0 → 0.54.0

package/dist/prosemirror/plugins/suggestionMode.js

@@ -1,12 +1,23 @@
-import { expectParagraphAttrs } from "../attrs/index.js";
+import { expectParagraphAttrs, expectTrackedChangeMarkAttrs } from "../attrs/index.js";
+import { paragraphPropertiesSnapshot } from "../commands/propertyChangeScope.js";
+import { paragraphEndsItsContainer } from "../containerFinalParagraph.js";
 import { encloseWholeControls } from "../contentControlRevisions.js";
 import { splitBlockClearBorders } from "../extensions/features/BaseKeymapExtension.js";
+import { JOINED_RUNS_RESTYLED_META } from "../extensions/features/JoinedRunStyleExtension.js";
 import { expandNoteReferenceDeletionRange } from "../extensions/marks/noteReferenceDeletion.js";
+import { carryParagraphProperties, paragraphLeftAfter, recordReplacedParagraphProperties } from "../paragraphPropertyCarry.js";
+import { rebaseParagraphRuns } from "../rebaseParagraphRunFormatting.js";
+import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
+import { paragraphRunStyleContext } from "../runStyleFormatting.js";
+import { cellPasteRange, pasteTableCells } from "../tableCellPaste.js";
 import { handleEditorBeforeInput } from "../textInput.js";
 import { canCarryTrackedRunMark } from "../trackedRunInlineAtoms.js";
+import { getDocumentNumbering } from "./documentNumbering.js";
+import { getDocumentStyleResolver } from "./documentStyleState.js";
 import { mintRevisionId, seedRevisionIdsFromDoc } from "./revisionIds.js";
-import { Mapping } from "prosemirror-transform";
-import { Plugin, PluginKey, TextSelection } from "prosemirror-state";
+import { Slice } from "prosemirror-model";
+import { Mapping, ReplaceStep } from "prosemirror-transform";
+import { AllSelection, Plugin, PluginKey, Selection, TextSelection } from "prosemirror-state";
 import { isHistoryTransaction } from "prosemirror-history";
 import { undoInputRule } from "prosemirror-inputrules";
 //#region src/prosemirror/plugins/suggestionMode.ts
@@ -48,6 +59,27 @@ function makeRevisionInfo(state) {
 		date: attrs.date
 	};
 }
+/**
+* A removed paragraph mark leaves the paragraph after it once accepted. An
+* edit that reads as the paragraph before it (Backspace or Delete at the
+* break, a deletion running from inside one paragraph into another) gives the
+* paragraph left that paragraph's properties now, under the mark's revision:
+* accepting reads as the edit made directly, rejecting restores its own.
+*/
+function carryIntoParagraphLeft(state, tr, source, survivorPos, info) {
+	carryParagraphProperties({
+		tr,
+		position: survivorPos,
+		source,
+		styleResolver: getDocumentStyleResolver(state),
+		numbering: getDocumentNumbering(state),
+		revision: {
+			id: info.id,
+			author: info.author ?? "",
+			date: info.date ?? ""
+		}
+	});
+}
 function makeParagraphMarkInfo(pluginState) {
 	const attrs = makeMarkAttrs(pluginState);
 	return {
@@ -82,7 +114,7 @@ function findAdjacentRevisionForRange(doc, from, to, markTypeName, author) {
 * Retract the current author's own inserted text.
 * Processes in reverse order to maintain position validity.
 */
-function markRangeAsDeleted(tr, doc, from, to, insertionType, deletionType, pluginState) {
+function markRangeAsDeleted(tr, doc, from, to, insertionType, deletionType, pluginState, joinState) {
 	const ranges = [];
 	doc.nodesBetween(from, to, (node, pos) => {
 		if (!canCarryTrackedRunMark(node)) return;
@@ -98,19 +130,38 @@ function markRangeAsDeleted(tr, doc, from, to, insertionType, deletionType, plug
 		});
 	});
 	const delAttrs = findAdjacentRevisionForRange(doc, from, to, "deletion", pluginState.author) || makeMarkAttrs(pluginState);
+	let removedMark = false;
 	doc.nodesBetween(from, to, (node, pos) => {
 		if (node.type.name === "tableRow" && pos >= from && pos + node.nodeSize <= to && node.attrs["trIns"] == null && node.attrs["trDel"] == null) tr.setNodeAttribute(pos, "trDel", delAttrs);
 		if (node.type.name !== "paragraph") return;
 		const boundary = pos + node.nodeSize;
-		if (boundary > from && boundary <= to && node.attrs["pPrMark"] == null) tr.setNodeAttribute(pos, "pPrMark", {
-			kind: "del",
-			info: {
-				id: delAttrs.revisionId,
-				author: delAttrs.author,
-				date: delAttrs.date
-			}
-		});
+		if (boundary > from && boundary <= to && node.attrs["pPrMark"] == null) {
+			tr.setNodeAttribute(pos, "pPrMark", {
+				kind: "del",
+				info: {
+					id: delAttrs.revisionId,
+					author: delAttrs.author,
+					date: delAttrs.date
+				}
+			});
+			removedMark = true;
+		}
 	});
+	const $first = doc.resolve(from);
+	const $last = doc.resolve(to);
+	if (joinState && removedMark && $first.parent.type.name === "paragraph" && $last.parent.type.name === "paragraph" && $first.parent !== $last.parent && from > $first.start()) {
+		const lastPos = doc === tr.doc ? $last.before() : tr.mapping.map($last.before());
+		const lastMark = tr.doc.nodeAt(lastPos)?.attrs["pPrMark"];
+		const survivorPos = lastMark?.kind === "del" || lastMark?.kind === "moveFrom" ? paragraphLeftAfter({
+			doc: tr.doc,
+			paragraphPos: lastPos
+		}) ?? lastPos : lastPos;
+		carryIntoParagraphLeft(joinState, tr, $first.parent, survivorPos, {
+			id: delAttrs.revisionId,
+			author: delAttrs.author,
+			date: delAttrs.date
+		});
+	}
 	if (ranges.length === 0) return;
 	encloseWholeControls({
 		tr,
@@ -124,6 +175,23 @@ function markRangeAsDeleted(tr, doc, from, to, insertionType, deletionType, plug
 		else tr.addMark(range.from, range.to, deletionType.create(delAttrs));
 	}
 }
+/** Preserve clipboard revisions inside the revision that inserted their content. */
+function enclosePastedRunRevisions({ tr, from, to, revision: insertion }) {
+	tr.doc.nodesBetween(from, to, (node, pos) => {
+		if (!canCarryTrackedRunMark(node)) return;
+		const revision = node.marks.find(({ type }) => type.name === "insertion" || type.name === "deletion");
+		if (!revision) return;
+		const previous = expectTrackedChangeMarkAttrs(revision);
+		tr.addMark(Math.max(from, pos), Math.min(to, pos + node.nodeSize), revision.type.create({
+			...revision.attrs,
+			_docxRevisionAncestors: [{
+				type: "insertion",
+				...insertion,
+				outerWrapperCount: 0
+			}, ...previous._docxRevisionAncestors ?? []]
+		}));
+	});
+}
 /**
 * Track every inserted run, paragraph break, and table row in `[from, to)`.
 * Content already carrying a revision keeps its attribution.
@@ -137,10 +205,13 @@ function markRangeAsInserted(tr, doc, from, to, insertionType, deletionType, att
 		if (start >= end) return;
 		tr.addMark(start, end, insertionType.create(attrs));
 	});
+	const $end = doc.resolve(to);
+	const endsBetweenBlocks = !$end.parent.isTextblock && $end.nodeBefore !== null && $end.nodeBefore.type.name !== "paragraph";
 	doc.nodesBetween(from, to, (node, pos) => {
 		if (node.type.name === "paragraph") {
 			const boundary = pos + node.nodeSize;
-			if (boundary > from && boundary < to && node.attrs["pPrMark"] == null) tr.setNodeAttribute(pos, "pPrMark", {
+			const keepsOwnMark = endsBetweenBlocks && boundary - 1 === from;
+			if (boundary > from && boundary < to && !keepsOwnMark && node.attrs["pPrMark"] == null) tr.setNodeAttribute(pos, "pPrMark", {
 				kind: "ins",
 				info: {
 					id: attrs.revisionId,
@@ -162,32 +233,221 @@ function markRangeAsInserted(tr, doc, from, to, insertionType, deletionType, att
 * With track changes on, pasting over a non-empty text selection marks the
 * replaced text as a tracked deletion and the pasted slice as a tracked
 * insertion (so they read as one replacement), matching typing over a
-* selection. Returns false for a collapsed cursor or non-text selection so the
+* selection. Select-all (an `AllSelection`) counts as a text selection over the
+* whole document. Returns false for a collapsed cursor or another selection so the
 * default paste + the `appendTransaction` catch-all marks a plain insertion
 * (eigenpal/docx-editor#784).
 */
 function handleSuggestionPaste(view, slice, pluginState) {
 	const { selection } = view.state;
-	if (!(selection instanceof TextSelection) || selection.empty) return false;
+	const selectsAll = selection instanceof AllSelection;
+	if (!(selection instanceof TextSelection || selectsAll) || selection.empty) return false;
 	const insertionType = view.state.schema.marks["insertion"];
 	const deletionType = view.state.schema.marks["deletion"];
 	if (!insertionType || !deletionType) return false;
-	const { from, to } = selection;
+	if (selectsAll && (slice.openStart > 0 || slice.openEnd > 0)) slice = new Slice(view.state.tr.replaceSelection(slice).doc.content, 0, 0);
+	const { from, to } = selectsAll ? {
+		from: Selection.atStart(view.state.doc).from,
+		to: Selection.atEnd(view.state.doc).to
+	} : selection;
 	const tr = view.state.tr;
 	tr.setMeta(SUGGESTION_META, true);
-	markRangeAsDeleted(tr, view.state.doc, from, to, insertionType, deletionType, pluginState);
-	const insertFrom = tr.mapping.map(to);
-	const sizeBefore = tr.doc.content.size;
-	tr.replaceRange(insertFrom, insertFrom, slice);
-	const insertTo = insertFrom + (tr.doc.content.size - sizeBefore);
-	tr.removeMark(insertFrom, insertTo, deletionType);
-	const insertAttrs = findAdjacentRevision(view.state.doc, from, "insertion", pluginState.author) || makeMarkAttrs(pluginState);
+	const { doc } = view.state;
+	const $from = doc.resolve(from);
+	const $to = doc.resolve(to);
+	const closedBlocks = slice.openStart === 0 && slice.content.firstChild?.isBlock === true;
+	const beforeStruck = closedBlocks && $from.parent.isTextblock && $from.parentOffset === 0;
+	const wholeBlocks = beforeStruck && $to.parent.isTextblock && $to.parentOffset === $to.parent.content.size;
+	const endsContainer = wholeBlocks && paragraphEndsItsContainer(doc.resolve($to.before()), $to.parent.type.name);
+	const rotates = endsContainer && slice.content.firstChild?.type === $to.parent.type && slice.content.lastChild?.type === $to.parent.type;
+	const tableFirst = endsContainer && !rotates;
+	if (!tableFirst) markRangeAsDeleted(tr, doc, from, wholeBlocks && !endsContainer ? $to.after() : to, insertionType, deletionType, pluginState);
+	const carryAcross = () => {
+		if (selectsAll || $from.parent.type.name !== "paragraph" || $from.parent === $to.parent || from <= $from.start()) return;
+		const firstPos = tr.mapping.map($from.before());
+		const mark = tr.doc.nodeAt(firstPos)?.attrs["pPrMark"];
+		const survivorPos = paragraphLeftAfter({
+			doc: tr.doc,
+			paragraphPos: firstPos
+		});
+		if (mark?.kind === "del" && survivorPos !== null) carryIntoParagraphLeft(view.state, tr, $from.parent, survivorPos, mark.info);
+	};
+	const inlineSlice = slice.content.firstChild?.isInline === true;
+	if (inlineSlice) carryAcross();
+	let at = tr.mapping.map(to);
+	if (rotates) at = tr.mapping.map($to.after());
+	else if (tableFirst) at = $from.before();
+	else if (beforeStruck) at = tr.mapping.map(from, -1);
+	const firstStep = tr.steps.length;
+	tr.replaceRange(at, at, slice);
+	const placed = tr.steps.slice(firstStep).flatMap((step, offset) => {
+		const later = new Mapping(tr.mapping.maps.slice(firstStep + offset + 1));
+		const ranges = [];
+		step.getMap().forEach((_oldFrom, _oldTo, newFrom, newTo) => {
+			ranges.push({
+				from: later.map(newFrom, -1),
+				to: later.map(newTo, 1)
+			});
+		});
+		return ranges;
+	});
+	let insertFrom = placed.length === 0 ? at : Math.min(...placed.map((range) => range.from));
+	let insertTo = placed.length === 0 ? at : Math.max(...placed.map((range) => range.to));
+	if (tableFirst) {
+		const struck = tr.steps.length;
+		markRangeAsDeleted(tr, tr.doc, tr.mapping.map(from), tr.mapping.map(to), insertionType, deletionType, pluginState);
+		const since = tr.mapping.slice(struck);
+		insertFrom = since.map(insertFrom, -1);
+		insertTo = since.map(insertTo, -1);
+	}
+	const insertAttrs = findAdjacentRevision(doc, from, "insertion", pluginState.author) || makeMarkAttrs(pluginState);
+	enclosePastedRunRevisions({
+		tr,
+		from: insertFrom,
+		to: insertTo,
+		revision: insertAttrs
+	});
 	markRangeAsInserted(tr, tr.doc, insertFrom, insertTo, insertionType, deletionType, insertAttrs);
+	if (!inlineSlice) carryAcross();
+	if (!closedBlocks && $to.parent.type.name === "paragraph") {
+		const $end = tr.doc.resolve(tr.mapping.map(to));
+		if ($end.parent.type.name === "paragraph" && $end.before() !== tr.mapping.map($from.before())) recordReplacedParagraphProperties({
+			tr,
+			position: $end.before(),
+			replaced: $to.parent,
+			revision: {
+				id: insertAttrs.revisionId,
+				author: insertAttrs.author,
+				date: insertAttrs.date
+			}
+		});
+	}
+	const firstPasted = slice.content.firstChild;
+	if (selectsAll && !closedBlocks && firstPasted?.type.name === "paragraph") {
+		const $first = tr.doc.resolve(insertFrom);
+		if ($first.parent.type.name === "paragraph") carryParagraphProperties({
+			tr,
+			position: $first.before(),
+			source: firstPasted,
+			revision: {
+				id: insertAttrs.revisionId,
+				author: insertAttrs.author,
+				date: insertAttrs.date
+			},
+			styleResolver: getDocumentStyleResolver(view.state),
+			numbering: getDocumentNumbering(view.state)
+		});
+	}
+	if (rotates) {
+		const rotation = tr.steps.length;
+		const joined = rotateIntoFinalParagraph(view.state, tr, tr.mapping.map($to.before()), insertAttrs);
+		insertFrom = Math.min(tr.mapping.slice(rotation).map(insertFrom, -1), joined);
+		insertTo = tr.mapping.slice(rotation).map(insertTo);
+	}
 	tr.setSelection(TextSelection.near(tr.doc.resolve(insertTo)));
 	view.dispatch(tr.scrollIntoView());
 	return true;
 }
 /**
+* With track changes on, a paste into a table's cells (a cell selection, or a
+* block of copied cells) replaces each cell's content the way a paste over a
+* text selection does: the old content struck through, the pasted content
+* after it as an insertion. When the pasted content is whole paragraphs, the
+* last one ends the cell, so its paragraph mark is tracked as added too:
+* rejecting then drops it and accepting joins the struck paragraphs into it.
+*/
+function handleSuggestionTableCellPaste(view, slice, pluginState) {
+	const insertionType = view.state.schema.marks["insertion"];
+	const deletionType = view.state.schema.marks["deletion"];
+	if (!insertionType || !deletionType) return false;
+	const revision = makeMarkAttrs(pluginState);
+	return pasteTableCells(view.state, slice, (tr) => view.dispatch(tr.setMeta(SUGGESTION_META, true)), {
+		revision,
+		replaceCellContent: (tr, cellPos, content) => {
+			const cell = tr.doc.nodeAt(cellPos);
+			if (!cell) return;
+			const { from, to } = cellPasteRange(cell, cellPos, content);
+			const mapFrom = tr.mapping.maps.length;
+			markRangeAsDeleted(tr, tr.doc, from, to, insertionType, deletionType, pluginState);
+			const insertFrom = tr.mapping.slice(mapFrom).map(to);
+			const sizeBefore = tr.doc.content.size;
+			tr.replaceRange(insertFrom, insertFrom, content);
+			const insertTo = insertFrom + (tr.doc.content.size - sizeBefore);
+			enclosePastedRunRevisions({
+				tr,
+				from: insertFrom,
+				to: insertTo,
+				revision
+			});
+			markRangeAsInserted(tr, tr.doc, insertFrom, insertTo, insertionType, deletionType, revision);
+			tr.doc.nodesBetween(insertFrom, insertTo, (node, pos) => {
+				if (node.type.name === "paragraph" && pos >= insertFrom && pos + node.nodeSize <= insertTo && node.attrs["pPrMark"] == null) tr.setNodeAttribute(pos, "pPrMark", {
+					kind: "ins",
+					info: {
+						id: revision.revisionId,
+						author: revision.author,
+						date: revision.date
+					}
+				});
+			});
+		}
+	});
+}
+/**
+* Pasted paragraphs replaced a container's last paragraph. They were placed
+* after it, and the paragraph was struck but keeps its mark, as a container's
+* last paragraph must. Join the first pasted paragraph onto it, so the struck
+* text and the first paste share one paragraph whose break is the inserted one,
+* and record the replaced paragraph's formatting on the paragraph that now ends
+* the container: accepting leaves only the paste, and rejecting closes every
+* pasted break back into one paragraph that returns to its old formatting.
+* Returns the position of the joined paragraph.
+*/
+function rotateIntoFinalParagraph(state, tr, replacedPos, attrs) {
+	const replaced = tr.doc.nodeAt(replacedPos);
+	const first = replaced ? tr.doc.nodeAt(replacedPos + replaced.nodeSize) : null;
+	if (!replaced || !first) return replacedPos;
+	const replacedAttrs = expectParagraphAttrs(replaced);
+	const previousFormatting = {
+		...paragraphPropertiesSnapshot(replaced),
+		numPr: replacedAttrs.numPr ?? null
+	};
+	const { _sectionProperties: sectionProperties } = replaced.attrs;
+	tr.join(replacedPos + replaced.nodeSize);
+	tr.setNodeMarkup(replacedPos, void 0, first.attrs);
+	const styleResolver = getDocumentStyleResolver(state);
+	if (styleResolver && replaced.content.size > 0) rebaseParagraphRuns({
+		previousContext: paragraphRunStyleContext(replaced, styleResolver),
+		paragraphPosition: replacedPos,
+		range: {
+			from: 0,
+			to: replaced.content.size
+		},
+		styleResolver,
+		tr
+	});
+	const $joined = tr.doc.resolve(replacedPos);
+	const container = $joined.parent;
+	let finalPos = replacedPos;
+	for (let index = $joined.index(); index < container.childCount - 1; index += 1) finalPos += container.child(index).nodeSize;
+	const final = tr.doc.nodeAt(finalPos);
+	if (final) tr.setNodeMarkup(finalPos, void 0, {
+		...final.attrs,
+		pPrMark: null,
+		...sectionProperties == null ? {} : { _sectionProperties: sectionProperties },
+		_propertyChanges: [{
+			type: "paragraphPropertyChange",
+			info: {
+				id: attrs.revisionId,
+				author: attrs.author,
+				date: attrs.date
+			},
+			previousFormatting
+		}]
+	});
+	return replacedPos;
+}
+/**
 * Insert text as a tracked insertion, optionally marking replaced selection as deletion.
 */
 function applySuggestionInsert(view, from, to, text, pluginState) {
@@ -196,20 +456,65 @@ function applySuggestionInsert(view, from, to, text, pluginState) {
 	const tr = view.state.tr;
 	tr.setMeta(SUGGESTION_META, true);
 	tr.setMeta(SUGGESTED_TEXT_INPUT_META, text);
+	const selectsAll = view.state.selection instanceof AllSelection;
+	if (selectsAll) {
+		from = Math.max(from, Selection.atStart(view.state.doc).from);
+		to = Math.min(to, Selection.atEnd(view.state.doc).to);
+	}
+	const replacedFormatting = selectsAll ? (view.state.doc.resolve(from).nodeAfter?.marks ?? []).filter(({ type }) => RUN_FORMATTING_MARK_NAMES.has(type.name)) : null;
 	const insertAttrs = findAdjacentRevision(view.state.doc, from, "insertion", pluginState.author) || makeMarkAttrs(pluginState);
 	if (from !== to) {
 		const deletionType = view.state.schema.marks["deletion"];
-		if (deletionType) markRangeAsDeleted(tr, view.state.doc, from, to, insertionType, deletionType, pluginState);
+		if (deletionType) markRangeAsDeleted(tr, view.state.doc, from, to, insertionType, deletionType, pluginState, view.state);
 	}
 	const insertAt = tr.mapping.map(to);
 	tr.insertText(text, insertAt, insertAt);
 	const deletionType = view.state.schema.marks["deletion"];
 	if (deletionType) tr.removeMark(insertAt, insertAt + text.length, deletionType);
 	tr.addMark(insertAt, insertAt + text.length, insertionType.create(insertAttrs));
+	if (replacedFormatting) {
+		for (const mark of tr.doc.resolve(insertAt).nodeAfter?.marks ?? []) if (RUN_FORMATTING_MARK_NAMES.has(mark.type.name)) tr.removeMark(insertAt, insertAt + text.length, mark.type);
+		for (const mark of replacedFormatting) tr.addMark(insertAt, insertAt + text.length, mark);
+	}
+	separateSplitStretch(tr, insertAt, insertAt + text.length, insertAttrs.revisionId);
+	if (view.state.selection instanceof AllSelection) tr.setSelection(TextSelection.create(tr.doc, insertAt + text.length));
 	view.dispatch(tr.scrollIntoView());
 	return true;
 }
 /**
+* Text typed inside another revision leaves that revision in two stretches.
+* A saved package writes each stretch as a wrapper of its own with its own
+* `w:id`, so the stretch after the typed text gets a fresh id now: the editor
+* lists, resolves and saves the same changes a reopened package does.
+*/
+function separateSplitStretch(tr, from, to, typedId) {
+	const $from = tr.doc.resolve(from);
+	const $to = tr.doc.resolve(to);
+	const before = $from.nodeBefore;
+	if (!before || $to.parent !== $from.parent) return;
+	const parent = $to.parent;
+	const start = $to.start();
+	for (const mark of before.marks) {
+		if (mark.type.name !== "insertion" && mark.type.name !== "deletion") continue;
+		const revisionId = mark.attrs["revisionId"];
+		if (revisionId === typedId || typeof revisionId !== "number") continue;
+		let end = to;
+		let offset = to - start;
+		while (offset < parent.content.size) {
+			const child = parent.childAfter(offset).node;
+			if (!child?.marks.some((candidate) => candidate.eq(mark))) break;
+			offset += child.nodeSize;
+			end = start + offset;
+		}
+		if (end === to) continue;
+		tr.removeMark(to, end, mark);
+		tr.addMark(to, end, mark.type.create({
+			...mark.attrs,
+			revisionId: mintRevisionId()
+		}));
+	}
+}
+/**
 * Remove `from`..`to` of `tr.doc` as a suggestion: text the current author
 * inserted is retracted, anything else is marked deleted. `false` when the
 * editor is not suggesting.
@@ -248,6 +553,13 @@ function handleSuggestionEnter(view, pluginState) {
 				info: makeParagraphMarkInfo(pluginState)
 			};
 			tr.setNodeAttribute(sourcePos, "pPrMark", markInfo);
+			const $caret = tr.selection.$from;
+			if ($caret.parent.type.name === "paragraph" && $caret.before() !== sourcePos) recordReplacedParagraphProperties({
+				tr,
+				position: $caret.before(),
+				replaced: $from.parent,
+				revision: markInfo.info
+			});
 		}
 	}
 	view.dispatch(tr.scrollIntoView());
@@ -301,9 +613,22 @@ function applyPPrDel(view, targetParagraphPos, pluginState) {
 		const tr = view.state.tr;
 		tr.setMeta(SUGGESTION_META, true);
 		const joinPos = targetParagraphPos + targetNode.nodeSize;
+		const joined = view.state.doc.nodeAt(joinPos);
 		try {
 			tr.join(joinPos);
 			tr.setNodeAttribute(targetParagraphPos, "pPrMark", null);
+			const styleResolver = getDocumentStyleResolver(view.state);
+			if (styleResolver && joined?.type === targetNode.type && joined.content.size > 0) rebaseParagraphRuns({
+				previousContext: paragraphRunStyleContext(joined, styleResolver),
+				paragraphPosition: targetParagraphPos,
+				range: {
+					from: targetNode.content.size,
+					to: targetNode.content.size + joined.content.size
+				},
+				styleResolver,
+				tr
+			});
+			tr.setMeta(JOINED_RUNS_RESTYLED_META, true);
 			view.dispatch(tr.scrollIntoView());
 		} catch {
 			return true;
@@ -318,6 +643,10 @@ function applyPPrDel(view, targetParagraphPos, pluginState) {
 		info: makeParagraphMarkInfo(pluginState)
 	};
 	tr.setNodeAttribute(targetParagraphPos, "pPrMark", markInfo);
+	carryIntoParagraphLeft(view.state, tr, targetNode, paragraphLeftAfter({
+		doc: tr.doc,
+		paragraphPos: targetParagraphPos
+	}) ?? targetParagraphPos + targetNode.nodeSize, markInfo.info);
 	view.dispatch(tr.scrollIntoView());
 	return true;
 }
@@ -345,7 +674,7 @@ function handleSuggestionDelete(state, dispatch, direction) {
 			from: rangeFrom.pos,
 			to: rangeTo.pos
 		}).sort((a, b) => b.from - a.from);
-		for (const { from, to } of ranges) markRangeAsDeleted(tr, state.doc, from, to, insertionType, deletionType, pluginState);
+		for (const { from, to } of ranges) markRangeAsDeleted(tr, state.doc, from, to, insertionType, deletionType, pluginState, state);
 		const cursorPos = tr.mapping.map($to.pos);
 		tr.setSelection(TextSelection.near(tr.doc.resolve(cursorPos)));
 		dispatch(tr.scrollIntoView());
@@ -414,6 +743,33 @@ function markComposedAsInsertion(view, from, pluginState, replaced) {
 	view.dispatch(tr);
 }
 /**
+* Paragraphs inserted into one (a paste at the caret) split it: its break ends
+* the last part, which reads as the last inserted paragraph. Rejecting the
+* inserted breaks leaves that part, so it records what the paragraph read as.
+*/
+function recordSplitParagraph(tr, before, step, insertedFrom, insertedTo, attrs) {
+	if (!(step instanceof ReplaceStep) || !before) return;
+	const $at = before.resolve(step.from);
+	if ($at.parent.type.name !== "paragraph" || step.to > $at.after() || before.textBetween(step.from, step.to) !== "") return;
+	const split = $at.parent;
+	const $first = tr.doc.resolve(insertedFrom);
+	const $last = tr.doc.resolve(insertedTo);
+	let lastPos = null;
+	if ($last.parent.type.name === "paragraph") lastPos = $last.before();
+	else if ($last.nodeBefore?.type.name === "paragraph") lastPos = insertedTo - $last.nodeBefore.nodeSize;
+	if ($first.parent.type.name !== "paragraph" || lastPos === null || lastPos === $first.before()) return;
+	recordReplacedParagraphProperties({
+		tr,
+		position: lastPos,
+		replaced: split,
+		revision: {
+			id: attrs.revisionId,
+			author: attrs.author,
+			date: attrs.date
+		}
+	});
+}
+/**
 * Create the suggestion mode plugin.
 * When active, text edits become tracked changes.
 */
@@ -490,7 +846,7 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 			handleKeyDown(view, event) {
 				const pluginState = suggestionModeKey.getState(view.state);
 				if (!pluginState?.active) return false;
-				if (event.key === "Enter") {
+				if (event.key === "Enter" && !event.shiftKey && !event.metaKey && !event.ctrlKey && !event.altKey) {
 					const { $from, empty } = view.state.selection;
 					if (empty && $from.parent.type.name === "paragraph" && expectParagraphAttrs($from.parent).numPr?.kind === "reference") return false;
 					return handleSuggestionEnter(view, pluginState);
@@ -515,7 +871,7 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 			handlePaste(view, _event, slice) {
 				const pluginState = suggestionModeKey.getState(view.state);
 				if (!pluginState?.active) return false;
-				return handleSuggestionPaste(view, slice, pluginState);
+				return handleSuggestionTableCellPaste(view, slice, pluginState) || handleSuggestionPaste(view, slice, pluginState);
 			}
 		},
 		appendTransaction(transactions, _oldState, newState) {
@@ -538,7 +894,14 @@ function createSuggestionModePlugin(initialActive = false, author = "User") {
 					const newFrom = following.map(stepFrom, -1);
 					const newTo = following.map(stepTo, 1);
 					if (newTo > newFrom) {
+						if (userTr.getMeta("paste")) enclosePastedRunRevisions({
+							tr,
+							from: newFrom,
+							to: newTo,
+							revision: markAttrs
+						});
 						if (deletionType) markRangeAsInserted(tr, newState.doc, newFrom, newTo, insertionType, deletionType, markAttrs);
+						recordSplitParagraph(tr, userTr.docs[stepIndex], step, newFrom, newTo, markAttrs);
 					}
 				});
 			}
@@ -573,4 +936,4 @@ function isSuggestionModeActive(state) {
 	return suggestionModeKey.getState(state)?.active ?? false;
 }
 //#endregion
-export { SUGGESTED_TEXT_INPUT_META, SUGGESTION_BYPASS_META, SUGGESTION_META, createSuggestionModePlugin, deleteSelectionAsSuggestion, handleSuggestionEnter, handleSuggestionPaste, isSuggestionModeActive, makeRevisionInfo, paragraphBoundaryTarget, setSuggestionMode, suggestRangeDeletion, suggestionModeKey, toggleSuggestionMode };
+export { SUGGESTED_TEXT_INPUT_META, SUGGESTION_BYPASS_META, SUGGESTION_META, createSuggestionModePlugin, deleteSelectionAsSuggestion, handleSuggestionEnter, handleSuggestionPaste, handleSuggestionTableCellPaste, isSuggestionModeActive, makeRevisionInfo, paragraphBoundaryTarget, setSuggestionMode, suggestRangeDeletion, suggestionModeKey, toggleSuggestionMode };

package/dist/prosemirror/rebaseParagraphRunFormatting.d.ts

@@ -1,6 +1,7 @@
-import { RunStyleResolver } from "./runStyleFormatting.js";
+import { ParagraphRunStyleContext, RunStyleResolver } from "./runStyleFormatting.js";
 import { Node } from "prosemirror-model";
 import { Transaction } from "prosemirror-state";
+import { Transform } from "prosemirror-transform";
 //#region src/prosemirror/rebaseParagraphRunFormatting.d.ts
 type RebaseParagraphRunFormattingOptions = {
   nextAttrs: Record<string, unknown>;
@@ -9,10 +10,29 @@ type RebaseParagraphRunFormattingOptions = {
   styleResolver: RunStyleResolver;
   tr: Transaction;
 };
+type RebaseParagraphRunsOptions<T extends Transform> = {
+  /** The style context the runs' marks were resolved in. */
+  previousContext: ParagraphRunStyleContext;
+  paragraphPosition: number;
+  /** Content offsets inside the paragraph to rebase; all of it when omitted. */
+  range?: {
+    from: number;
+    to: number;
+  };
+  shouldRebase?: (node: Node) => boolean;
+  styleResolver: RunStyleResolver;
+  tr: T;
+};
+/**
+ * Re-resolve the inherited marks of runs resolved in `previousContext` in the
+ * paragraph's current style context: direct formatting stays direct, and what
+ * the old context lent the runs goes with it.
+ */
+declare const rebaseParagraphRuns: <T extends Transform>({ previousContext, paragraphPosition, range, shouldRebase, styleResolver, tr }: RebaseParagraphRunsOptions<T>) => T;
 /**
  * Change paragraph attrs and re-resolve inherited run marks in the new style
  * context without turning the old rendered style into direct run formatting.
  */
 declare const setParagraphAttrsWithRebasedRunFormatting: ({ nextAttrs, paragraphPosition, shouldRebase, styleResolver, tr }: RebaseParagraphRunFormattingOptions) => Transaction;
 //#endregion
-export { setParagraphAttrsWithRebasedRunFormatting };
+export { rebaseParagraphRuns, setParagraphAttrsWithRebasedRunFormatting };