@stll/folio-core 0.52.0 → 0.54.0

package/dist/prosemirror/extensions/features/ListExtension.js

@@ -1,18 +1,18 @@
-import { isBulletLevel } from "../../../docx/numberingParser.js";
-import { NO_PARAGRAPH_NUMBERING, paragraphNumberingLevel, paragraphNumberingReference, paragraphNumberingReferenceId } from "../../../docx/numberingReference.js";
+import { paragraphNumberingLevel, paragraphNumberingReferenceId } from "../../../docx/numberingReference.js";
 import { expectParagraphAttrs } from "../../attrs/index.js";
-import { PPR_CHANGE_SCOPED_ATTR_KEYS, hasSerializableParagraphPropertyChange } from "../../commands/propertyChangeScope.js";
+import { LIST_MARKER_PATTERN, listRequestsForMarker } from "../../listAutoformatMarkers.js";
 import { CLEARED_LIST_RENDERING_ATTRS } from "../../listMarker.js";
-import { LIST_RENDERING_ATTR_KEYS } from "../../listRenderingAttrs.js";
+import { applyParagraphUpdates, continueNumbering, listItemAttrs, resolveListTarget, restartNumbering, setNumberingValue } from "../../listNumbering.js";
 import { resolveListState } from "../../listState.js";
-import { paragraphNumberingAttr } from "../../numberingAttr.js";
+import { removedNumberingAttr } from "../../numberingAttr.js";
 import { getDocumentNumbering } from "../../plugins/documentNumbering.js";
-import { SUGGESTION_META, makeRevisionInfo } from "../../plugins/suggestionMode.js";
-import { listLevelAttrPatch } from "../../styles/resolvedStyleAttrs.js";
+import { SUGGESTION_META, makeRevisionInfo, suggestRangeDeletion } from "../../plugins/suggestionMode.js";
+import { listLevelAttrPatch, listLevelIndentRemovalPatch } from "../../styles/resolvedStyleAttrs.js";
 import { createExtension } from "../create.js";
 import { goToNextCell, goToPrevCell } from "../nodes/TableExtension.js";
 import { Priority } from "../types.js";
 import { panic } from "better-result";
+import { Plugin } from "prosemirror-state";
 import { InputRule, inputRules, undoInputRule } from "prosemirror-inputrules";
 //#region src/prosemirror/extensions/features/ListExtension.ts
 /**
@@ -27,113 +27,88 @@ function chainCommands(...commands) {
 		return false;
 	};
 }
-function appendParagraphPropertyChange(attrs, existing, previousFormatting, rev) {
+function clearListAttrs(attrs, numbering) {
 	return {
 		...attrs,
-		_propertyChanges: [...existing ?? [], {
-			type: "paragraphPropertyChange",
-			info: {
-				id: rev.id,
-				author: rev.author,
-				date: rev.date
-			},
-			previousFormatting
-		}]
-	};
-}
-function getPreviousListFormatting(attrs) {
-	const previousFormatting = {};
-	for (const key of PPR_CHANGE_SCOPED_ATTR_KEYS) {
-		const value = attrs[key];
-		if (value != null) previousFormatting[key] = value;
-	}
-	previousFormatting["numPr"] = attrs["numPr"] ?? null;
-	for (const key of LIST_RENDERING_ATTR_KEYS) previousFormatting[key] = attrs[key] ?? null;
-	return previousFormatting;
-}
-function clearListAttrs(attrs) {
-	const numPr = paragraphNumberingReferenceId(attrs.numPrFromStyle) === void 0 ? null : paragraphNumberingAttr(NO_PARAGRAPH_NUMBERING);
-	return {
-		...attrs,
-		numPr,
+		...listLevelIndentRemovalPatch(attrs, numbering),
+		numPr: removedNumberingAttr(attrs.numPrFromStyle),
 		...CLEARED_LIST_RENDERING_ATTRS
 	};
 }
 function hasActiveListNumbering(attrs) {
 	return attrs.numPr?.kind === "reference";
 }
+const paragraphsBetween = (doc, from, to) => {
+	const paragraphs = [];
+	doc.nodesBetween(from, to, (node, pos) => {
+		if (node.type.name !== "paragraph") return true;
+		paragraphs.push({
+			pos,
+			node
+		});
+		return false;
+	});
+	return paragraphs;
+};
 /**
-* The numbering instances Folio mints for its own toolbar lists. They are the
-* ids the autoformat rules and the list buttons create; a document Folio did
-* not create numbers its lists however its author did, which is why nothing
-* reads a list's kind off its id any more.
+* Make every paragraph from `from` to `to` an item of one list: the list next
+* to them when it matches, else a new one (see `listNumbering.ts`). One
+* target for the whole range, so a selection of plain paragraphs becomes one
+* list rather than one list apiece.
 */
-const FOLIO_BULLET_NUM_ID = 1;
-const FOLIO_NUMBERED_NUM_ID = 2;
-const targetNumIdForIntent = (numbering, preferredNumId, ilvl, intent) => {
-	const matchesIntent = (numId) => {
-		const level = numbering?.getLevel(numId, ilvl) ?? null;
-		return level !== null && (isBulletLevel(level) ? "bullet" : "numbered") === intent;
-	};
-	if (matchesIntent(preferredNumId)) return preferredNumId;
-	return numbering?.definitions.nums.find(({ numId }) => matchesIntent(numId))?.numId ?? preferredNumId;
+const numberParagraphs = ({ state, tr, from, to, requests }) => {
+	const target = resolveListTarget({
+		numbering: getDocumentNumbering(state),
+		$from: tr.doc.resolve(from),
+		$to: tr.doc.resolve(to),
+		requests
+	});
+	if (!target) return false;
+	applyParagraphUpdates({
+		tr,
+		state,
+		updates: paragraphsBetween(tr.doc, from, to).map(({ pos, node }) => ({
+			pos,
+			node,
+			next: listItemAttrs(expectParagraphAttrs(node), {
+				numId: target.numId,
+				ilvl: paragraphNumberingLevel(expectParagraphAttrs(node).numPr) ?? target.ilvl
+			}, target.numbering)
+		}))
+	});
+	return true;
 };
-function toggleList(numId, intent) {
+function toggleList(intent) {
 	return (state, dispatch) => {
 		const { $from, $to } = state.selection;
 		const paragraph = $from.parent;
 		if (paragraph.type.name !== "paragraph") return false;
-		const numbering = getDocumentNumbering(state);
-		const isInSameList = resolveListState(numbering, expectParagraphAttrs(paragraph).numPr).type === intent;
-		const rev = makeRevisionInfo(state);
-		if (rev) {
-			let hasPendingChange = false;
-			state.doc.nodesBetween($from.pos, $to.pos, (node) => {
-				if (node.type.name === "paragraph" && hasSerializableParagraphPropertyChange(expectParagraphAttrs(node)._propertyChanges)) {
-					hasPendingChange = true;
-					return false;
-				}
-			});
-			if (hasPendingChange) return false;
-		}
 		if (!dispatch) return true;
-		let tr = state.tr;
-		const seen = /* @__PURE__ */ new Set();
-		state.doc.nodesBetween($from.pos, $to.pos, (node, pos) => {
-			if (node.type.name === "paragraph" && !seen.has(pos)) {
-				seen.add(pos);
-				let nextAttrs;
-				if (isInSameList) nextAttrs = clearListAttrs(expectParagraphAttrs(node));
-				else {
-					const ilvl = paragraphNumberingLevel(expectParagraphAttrs(node).numPr) ?? 0;
-					const targetNumId = targetNumIdForIntent(numbering, numId, ilvl, intent);
-					const definition = numbering?.getLevel(targetNumId, ilvl) ?? null;
-					const isBullet = definition === null ? intent === "bullet" : isBulletLevel(definition);
-					nextAttrs = {
-						...node.attrs,
-						...CLEARED_LIST_RENDERING_ATTRS,
-						numPr: paragraphNumberingAttr(paragraphNumberingReference({
-							numId: targetNumId,
-							ilvl
-						})),
-						listIsBullet: isBullet,
-						listNumFmt: isBullet ? null : definition?.numFmt ?? "decimal"
-					};
-				}
-				if (rev) {
-					const existing = expectParagraphAttrs(node)._propertyChanges;
-					nextAttrs = appendParagraphPropertyChange(nextAttrs, existing, getPreviousListFormatting(node.attrs), rev);
-				}
-				tr = tr.setNodeMarkup(pos, void 0, nextAttrs);
-			}
+		const numbering = getDocumentNumbering(state);
+		const isItemOfKind = (node) => resolveListState(numbering, expectParagraphAttrs(node).numPr).type === intent;
+		const tr = state.tr;
+		if (isItemOfKind(paragraph)) applyParagraphUpdates({
+			tr,
+			state,
+			updates: paragraphsBetween(state.doc, $from.pos, $to.pos).filter(({ node }) => isItemOfKind(node)).map(({ pos, node }) => ({
+				pos,
+				node,
+				next: clearListAttrs(expectParagraphAttrs(node), getDocumentNumbering(state))
+			}))
+		});
+		else numberParagraphs({
+			state,
+			tr,
+			from: $from.pos,
+			to: $to.pos,
+			requests: [{ kind: intent }]
 		});
-		if (rev) tr.setMeta(SUGGESTION_META, true);
 		dispatch(tr.scrollIntoView());
 		return true;
 	};
 }
-const toggleBulletList = (state, dispatch) => toggleList(FOLIO_BULLET_NUM_ID, "bullet")(state, dispatch);
-const toggleNumberedList = (state, dispatch) => toggleList(FOLIO_NUMBERED_NUM_ID, "numbered")(state, dispatch);
+const toggleBulletList = (state, dispatch) => toggleList("bullet")(state, dispatch);
+const toggleNumberedList = (state, dispatch) => toggleList("numbered")(state, dispatch);
 const attrsForListLevel = (state, attrs, level) => {
 	if (!hasActiveListNumbering(attrs)) panic("Cannot change the level of a list without a numbering id");
 	return {
@@ -167,7 +142,7 @@ const decreaseListLevel = (state, dispatch) => {
 	if (!dispatch) return true;
 	const paragraphPos = $from.before($from.depth);
 	if (currentLevel <= 0) dispatch(state.tr.setNodeMarkup(paragraphPos, void 0, {
-		...clearListAttrs(attrs),
+		...clearListAttrs(attrs, getDocumentNumbering(state)),
 		indentLeft: null,
 		indentFirstLine: null,
 		hangingIndent: null
@@ -183,7 +158,7 @@ const removeList = (state, dispatch) => {
 	state.doc.nodesBetween($from.pos, $to.pos, (node, pos) => {
 		if (node.type.name === "paragraph" && hasActiveListNumbering(expectParagraphAttrs(node)) && !seen.has(pos)) {
 			seen.add(pos);
-			tr = tr.setNodeMarkup(pos, void 0, clearListAttrs(expectParagraphAttrs(node)));
+			tr = tr.setNodeMarkup(pos, void 0, clearListAttrs(expectParagraphAttrs(node), getDocumentNumbering(state)));
 		}
 	});
 	dispatch(tr.scrollIntoView());
@@ -215,7 +190,19 @@ function exitListOnEmptyEnter() {
 		const attrs = expectParagraphAttrs(paragraph);
 		if (!hasActiveListNumbering(attrs)) return false;
 		if (paragraph.textContent.length > 0) return false;
-		if (dispatch) dispatch(state.tr.setNodeMarkup($from.before(), void 0, clearListAttrs(attrs)));
+		if (dispatch) {
+			const tr = state.tr;
+			applyParagraphUpdates({
+				tr,
+				state,
+				updates: [{
+					pos: $from.before(),
+					node: paragraph,
+					next: clearListAttrs(attrs, getDocumentNumbering(state))
+				}]
+			});
+			dispatch(tr);
+		}
 		return true;
 	};
 }
@@ -229,10 +216,19 @@ function splitListItem() {
 		if (dispatch) {
 			const { tr } = state;
 			const pos = $from.pos;
+			const paragraphPos = $from.before();
+			const revision = makeRevisionInfo(state);
 			tr.split(pos, 1, [{
 				type: state.schema.nodes["paragraph"],
 				attrs: { ...paragraph.attrs }
 			}]);
+			if (revision && paragraph.attrs["pPrMark"] == null) {
+				tr.setNodeAttribute(paragraphPos, "pPrMark", {
+					kind: "ins",
+					info: revision
+				});
+				tr.setMeta(SUGGESTION_META, true);
+			}
 			dispatch(tr.scrollIntoView());
 		}
 		return true;
@@ -247,7 +243,19 @@ function backspaceExitList() {
 		if (paragraph.type.name !== "paragraph") return false;
 		const attrs = expectParagraphAttrs(paragraph);
 		if (!hasActiveListNumbering(attrs)) return false;
-		if (dispatch) dispatch(state.tr.setNodeMarkup($from.before(), void 0, clearListAttrs(attrs)));
+		if (dispatch) {
+			const tr = state.tr;
+			applyParagraphUpdates({
+				tr,
+				state,
+				updates: [{
+					pos: $from.before(),
+					node: paragraph,
+					next: clearListAttrs(attrs, getDocumentNumbering(state))
+				}]
+			});
+			dispatch(tr);
+		}
 		return true;
 	};
 }
@@ -293,7 +301,7 @@ function decreaseListIndent() {
 			for (const { pos, attrs } of positions) {
 				const currentLevel = attrs.numPr.ilvl ?? 0;
 				if (currentLevel <= 0) tr = tr.setNodeMarkup(pos, void 0, {
-					...clearListAttrs(attrs),
+					...clearListAttrs(attrs, getDocumentNumbering(state)),
 					indentLeft: null,
 					indentFirstLine: null,
 					hangingIndent: null
@@ -314,53 +322,84 @@ function insertTab() {
 		return true;
 	};
 }
+/** Whether a typed marker may become a list here at all. */
+const acceptsListMarker = (paragraph) => paragraph.type.name === "paragraph" && paragraphNumberingReferenceId(expectParagraphAttrs(paragraph).numPr) === void 0;
 /**
-* Word's as-you-type markers. Each ends in the space that triggers the rule.
-* `1.` starts a numbered list at one, like the toolbar button; another typed
-* number stays text rather than being silently renumbered.
+* Replace a typed marker with the list the toolbar button produces: the same
+* target resolution and the same attrs, so an autoformatted list saves exactly
+* like a clicked one. The marker's format and value choose the list (see
+* `listAutoformatMarkers.ts`).
 */
-const BULLET_AUTOFORMAT = /^[-*] $/u;
-const NUMBERED_AUTOFORMAT = /^1\. $/u;
-const captureTransaction = (command, state) => {
-	const captured = { transaction: null };
-	command(state, (transaction) => {
-		captured.transaction = transaction;
-	});
-	return captured.transaction;
-};
-/**
-* Replace a typed marker with the list the toolbar button produces. Running the
-* command itself (rather than writing `numPr` here) keeps an autoformatted list
-* identical to a clicked one, down to what the document saves.
-*/
-const listAutoformat = (marker, toggleCommand) => new InputRule(marker, (state, _match, start, end) => {
+const listAutoformatRule = () => new InputRule(LIST_MARKER_PATTERN, (state, match, start, end) => {
 	const { $from } = state.selection;
-	if ($from.parent.type.name !== "paragraph") return null;
+	if (!acceptsListMarker($from.parent)) return null;
 	if (start !== $from.start()) return null;
-	if (paragraphNumberingReferenceId(expectParagraphAttrs($from.parent).numPr) !== void 0) return null;
 	if (makeRevisionInfo(state)) return null;
-	const toggled = captureTransaction(toggleCommand, state);
-	if (!toggled) return null;
+	const requests = listRequestsForMarker(match[0]);
+	if (!requests) return null;
 	const tr = state.tr.delete(start, end);
-	for (const step of toggled.steps) {
-		const mapped = step.map(tr.mapping);
-		if (mapped) tr.step(mapped);
-	}
-	return tr;
+	return numberParagraphs({
+		state,
+		tr,
+		from: start,
+		to: start,
+		requests
+	}) ? tr : null;
 });
-const listAutoformatRules = () => inputRules({ rules: [listAutoformat(BULLET_AUTOFORMAT, toggleBulletList), listAutoformat(NUMBERED_AUTOFORMAT, toggleNumberedList)] });
+/**
+* List autoformat while suggesting. The suggestion plugin has already
+* recorded the typed space as a tracked insertion; this follows it with the
+* marker's removal (a retraction of the author's own typing, or a tracked
+* deletion of text that was there before) and the list as a tracked
+* paragraph-property change. The follow-up is appended to the typing
+* transaction, so one undo reverts both, and it is stored as the input rule's
+* last conversion, so Backspace puts the marker back as it does while editing.
+*/
+const suggestedListAutoformat = (autoformat) => new Plugin({ appendTransaction(transactions, _oldState, state) {
+	if (!transactions.some((tr) => tr.getMeta("suggestionModeTextInput") === " ")) return null;
+	const { $head, empty } = state.selection;
+	if (!empty || !makeRevisionInfo(state) || !acceptsListMarker($head.parent)) return null;
+	const requests = listRequestsForMarker($head.parent.textBetween(0, $head.parentOffset, null, ""));
+	if (!requests) return null;
+	const start = $head.start();
+	const tr = state.tr;
+	if (!suggestRangeDeletion(state, tr, start, $head.pos)) return null;
+	const from = tr.mapping.map(start);
+	if (!numberParagraphs({
+		state,
+		tr,
+		from,
+		to: from,
+		requests
+	})) return null;
+	const caret = tr.mapping.map($head.pos);
+	tr.setMeta(autoformat, {
+		transform: tr,
+		from: caret,
+		to: caret,
+		text: ""
+	});
+	return tr;
+} });
+const listAutoformatPlugins = () => {
+	const autoformat = inputRules({ rules: [listAutoformatRule()] });
+	return [autoformat, suggestedListAutoformat(autoformat)];
+};
 const ListExtension = createExtension({
 	name: "list",
 	priority: Priority.High,
 	onSchemaReady() {
 		return {
-			plugins: [listAutoformatRules()],
+			plugins: listAutoformatPlugins(),
 			commands: {
 				toggleBulletList: () => toggleBulletList,
 				toggleNumberedList: () => toggleNumberedList,
 				increaseListLevel: () => increaseListLevel,
 				decreaseListLevel: () => decreaseListLevel,
-				removeList: () => removeList
+				removeList: () => removeList,
+				restartNumbering: () => restartNumbering,
+				continueNumbering: () => continueNumbering,
+				setNumberingValue: (value) => setNumberingValue(value)
 			},
 			keyboardShortcuts: {
 				Tab: chainCommands(goToNextCell(), increaseListIndent(), insertTab()),

package/dist/prosemirror/extensions/features/ParaIdAllocatorExtension.d.ts

@@ -1,6 +1,6 @@
 import { Extension } from "../types.js";
-import { EditorState, PluginKey, Transaction } from "prosemirror-state";
 import { Node } from "prosemirror-model";
+import { EditorState, PluginKey, Transaction } from "prosemirror-state";
 //#region src/prosemirror/extensions/features/ParaIdAllocatorExtension.d.ts
 type ParagraphPropertySourceSeed = {
   contract: string | null;
@@ -20,6 +20,23 @@ declare const paraIdAllocatorKey: PluginKey<ParagraphPropertySourceSeed>;
 declare const deterministicParaIdSeedKey: PluginKey<string>;
 /** Ask the allocator to mint reproducible ids for the paragraphs `tr` creates. */
 declare const requestDeterministicParaIds: (tr: Transaction, seed: string) => Transaction;
+type ParagraphPropertySourceKeeper = {
+  status: "ambiguous";
+} | {
+  pos: number;
+  status: "deleted" | "mapped";
+};
+type MappedParagraphKeepers = {
+  paraIds: Map<string, number>;
+  sourceTokens: Map<string, ParagraphPropertySourceKeeper>;
+};
+/**
+ * Where each id's and each seeded source token's owner went: the first
+ * occurrence that survives the batch keeps an id.
+ *
+ * @internal Exported for the per-step equivalence test.
+ */
+declare const mapParagraphKeepers: (oldDoc: Node, transactions: readonly Transaction[], sourceSeed: ParagraphPropertySourceSeed) => MappedParagraphKeepers;
 /**
  * Allocate initial paragraph IDs before constructing editor state.
  *
@@ -31,4 +48,4 @@ declare const ensureParaIdsInDoc: (doc: Node) => Node;
 declare const ensureParaIdsInState: (state: EditorState) => EditorState;
 declare const ParaIdAllocatorExtension: (options?: Partial<{}> | undefined) => Extension;
 //#endregion
-export { ParaIdAllocatorExtension, deterministicParaIdSeedKey, ensureParaIdsInDoc, ensureParaIdsInState, paraIdAllocatorKey, requestDeterministicParaIds };
+export { ParaIdAllocatorExtension, deterministicParaIdSeedKey, ensureParaIdsInDoc, ensureParaIdsInState, mapParagraphKeepers, paraIdAllocatorKey, requestDeterministicParaIds };

package/dist/prosemirror/extensions/features/ParaIdAllocatorExtension.js

@@ -1,5 +1,6 @@
 import { PROSE_PARAGRAPH_SOURCE_TOKEN_ATTR, getExplicitParagraphPropertySourceTransfers, getProseDocumentParagraphPropertySourceContract, getProseParagraphPropertySourceToken, paragraphPropertySourceTokenMatchesContract, recreateProseNodeWithParagraphPropertySource, setProseParagraphMarkupWithPropertySource, transferProseParagraphPropertySource } from "../../../docx/paragraphPropertySource.js";
 import { deterministicHexId, generateHexId } from "../../../utils/hexId.js";
+import { sweepPositions } from "../../positionSweep.js";
 import { createExtension } from "../create.js";
 import { ignoreTrackedChanges } from "./ParagraphChangeTrackerExtension.js";
 import { panic } from "better-result";
@@ -92,33 +93,45 @@ const collectParagraphPropertySourceSeed = (doc) => {
 		tokens: new Set([...counts].filter(([, count]) => count === 1).map(([token]) => token))
 	};
 };
+/**
+* Where each id's and each seeded source token's owner went: the first
+* occurrence that survives the batch keeps an id.
+*
+* @internal Exported for the per-step equivalence test.
+*/
 const mapParagraphKeepers = (oldDoc, transactions, sourceSeed) => {
-	const paraIds = /* @__PURE__ */ new Map();
-	const sourceTokens = /* @__PURE__ */ new Map();
+	const paragraphs = [];
 	oldDoc.descendants((node, pos) => {
 		if (node.type.name !== "paragraph") return true;
 		const id = node.attrs["paraId"];
 		const token = getProseParagraphPropertySourceToken(node);
-		const mapsParaId = isUsableParaId(id) && !paraIds.has(id);
-		const mapsSourceToken = typeof token === "string" && sourceSeed.tokens.has(token);
-		if (!mapsParaId && !mapsSourceToken) return false;
-		let mapped = pos;
-		let mappedInterior = pos + 1;
-		let deleted = false;
-		for (const transaction of transactions) {
-			const ownerResult = transaction.mapping.mapResult(mapped);
-			const interiorResult = transaction.mapping.mapResult(mappedInterior, -1);
-			deleted ||= interiorResult.deletedAcross;
-			mapped = ownerResult.pos;
-			mappedInterior = interiorResult.pos;
-		}
-		if (mapsParaId && !deleted) paraIds.set(id, mapped);
-		if (mapsSourceToken) sourceTokens.set(token, sourceTokens.has(token) ? { status: "ambiguous" } : {
-			pos: mapped,
-			status: deleted ? "deleted" : "mapped"
+		if (isUsableParaId(id) || typeof token === "string" && sourceSeed.tokens.has(token)) paragraphs.push({
+			pos,
+			id,
+			token
 		});
 		return false;
 	});
+	const swept = sweepPositions(transactions.map((transaction) => transaction.mapping), paragraphs.flatMap(({ pos }) => [{
+		pos,
+		assoc: 1,
+		from: 0
+	}, {
+		pos: pos + 1,
+		assoc: -1,
+		from: 0
+	}]));
+	const paraIds = /* @__PURE__ */ new Map();
+	const sourceTokens = /* @__PURE__ */ new Map();
+	for (const [index, { id, token }] of paragraphs.entries()) {
+		const mapped = swept[2 * index].pos;
+		const deleted = swept[2 * index + 1].deletedAcross;
+		if (isUsableParaId(id) && !paraIds.has(id) && !deleted) paraIds.set(id, mapped);
+		if (typeof token === "string" && sourceSeed.tokens.has(token)) sourceTokens.set(token, sourceTokens.has(token) ? { status: "ambiguous" } : {
+			pos: mapped,
+			status: deleted ? "deleted" : "mapped"
+		});
+	}
 	return {
 		paraIds,
 		sourceTokens
@@ -334,4 +347,4 @@ const ParaIdAllocatorExtension = createExtension({
 	}
 });
 //#endregion
-export { ParaIdAllocatorExtension, deterministicParaIdSeedKey, ensureParaIdsInDoc, ensureParaIdsInState, paraIdAllocatorKey, requestDeterministicParaIds };
+export { ParaIdAllocatorExtension, deterministicParaIdSeedKey, ensureParaIdsInDoc, ensureParaIdsInState, mapParagraphKeepers, paraIdAllocatorKey, requestDeterministicParaIds };

package/dist/prosemirror/extensions/features/ParagraphChangeTrackerExtension.d.ts

@@ -1,7 +1,8 @@
+import { document_d_exports } from "../../../types/document.js";
 import { Extension } from "../types.js";
 import { RemovedSectionReference, TrackedSectionEndpointRemoval } from "../../../internal/sectionEndpointResolution.js";
-import { EditorState, PluginKey, Transaction } from "prosemirror-state";
 import { Node } from "prosemirror-model";
+import { EditorState, PluginKey, Transaction } from "prosemirror-state";
 //#region src/prosemirror/extensions/features/ParagraphChangeTrackerExtension.d.ts
 declare const paragraphChangeTrackerKey: PluginKey<InternalParagraphChangeTrackerState>;
 type ParagraphChangeTrackerState = {
@@ -26,6 +27,8 @@ type InternalParagraphChangeTrackerState = ParagraphChangeTrackerState & {
   /** Editing an already unidentified source paragraph cannot become selective. */
   hasUntrackedSourceChanges: boolean;
   blockStructureFingerprint: string;
+  /** The section records themselves, by identity. */
+  sectionRecords: ReadonlySet<document_d_exports.SectionProperties>;
 };
 /**
  * Get the change tracker state from an EditorState
@@ -45,6 +48,24 @@ declare function hasStructuralChanges(state: EditorState): boolean;
 declare function hasUntrackedChanges(state: EditorState): boolean;
 /** Exact section-count transition authorized by tracked paragraph-mark resolution. */
 declare function getTrackedSectionEndpointRemoval(state: EditorState): TrackedSectionEndpointRemoval | null;
+type RepackWithEditorSectionRemovalsOptions<T> = {
+  /** The editor state the document was built from. */
+  state: EditorState;
+  /** The exact document object `repack` hands to `repackDocx`. */
+  document: document_d_exports.Document;
+  repack: () => Promise<T>;
+};
+/**
+ * Run an editor save's full repack with the section removals the editor's own
+ * edits made.
+ *
+ * A save refuses a package with fewer sections than its source unless it is
+ * told which removals were meant: deleting the paragraph that ends a section,
+ * or accepting its tracked deletion, removes that section on purpose. The
+ * tracker records exactly those removals; without them the repack throws and
+ * the edit cannot be saved.
+ */
+declare const repackWithEditorSectionRemovals: <T>({ state, document, repack }: RepackWithEditorSectionRemovalsOptions<T>) => Promise<T>;
 type MarkTrackedSectionEndpointRemovalOptions = {
   sourceDoc: Node;
   removedEndpointCount: number;
@@ -52,6 +73,13 @@ type MarkTrackedSectionEndpointRemovalOptions = {
 };
 /** Record only a complete, internally consistent endpoint-removal transition. */
 declare function markTrackedSectionEndpointRemoval(tr: Transaction, { sourceDoc, removedEndpointCount, removedReferences }: MarkTrackedSectionEndpointRemovalOptions): Transaction;
+/**
+ * Record that `tr` removed section breaks on purpose: a command whose job is
+ * to remove the break (not to delete its paragraph mark, which the tracker
+ * reads for itself). Only a plain removal is recorded; a transaction that also
+ * adds or replaces a record is left as it is.
+ */
+declare function markSectionBreakRemoval(tr: Transaction, sourceDoc: Node): Transaction;
 /**
  * Create a transaction that clears the change tracker
  */
@@ -64,9 +92,10 @@ type MarkChangedParagraphRangesOptions = {
     to: number;
   }[];
   mappingFrom: number;
+  replacesStepMapAt?: number;
 };
 /** Record mark-only paragraph changes whose replacement step has a granular map. */
 declare function markChangedParagraphRanges(tr: Transaction, batch: MarkChangedParagraphRangesOptions): Transaction;
 declare const ParagraphChangeTrackerExtension: (options?: Partial<{}> | undefined) => Extension;
 //#endregion
-export { ParagraphChangeTrackerExtension, ParagraphChangeTrackerState, clearTrackedChanges, getChangeTrackerState, getChangedParagraphIds, getTrackedSectionEndpointRemoval, hasStructuralChanges, hasUntrackedChanges, ignoreTrackedChanges, markChangedParagraphRanges, markStructuralChange, markTrackedSectionEndpointRemoval, paragraphChangeTrackerKey };
+export { ParagraphChangeTrackerExtension, ParagraphChangeTrackerState, clearTrackedChanges, getChangeTrackerState, getChangedParagraphIds, getTrackedSectionEndpointRemoval, hasStructuralChanges, hasUntrackedChanges, ignoreTrackedChanges, markChangedParagraphRanges, markSectionBreakRemoval, markStructuralChange, markTrackedSectionEndpointRemoval, paragraphChangeTrackerKey, repackWithEditorSectionRemovals };