@stll/folio-core 0.54.1 → 0.55.0

package/dist/prosemirror/extensions/core/HistoryExtension.js

@@ -1,5 +1,97 @@
 import { createExtension } from "../create.js";
-import { history, redo, undo } from "prosemirror-history";
+import { Plugin } from "prosemirror-state";
+import { closeHistory, history, isHistoryTransaction, redo, undo } from "prosemirror-history";
+//#region src/prosemirror/extensions/core/HistoryExtension.ts
+/**
+* History Extension — undo/redo via prosemirror-history
+*/
+/**
+* History adjacency is based on step maps, which differ for physical deletions
+* and suggestion marks. Group continuous typing and same-direction deletions explicitly; each
+* structural edit, paste, drop, or composition starts its own undo event.
+* Capture DOM input before the shared input router or a keymap handles it.
+*/
+const inputBoundaryPlugin = (newGroupDelay) => {
+	let previousKind;
+	let deletionGroup = 0;
+	let previousInputTime = 0;
+	let pendingDeletionGroup = null;
+	return new Plugin({
+		filterTransaction(tr) {
+			const pendingGroup = pendingDeletionGroup;
+			pendingDeletionGroup = null;
+			if (isHistoryTransaction(tr) || !tr.docChanged && tr.selectionSet) {
+				previousKind = void 0;
+				return true;
+			}
+			if (tr.docChanged && (previousKind === "deleteBackward" || previousKind === "deleteForward" || previousKind === "deletion")) {
+				if (pendingGroup !== null) tr.setMeta("composition", pendingGroup);
+				else if (!tr.getMeta("appendedTransaction")) previousKind = void 0;
+			}
+			return true;
+		},
+		view(view) {
+			const startInput = (kind) => {
+				const now = Date.now();
+				if (kind !== previousKind || kind === "structure" || kind === "paste" || kind === "drop" || now - previousInputTime > newGroupDelay) {
+					deletionGroup--;
+					view.dispatch(closeHistory(view.state.tr));
+				}
+				previousInputTime = now;
+				previousKind = kind;
+				pendingDeletionGroup = kind === "deleteBackward" || kind === "deleteForward" || kind === "deletion" ? deletionGroup : null;
+			};
+			const keydown = (event) => {
+				if (event.isComposing) return;
+				if (event.key === "Backspace" || event.key === "Delete") {
+					startInput(event.key === "Backspace" ? "deleteBackward" : "deleteForward");
+					return;
+				}
+				if (event.key === "Enter") {
+					startInput("structure");
+					return;
+				}
+				if (event.key.length === 1 && !event.metaKey && !event.ctrlKey) startInput("typing");
+			};
+			const beforeinput = (event) => {
+				if (event.inputType === "insertCompositionText" || event.isComposing) {
+					startInput("composition");
+					return;
+				}
+				if (event.inputType === "insertText" || event.inputType === "insertReplacementText") {
+					startInput("typing");
+					return;
+				}
+				if (event.inputType.startsWith("delete")) if (event.inputType.endsWith("Backward")) startInput("deleteBackward");
+				else if (event.inputType.endsWith("Forward")) startInput("deleteForward");
+				else startInput("deletion");
+				else if (event.inputType === "insertParagraph" || event.inputType === "insertLineBreak") startInput("structure");
+			};
+			const paste = () => startInput("paste");
+			const drop = () => startInput("drop");
+			const compositionstart = () => {
+				view.dispatch(closeHistory(view.state.tr));
+				previousKind = "composition";
+			};
+			view.dom.addEventListener("keydown", keydown, true);
+			view.dom.addEventListener("beforeinput", beforeinput, true);
+			view.dom.addEventListener("paste", paste, true);
+			view.dom.addEventListener("drop", drop, true);
+			view.dom.addEventListener("compositionstart", compositionstart, true);
+			return { destroy() {
+				view.dom.removeEventListener("keydown", keydown, true);
+				view.dom.removeEventListener("beforeinput", beforeinput, true);
+				view.dom.removeEventListener("paste", paste, true);
+				view.dom.removeEventListener("drop", drop, true);
+				view.dom.removeEventListener("compositionstart", compositionstart, true);
+			} };
+		}
+	});
+};
+const consumeHistoryShortcut = (command) => (state, dispatch, view) => {
+	command(state, dispatch, view);
+	return true;
+};
 const HistoryExtension = createExtension({
 	name: "history",
 	defaultOptions: {
@@ -12,15 +104,15 @@ const HistoryExtension = createExtension({
 			plugins: [history({
 				depth: options.depth,
 				newGroupDelay: options.newGroupDelay
-			})],
+			}), inputBoundaryPlugin(options.newGroupDelay)],
 			commands: {
 				undo: () => undo,
 				redo: () => redo
 			},
 			...options.shortcuts === "editor" && { keyboardShortcuts: {
-				"Mod-z": undo,
-				"Mod-y": redo,
-				"Mod-Shift-z": redo
+				"Mod-z": consumeHistoryShortcut(undo),
+				"Mod-y": consumeHistoryShortcut(redo),
+				"Mod-Shift-z": consumeHistoryShortcut(redo)
 			} }
 		};
 	}

package/dist/prosemirror/extensions/core/ParagraphExtension.js

@@ -1,3 +1,4 @@
+import { mintBookmarkId, reserveProseBookmarkIds } from "../../../docx/bookmarkIds.js";
 import { BUILT_IN_STYLE_NAME } from "../../../docx/builtInStyles.js";
 import { PROSE_PARAGRAPH_SOURCE_TOKEN_ATTR } from "../../../docx/paragraphPropertySource.js";
 import { isStyleSourcedParagraphNumbering } from "../../../internal/paragraphFormattingSerialization.js";
@@ -7,6 +8,7 @@ import { collectHeadings } from "../../../utils/headingCollector.js";
 import { tableOfContentsStyleLevel } from "../../../utils/tableOfContentsStyle.js";
 import { expectParagraphAttrs } from "../../attrs/index.js";
 import { autospacingMatchesBase } from "../../autospacingBase.js";
+import { withCanonicalParagraphFormatting } from "../../canonicalCommands.js";
 import { removeSectionBreakAtSelection, setSectionBreakType } from "../../commands/sectionBreak.js";
 import { CLEARED_LIST_RENDERING_ATTRS } from "../../listMarker.js";
 import { directParagraphAlignment } from "../../paragraphAlignment.js";
@@ -231,6 +233,7 @@ const paragraphNodeSpec = {
 		listMarkerSuffix: { default: null },
 		listMarkerAllCaps: { default: null },
 		listImplicitChildLevelAdvances: { default: null },
+		listFoldedMarkerSuffix: { default: void 0 },
 		listMarkerSecondSlotOffsetTwips: { default: null },
 		listLevelNumFmts: { default: null },
 		listLevelStarts: { default: null },
@@ -630,27 +633,56 @@ const ParagraphExtension = createNodeExtension({
 	onSchemaReady() {
 		const applyStyleFn = makeApplyStyle();
 		return { commands: {
-			setAlignment: (alignment) => makeSetAlignment(alignment),
-			alignLeft: () => makeSetAlignment("left"),
-			alignCenter: () => makeSetAlignment("center"),
-			alignRight: () => makeSetAlignment("right"),
-			alignJustify: () => makeSetAlignment("both"),
-			setLineSpacing: (value, rule) => makeSetLineSpacing(value, rule),
-			singleSpacing: () => makeSetLineSpacing(240),
-			oneAndHalfSpacing: () => makeSetLineSpacing(360),
-			doubleSpacing: () => makeSetLineSpacing(480),
-			setSpaceBefore: (twips) => setParagraphSpacingAttr("before", twips),
-			setSpaceAfter: (twips) => setParagraphSpacingAttr("after", twips),
-			increaseIndent: (amount) => makeIncreaseIndent(amount),
-			decreaseIndent: (amount) => makeDecreaseIndent(amount),
-			setIndentLeft: (twips) => setParagraphAttr("indentLeft", twips > 0 ? twips : null),
-			setIndentRight: (twips) => setParagraphAttr("indentRight", twips > 0 ? twips : null),
-			setIndentFirstLine: (twips, hanging) => setParagraphAttrsCmd({
+			setAlignment: (alignment) => withCanonicalParagraphFormatting(makeSetAlignment(alignment), { alignment }),
+			alignLeft: () => withCanonicalParagraphFormatting(makeSetAlignment("left"), { alignment: "left" }),
+			alignCenter: () => withCanonicalParagraphFormatting(makeSetAlignment("center"), { alignment: "center" }),
+			alignRight: () => withCanonicalParagraphFormatting(makeSetAlignment("right"), { alignment: "right" }),
+			alignJustify: () => withCanonicalParagraphFormatting(makeSetAlignment("both"), { alignment: "both" }),
+			setLineSpacing: (value, rule) => withCanonicalParagraphFormatting(makeSetLineSpacing(value, rule), {
+				lineSpacing: value,
+				lineSpacingRule: rule ?? "auto"
+			}),
+			singleSpacing: () => withCanonicalParagraphFormatting(makeSetLineSpacing(240), {
+				lineSpacing: 240,
+				lineSpacingRule: "auto"
+			}),
+			oneAndHalfSpacing: () => withCanonicalParagraphFormatting(makeSetLineSpacing(360), {
+				lineSpacing: 360,
+				lineSpacingRule: "auto"
+			}),
+			doubleSpacing: () => withCanonicalParagraphFormatting(makeSetLineSpacing(480), {
+				lineSpacing: 480,
+				lineSpacingRule: "auto"
+			}),
+			setSpaceBefore: (twips) => withCanonicalParagraphFormatting(setParagraphSpacingAttr("before", twips), { spaceBefore: twips }),
+			setSpaceAfter: (twips) => withCanonicalParagraphFormatting(setParagraphSpacingAttr("after", twips), { spaceAfter: twips }),
+			increaseIndent: (amount) => withCanonicalParagraphFormatting(makeIncreaseIndent(amount), (node) => ({ indentLeft: (expectParagraphAttrs(node).indentLeft ?? 0) + (amount ?? 720) })),
+			decreaseIndent: (amount) => withCanonicalParagraphFormatting(makeDecreaseIndent(amount), (node) => {
+				const attrs = expectParagraphAttrs(node);
+				const indentLeft = Math.max(0, (attrs.indentLeft ?? 0) - (amount ?? 720));
+				return { indentLeft: indentLeft > 0 || paragraphNumberingReferenceId(attrs.numPr ?? void 0) !== void 0 ? indentLeft : null };
+			}),
+			setIndentLeft: (twips) => withCanonicalParagraphFormatting(setParagraphAttr("indentLeft", twips > 0 ? twips : null), { indentLeft: twips > 0 ? twips : null }),
+			setIndentRight: (twips) => withCanonicalParagraphFormatting(setParagraphAttr("indentRight", twips > 0 ? twips : null), { indentRight: twips > 0 ? twips : null }),
+			setIndentFirstLine: (twips, hanging) => withCanonicalParagraphFormatting(setParagraphAttrsCmd({
+				indentFirstLine: twips > 0 ? twips : null,
+				hangingIndent: hanging ?? false
+			}), {
 				indentFirstLine: twips > 0 ? twips : null,
 				hangingIndent: hanging ?? false
 			}),
-			applyStyle: (styleId, resolvedAttrs) => applyStyleFn(styleId, resolvedAttrs),
-			clearStyle: () => (state, dispatch) => {
+			applyStyle: (styleId, resolvedAttrs) => withCanonicalParagraphFormatting(applyStyleFn(styleId, resolvedAttrs), {
+				styleId,
+				...resolvedAttrs ? {
+					alignment: null,
+					outlineLevel: null,
+					spaceBefore: null,
+					spaceAfter: null,
+					lineSpacing: null,
+					lineSpacingRule: null
+				} : {}
+			}),
+			clearStyle: () => withCanonicalParagraphFormatting((state, dispatch) => {
 				const resolver = getDocumentStyleResolver(state);
 				if (!resolver) return applyStyleFn(null)(state, dispatch);
 				const resolved = resolver.resolveParagraphStyle(null);
@@ -661,7 +693,7 @@ const ParagraphExtension = createNodeExtension({
 					...styleName && { styleName },
 					numbering: getDocumentNumbering(state)
 				})(state, dispatch);
-			},
+			}, { styleId: null }),
 			insertSectionBreak: (breakType) => setSectionBreakType(breakType),
 			removeSectionBreak: () => removeSectionBreakAtSelection,
 			generateTOC: ({ title }) => (state, dispatch) => {
@@ -671,6 +703,7 @@ const ParagraphExtension = createNodeExtension({
 				if (!dispatch) return true;
 				const { schema: s } = state;
 				const tr = state.tr;
+				reserveProseBookmarkIds(state.doc);
 				const bookmarkEntries = [];
 				for (const h of headings) {
 					const bookmarkName = `_Toc${Math.floor(1e8 + Math.random() * 9e8)}`;
@@ -683,7 +716,7 @@ const ParagraphExtension = createNodeExtension({
 					const paragraphNode = tr.doc.resolve(mappedPos).nodeAfter;
 					if (paragraphNode && paragraphNode.type.name === "paragraph") {
 						const newBookmarks = [...(paragraphNode.attrs["bookmarks"] ?? []).filter((b) => !b.name.startsWith("_Toc")), {
-							id: Math.floor(Math.random() * 2147483647),
+							id: mintBookmarkId(),
 							name: bookmarkName
 						}];
 						tr.setNodeMarkup(mappedPos, void 0, {

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

@@ -1,5 +1,6 @@
 import { mergeTextFormatting } from "../../../utils/textFormattingMerge.js";
 import { expectCharacterStyleMarkAttrs, expectRunFormattingOverrideMarkAttrs } from "../../attrs/index.js";
+import { clearIndentOnBackspace } from "../../commands/clearParagraphIndent.js";
 import { keepSectionBreaksOnSurvivingMarks } from "../../commands/sectionBreak.js";
 import { getDocumentStyleResolver } from "../../plugins/documentStyleState.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../../runFormattingMarkNames.js";
@@ -8,6 +9,7 @@ import { paragraphAttrsFromResolvedStyle } from "../../styles/resolvedStyleAttrs
 import { createExtension } from "../create.js";
 import { marksToTextFormatting, textFormattingToMarks } from "../marks/markUtils.js";
 import { Priority } from "../types.js";
+import { EditorState, TextSelection } from "prosemirror-state";
 import { baseKeymap, deleteSelection, joinBackward, joinForward, selectAll, selectParentNode, splitBlock } from "prosemirror-commands";
 //#region src/prosemirror/extensions/features/BaseKeymapExtension.ts
 /**
@@ -22,31 +24,6 @@ function chainCommands(...commands) {
 	};
 }
 /**
-* Backspace at the start of a paragraph clears first-line indent / hanging indent
-* before joining with the previous paragraph (matches Word behavior).
-*/
-const clearIndentOnBackspace = (state, dispatch) => {
-	const { $cursor } = state.selection;
-	if (!$cursor) return false;
-	if ($cursor.parentOffset !== 0) return false;
-	if ($cursor.parent.type.name !== "paragraph") return false;
-	const attrs = $cursor.parent.attrs;
-	const hasFirstLine = attrs["indentFirstLine"] !== null && attrs["indentFirstLine"] > 0;
-	const hasHanging = !!attrs["hangingIndent"];
-	const hasIndentLeft = attrs["indentLeft"] !== null && attrs["indentLeft"] > 0;
-	if (!hasFirstLine && !hasHanging && !hasIndentLeft) return false;
-	if (dispatch) {
-		const pos = $cursor.before();
-		dispatch(state.tr.setNodeMarkup(pos, void 0, {
-			...attrs,
-			indentFirstLine: null,
-			hangingIndent: null,
-			indentLeft: null
-		}).scrollIntoView());
-	}
-	return true;
-};
-/**
 * Custom Enter handler: splits the block, inherits style-related attrs,
 * clears paragraph borders, and preserves run formatting on the new paragraph.
 *
@@ -117,16 +94,33 @@ function applyNextParagraphStyle(tr, sourcePara, newPara, resolver) {
 	tr.setStoredMarks(resolved.runFormatting ? textFormattingToMarks(resolved.runFormatting, tr.doc.type.schema) : []);
 	return true;
 }
+const blockBoundaryDeletion = (state) => {
+	if (!(state.selection instanceof TextSelection) || state.selection.empty) return null;
+	const tr = state.tr.deleteSelection();
+	return tr.doc.resolve(tr.mapping.map(state.selection.from)).parent.isTextblock ? null : tr;
+};
 const splitBlockClearBorders = (state, dispatch, view) => {
-	const { $from: preSplitFrom } = state.selection;
+	const deletion = blockBoundaryDeletion(state);
+	const splitState = deletion ? EditorState.create({
+		doc: deletion.doc,
+		selection: deletion.selection,
+		storedMarks: deletion.storedMarks
+	}) : state;
+	const { $from: preSplitFrom } = splitState.selection;
 	const sourcePara = preSplitFrom.parent.type.name === "paragraph" ? preSplitFrom.parent : null;
-	const caretFormattingMarks = (state.storedMarks || preSplitFrom.marks()).filter((mark) => RUN_FORMATTING_MARK_NAMES.has(mark.type.name));
+	const caretFormattingMarks = (splitState.storedMarks || preSplitFrom.marks()).filter((mark) => RUN_FORMATTING_MARK_NAMES.has(mark.type.name));
 	const resolver = getDocumentStyleResolver(state);
 	const splitResult = { tr: null };
-	if (!splitBlock(state, dispatch ? (tr) => {
+	if (!splitBlock(splitState, dispatch ? (tr) => {
 		splitResult.tr = tr;
 	} : void 0, view)) return false;
 	if (dispatch && splitResult.tr !== null) {
+		if (deletion) {
+			for (const step of splitResult.tr.steps) deletion.step(step);
+			deletion.setSelection(splitResult.tr.selection.getBookmark().resolve(deletion.doc));
+			deletion.setStoredMarks(splitResult.tr.storedMarks);
+			splitResult.tr = deletion;
+		}
 		const tr = splitResult.tr;
 		const { $from } = tr.selection;
 		const newPara = $from.parent;

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

@@ -1,5 +1,6 @@
 import { paragraphNumberingLevel, paragraphNumberingReferenceId } from "../../../docx/numberingReference.js";
 import { expectParagraphAttrs } from "../../attrs/index.js";
+import { withCanonicalCommand } from "../../canonicalCommands.js";
 import { LIST_MARKER_PATTERN, listRequestsForMarker } from "../../listAutoformatMarkers.js";
 import { CLEARED_LIST_RENDERING_ATTRS } from "../../listMarker.js";
 import { applyParagraphUpdates, continueNumbering, listItemAttrs, resolveListTarget, restartNumbering, setNumberingValue } from "../../listNumbering.js";
@@ -107,8 +108,14 @@ function toggleList(intent) {
 		return true;
 	};
 }
-const toggleBulletList = (state, dispatch) => toggleList("bullet")(state, dispatch);
-const toggleNumberedList = (state, dispatch) => toggleList("numbered")(state, dispatch);
+const toggleBulletList = withCanonicalCommand((state, dispatch) => toggleList("bullet")(state, dispatch), () => [{
+	type: "toggleList",
+	kind: "bullet"
+}]);
+const toggleNumberedList = withCanonicalCommand((state, dispatch) => toggleList("numbered")(state, dispatch), () => [{
+	type: "toggleList",
+	kind: "decimal"
+}]);
 const attrsForListLevel = (state, attrs, level) => {
 	if (!hasActiveListNumbering(attrs)) panic("Cannot change the level of a list without a numbering id");
 	return {
@@ -394,9 +401,15 @@ const ListExtension = createExtension({
 			commands: {
 				toggleBulletList: () => toggleBulletList,
 				toggleNumberedList: () => toggleNumberedList,
-				increaseListLevel: () => increaseListLevel,
-				decreaseListLevel: () => decreaseListLevel,
-				removeList: () => removeList,
+				increaseListLevel: () => withCanonicalCommand(increaseListLevel, () => [{
+					type: "changeListLevel",
+					direction: "increase"
+				}]),
+				decreaseListLevel: () => withCanonicalCommand(decreaseListLevel, () => [{
+					type: "changeListLevel",
+					direction: "decrease"
+				}]),
+				removeList: () => withCanonicalCommand(removeList, () => [{ type: "removeList" }]),
 				restartNumbering: () => restartNumbering,
 				continueNumbering: () => continueNumbering,
 				setNumberingValue: (value) => setNumberingValue(value)

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

@@ -2,7 +2,7 @@ import { document_d_exports } from "../../../types/document.js";
 import { Extension } from "../types.js";
 import { RemovedSectionReference, TrackedSectionEndpointRemoval } from "../../../internal/sectionEndpointResolution.js";
 import { Node } from "prosemirror-model";
-import { EditorState, PluginKey, Transaction } from "prosemirror-state";
+import { EditorState, Plugin, PluginKey, Transaction } from "prosemirror-state";
 //#region src/prosemirror/extensions/features/ParagraphChangeTrackerExtension.d.ts
 declare const paragraphChangeTrackerKey: PluginKey<InternalParagraphChangeTrackerState>;
 type ParagraphChangeTrackerState = {
@@ -30,6 +30,7 @@ type InternalParagraphChangeTrackerState = ParagraphChangeTrackerState & {
   /** The section records themselves, by identity. */
   sectionRecords: ReadonlySet<document_d_exports.SectionProperties>;
 };
+declare function createParagraphChangeTrackerPlugin(): Plugin<InternalParagraphChangeTrackerState>;
 /**
  * Get the change tracker state from an EditorState
  */
@@ -85,6 +86,8 @@ declare function markSectionBreakRemoval(tr: Transaction, sourceDoc: Node): Tran
  */
 declare function clearTrackedChanges(state: EditorState): Transaction;
 declare function ignoreTrackedChanges(tr: Transaction): Transaction;
+/** A committed package-story/property edit requires the full package serializer. */
+declare const markPackageChange: (tr: Transaction) => Transaction;
 declare function markStructuralChange(tr: Transaction): Transaction;
 type MarkChangedParagraphRangesOptions = {
   ranges: readonly {
@@ -98,4 +101,4 @@ type MarkChangedParagraphRangesOptions = {
 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, markSectionBreakRemoval, markStructuralChange, markTrackedSectionEndpointRemoval, paragraphChangeTrackerKey, repackWithEditorSectionRemovals };
+export { ParagraphChangeTrackerExtension, ParagraphChangeTrackerState, clearTrackedChanges, createParagraphChangeTrackerPlugin, getChangeTrackerState, getChangedParagraphIds, getTrackedSectionEndpointRemoval, hasStructuralChanges, hasUntrackedChanges, ignoreTrackedChanges, markChangedParagraphRanges, markPackageChange, markSectionBreakRemoval, markStructuralChange, markTrackedSectionEndpointRemoval, paragraphChangeTrackerKey, repackWithEditorSectionRemovals };

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

@@ -13,6 +13,7 @@ const paragraphChangeTrackerKey = new PluginKey("paragraphChangeTracker");
 const CLEAR_META = "clear";
 const IGNORE_META = "ignore";
 const STRUCTURAL_META = "structural";
+const PACKAGE_CHANGE_META = "package-change";
 const CHANGED_PARAGRAPH_RANGES_META = "folioChangedParagraphRanges";
 const SECTION_ENDPOINT_REMOVAL_META = "folioSectionEndpointRemoval";
 const SECTION_EDIT_META = "folioSectionEdit";
@@ -258,6 +259,11 @@ function createParagraphChangeTrackerPlugin() {
 						sectionRecords: counts.sectionRecords
 					};
 				}
+				if (meta === PACKAGE_CHANGE_META && !tr.docChanged) return {
+					...prevState,
+					hasUntrackedSourceChanges: true,
+					hasUntrackedChanges: true
+				};
 				if (!tr.docChanged) return isSectionEditMeta(sectionEditMeta) && sectionEditMeta.expectedEndpointFingerprint === prevState.sectionEndpointFingerprint ? {
 					...prevState,
 					sectionEndpointRemoval: sectionEditMeta.authorization
@@ -326,6 +332,10 @@ function createParagraphChangeTrackerPlugin() {
 						newState.hasUntrackedChanges = true;
 					}
 				}
+				if (meta === PACKAGE_CHANGE_META) {
+					newState.hasUntrackedSourceChanges = true;
+					newState.hasUntrackedChanges = true;
+				}
 				return newState;
 			}
 		},
@@ -503,6 +513,8 @@ function clearTrackedChanges(state) {
 function ignoreTrackedChanges(tr) {
 	return tr.setMeta(paragraphChangeTrackerKey, IGNORE_META);
 }
+/** A committed package-story/property edit requires the full package serializer. */
+const markPackageChange = (tr) => tr.setMeta(paragraphChangeTrackerKey, PACKAGE_CHANGE_META);
 function markStructuralChange(tr) {
 	return tr.setMeta(paragraphChangeTrackerKey, STRUCTURAL_META);
 }
@@ -523,4 +535,4 @@ const ParagraphChangeTrackerExtension = createExtension({
 	}
 });
 //#endregion
-export { ParagraphChangeTrackerExtension, clearTrackedChanges, getChangeTrackerState, getChangedParagraphIds, getTrackedSectionEndpointRemoval, hasStructuralChanges, hasUntrackedChanges, ignoreTrackedChanges, markChangedParagraphRanges, markSectionBreakRemoval, markStructuralChange, markTrackedSectionEndpointRemoval, paragraphChangeTrackerKey, repackWithEditorSectionRemovals };
+export { ParagraphChangeTrackerExtension, clearTrackedChanges, createParagraphChangeTrackerPlugin, getChangeTrackerState, getChangedParagraphIds, getTrackedSectionEndpointRemoval, hasStructuralChanges, hasUntrackedChanges, ignoreTrackedChanges, markChangedParagraphRanges, markPackageChange, markSectionBreakRemoval, markStructuralChange, markTrackedSectionEndpointRemoval, paragraphChangeTrackerKey, repackWithEditorSectionRemovals };

package/dist/prosemirror/extensions/marks/TextColorExtension.js

@@ -1,5 +1,6 @@
 import { textToStyle } from "../../../utils/formatToStyle.js";
 import { expectTextColorMarkAttrs } from "../../attrs/index.js";
+import { canonicalRunFormatting, withCanonicalCommand } from "../../canonicalCommands.js";
 import { clearRunColor } from "../../clearRunColor.js";
 import { createMarkExtension } from "../create.js";
 import { setMark } from "./markUtils.js";
@@ -40,10 +41,10 @@ const TextColorExtension = createMarkExtension({
 		if (!textColorType) panic("Missing mark type: textColor");
 		return { commands: {
 			setTextColor: (attrs) => {
-				if (!attrs.rgb && !attrs.themeColor) return clearRunColor();
+				if (!attrs.rgb && !attrs.themeColor) return withCanonicalCommand(clearRunColor(), (state) => canonicalRunFormatting(state, { color: null }));
 				return setMark(textColorType, attrs);
 			},
-			clearTextColor: () => clearRunColor()
+			clearTextColor: () => withCanonicalCommand(clearRunColor(), (state) => canonicalRunFormatting(state, { color: null }))
 		} };
 	}
 });

package/dist/prosemirror/extensions/marks/TrackedChangeExtensions.js

@@ -58,6 +58,7 @@ const InsertionExtension = createMarkExtension({
 			provenance: { default: "user" },
 			suggestionId: { default: null },
 			_docxOuterWrapperCount: { default: null },
+			_docxResolutionJoins: { default: null },
 			_docxRevisionAncestors: { default: null }
 		},
 		inclusive: false,
@@ -120,6 +121,7 @@ const DeletionExtension = createMarkExtension({
 			suggestionId: { default: null },
 			_historicalFormatting: { default: null },
 			_docxOuterWrapperCount: { default: null },
+			_docxResolutionJoins: { default: null },
 			_docxRevisionAncestors: { default: null }
 		},
 		inclusive: false,

package/dist/prosemirror/extensions/marks/markUtils.js

@@ -2,6 +2,7 @@ import { FONT_THEME_VALUES } from "../../../types/documentEnumValues.js";
 import { mergeFontFamily } from "../../../utils/fontFamilyMerge.js";
 import { normalizeHorizontalScalePercent } from "../../../utils/horizontalScale.js";
 import { expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectEmphasisMarkAttrs, expectFontFamilyMarkAttrs, expectRunFormattingOverrideMarkAttrs, expectRunShadingMarkAttrs, expectStrikeMarkAttrs, expectTextEffectMarkAttrs } from "../../attrs/index.js";
+import { canonicalRunFormatting, withCanonicalCommand } from "../../canonicalCommands.js";
 import { runShadingAttrsToShading, shadingToRunShadingAttrs } from "../../conversion/runShadingMark.js";
 import { documentMarkType } from "../../documentSchema.js";
 import { selectRunFormattingCarrierRepresentations } from "../../runFormattingInlineCarriers.js";
@@ -12,6 +13,12 @@ import { applyRunFormattingOverrideMark, buildRunFormattingOverrideAttrs } from
 import { readThemeColor } from "@stll/docx-core/model";
 import { toggleMark } from "prosemirror-commands";
 //#region src/prosemirror/extensions/marks/markUtils.ts
+/**
+* Shared mark utility functions
+*
+* setMark, removeMark, isMarkActive, getMarkAttr, marksToTextFormatting,
+* textFormattingToMarks, clearFormatting
+*/
 const isFontTheme = (value) => value !== void 0 && FONT_THEME_VALUES.some((theme) => theme === value);
 const fontFamilyAttrsToFormatting = ({ ascii, hAnsi, eastAsia, cs, hint, asciiTheme, hAnsiTheme, eastAsiaTheme, csTheme }) => ({
 	...ascii !== void 0 ? { ascii } : {},
@@ -179,8 +186,23 @@ function createMarkWithMergedAttrs(markType, currentMark, nextAttrs) {
 	if (!markRequiresAttrMerge(markType)) return markType.create(nextAttrs);
 	return markType.create(mergeMarkAttrs(markType, currentMark, nextAttrs));
 }
+const canonicalSetMarkFormatting = ({ state, type, attrs }) => {
+	const markType = documentMarkType(state, type);
+	const { from, to, empty } = state.selection;
+	if (empty) return canonicalRunFormatting(state, marksToTextFormatting([createMarkWithMergedAttrs(markType, markType.isInSet(state.storedMarks ?? state.selection.$from.marks()), attrs)]));
+	return selectRunFormattingCarrierRepresentations({
+		doc: state.doc,
+		from,
+		to
+	}).map((representation) => ({
+		type: "formatRun",
+		from: representation.from,
+		to: representation.to,
+		patch: marksToTextFormatting([createMarkWithMergedAttrs(markType, markType.isInSet(representation.node.marks), attrs)])
+	}));
+};
 function setMark(type, attrs) {
-	return (state, dispatch) => {
+	const command = (state, dispatch) => {
 		const markType = documentMarkType(state, type);
 		const { from, to, empty } = state.selection;
 		if (empty) {
@@ -211,6 +233,12 @@ function setMark(type, attrs) {
 		}
 		return true;
 	};
+	if (!RUN_FORMATTING_MARK_NAMES.has(type.name)) return command;
+	return withCanonicalCommand(command, (state) => canonicalSetMarkFormatting({
+		state,
+		type,
+		attrs
+	}));
 }
 const DIRECT_FONT_PROPERTIES = [
 	"color",
@@ -287,17 +315,42 @@ const withRunFormattingOverride = (command, update) => (state, dispatch) => comm
 	dispatch(updateRunFormattingOverride(state, tr, update));
 } : void 0);
 /** `toggleMark` for the document's own counterpart of `type`. */
-const toggleDocumentMark = (type) => (state, dispatch, view) => toggleMark(documentMarkType(state, type))(state, dispatch, view);
+const toggleDocumentMark = (type) => {
+	const command = (state, dispatch, view) => toggleMark(documentMarkType(state, type))(state, dispatch, view);
+	if (!RUN_FORMATTING_MARK_NAMES.has(type.name)) return command;
+	return withCanonicalCommand(command, (state) => {
+		const markType = documentMarkType(state, type);
+		const formatting = marksToTextFormatting([markType.create()]);
+		if (!isMarkActive(state, markType)) return canonicalRunFormatting(state, formatting);
+		const keys = markType.name === "strike" ? ["strike", "doubleStrike"] : Object.keys(formatting);
+		return canonicalRunFormatting(state, Object.fromEntries(keys.map((key) => [key, null])));
+	});
+};
 /** UI toggle whose direct-formatting contract explicitly targets both script families. */
-const toggleMarkForAllScripts = (type, property) => (state, dispatch) => {
+const toggleMarkForAllScripts = (type, property) => withCanonicalCommand((state, dispatch) => {
 	const markType = documentMarkType(state, type);
 	const enabled = !isMarkActive(state, markType);
 	return withRunFormattingOverride(toggleMark(markType), (attrs) => updatePairedToggleAttrs(attrs, property, enabled))(state, dispatch);
-};
+}, (state) => {
+	const enabled = !isMarkActive(state, documentMarkType(state, type));
+	return canonicalRunFormatting(state, property === "bold" ? {
+		bold: enabled,
+		boldCs: enabled
+	} : {
+		italic: enabled,
+		italicCs: enabled
+	});
+});
 /** UI size command whose direct-formatting contract explicitly targets both script families. */
-const setFontSizeForAllScripts = (markType, size) => withRunFormattingOverride(setMark(markType, { size }), (attrs) => updateFontSizeCompanionAttrs(attrs, size));
+const setFontSizeForAllScripts = (markType, size) => withCanonicalCommand(withRunFormattingOverride(setMark(markType, { size }), (attrs) => updateFontSizeCompanionAttrs(attrs, size)), (state) => canonicalRunFormatting(state, {
+	fontSize: size,
+	fontSizeCs: size
+}));
 /** Clears both ordinary and complex-script direct size through the UI command boundary. */
-const clearFontSizeForAllScripts = (markType) => withRunFormattingOverride(removeMark(markType), (attrs) => updateFontSizeCompanionAttrs(attrs, void 0));
+const clearFontSizeForAllScripts = (markType) => withCanonicalCommand(withRunFormattingOverride(removeMark(markType), (attrs) => updateFontSizeCompanionAttrs(attrs, void 0)), (state) => canonicalRunFormatting(state, {
+	fontSize: null,
+	fontSizeCs: null
+}));
 function selectionHasVisibleUnderline(state, markType) {
 	const { from, to, empty, $from } = state.selection;
 	if (empty) {
@@ -317,10 +370,14 @@ function selectionHasVisibleUnderline(state, markType) {
 	return hasVisibleUnderline;
 }
 function toggleUnderlineMark(markType) {
-	return (state, dispatch) => setMark(markType, { style: selectionHasVisibleUnderline(state, documentMarkType(state, markType)) ? "none" : "single" })(state, dispatch);
+	return withCanonicalCommand((state, dispatch) => setMark(markType, { style: selectionHasVisibleUnderline(state, documentMarkType(state, markType)) ? "none" : "single" })(state, dispatch), (state) => canonicalSetMarkFormatting({
+		state,
+		type: markType,
+		attrs: { style: selectionHasVisibleUnderline(state, documentMarkType(state, markType)) ? "none" : "single" }
+	}));
 }
 function removeMark(type) {
-	return (state, dispatch) => {
+	const command = (state, dispatch) => {
 		const markType = documentMarkType(state, type);
 		const { from, to, empty } = state.selection;
 		if (empty) {
@@ -330,6 +387,11 @@ function removeMark(type) {
 		if (dispatch) dispatch(state.tr.removeMark(from, to, markType).scrollIntoView());
 		return true;
 	};
+	if (!RUN_FORMATTING_MARK_NAMES.has(type.name)) return command;
+	return withCanonicalCommand(command, (state) => {
+		const formatting = marksToTextFormatting([documentMarkType(state, type).create()]);
+		return canonicalRunFormatting(state, Object.fromEntries(Object.keys(formatting).map((key) => [key, null])));
+	});
 }
 /**
 * Check if a mark is active in the current selection

package/dist/prosemirror/extensions/nodes/NoteMarkerExtension.d.ts

@@ -0,0 +1,6 @@
+import { NodeExtension } from "../types.js";
+//#region src/prosemirror/extensions/nodes/NoteMarkerExtension.d.ts
+declare const NOTE_MARKER_NODE_NAME = "noteMarker";
+declare const NoteMarkerExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
+//#endregion
+export { NOTE_MARKER_NODE_NAME, NoteMarkerExtension };