@stll/folio-core 0.56.0 → 0.58.0

package/dist/internal/revisionResolutionInline.js

@@ -3,9 +3,11 @@ import { expectFieldAttrs, expectRunPropertyChangeMarkAttrs, expectTrackedChange
 import { resolutionRemovesControl, withoutResolvedEnclosures } from "../prosemirror/contentControlRevisions.js";
 import { resolveEmptyFieldResultRuns } from "../prosemirror/emptyFieldResultRuns.js";
 import "../prosemirror/extensions/nodes/SdtExtension.js";
+import { canonicalFieldNode } from "../prosemirror/fieldRepresentation.js";
+import { resolvedPreservedXmlAttrs } from "../prosemirror/preservedXmlReview.js";
 import { continuedRunMarks } from "../prosemirror/rejoinRunCarriers.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../prosemirror/runFormattingMarkNames.js";
-import { reconstructRejectedRunFormattingMarks } from "../prosemirror/runPropertyChangeResolution.js";
+import { reconstructRejectedRunFormattingMarks, restoreHistoricalRunFormatting } from "../prosemirror/runPropertyChangeResolution.js";
 import { paragraphRunStyleContext } from "../prosemirror/runStyleFormatting.js";
 import { recordNodeResolution } from "./revisionResolutionEdits.js";
 import { panic } from "better-result";
@@ -35,6 +37,11 @@ const rebuildNode = (source, attrs, content, marks = source.marks) => recreatePr
 const resolveInlineNode = ({ node, context, paragraphScope }) => {
 	let marks = node.marks;
 	let attrs = node.attrs;
+	if (context.mode === "reject" && node.marks.some((mark) => mark.type === context.keepType && expectTrackedChangeMarkAttrs(mark)._historicalFormatting)) marks = restoreHistoricalRunFormatting({
+		node,
+		paragraphContext: resolveParagraphRunStyleScope(paragraphScope, context.styleResolver),
+		styleResolver: context.styleResolver
+	});
 	const runPropertyChangeMark = marks.find((mark) => mark.type.name === "runPropertyChange");
 	if (runPropertyChangeMark) {
 		const { changes } = expectRunPropertyChangeMarkAttrs(runPropertyChangeMark);
@@ -64,6 +71,7 @@ const resolveInlineNode = ({ node, context, paragraphScope }) => {
 	}
 	if (node.marks.some((mark) => (mark.type.name === "insertion" || mark.type.name === "deletion") && expectTrackedChangeMarkAttrs(mark)._docxRevisionAncestors?.some((layer) => context.mode === "accept" ? layer.type === "deletion" || layer.type === "moveFrom" : layer.type === "insertion" || layer.type === "moveTo")) || context.removeType && node.marks.some((mark) => mark.type === context.removeType)) return null;
 	if (context.keepType) marks = marks.filter((mark) => mark.type !== context.keepType);
+	if (attrs === node.attrs) attrs = resolvedPreservedXmlAttrs(node, marks);
 	if (attrs !== node.attrs) return rebuildNode(node, attrs, node.content, marks);
 	return marksEqual(marks, node.marks) ? node : node.mark(marks);
 };
@@ -172,7 +180,7 @@ const resolveInlineContent = ({ node, position, context, inheritedParagraphScope
 		context
 	});
 	let resolvedContent = Fragment.fromArray(children);
-	if (!resolvedNode.type.validContent(resolvedContent)) {
+	if (!resolvedNode.type.validContent(resolvedContent) && !(resolvedNode.type.name === "structuredField" && resolvedContent.size === 0)) {
 		const fitted = resolvedNode.type.createAndFill(resolvedNode.attrs, resolvedContent, resolvedNode.marks);
 		if (!fitted || !resolvedNode.type.validContent(fitted.content)) {
 			if (!resolvedNode.isInline) return panic(`Revision inline resolution invalidated ${resolvedNode.type.name} content`);
@@ -195,7 +203,21 @@ const resolveInlineContent = ({ node, position, context, inheritedParagraphScope
 		from: position,
 		to: position + resolvedNode.nodeSize
 	});
-	return rebuildNode(node, resolvedAttrs, resolvedContent, resolvedNode.marks);
+	const rebuilt = rebuildNode(node, resolvedAttrs, resolvedContent, resolvedNode.marks);
+	const canonical = canonicalFieldNode(rebuilt);
+	if (canonical !== rebuilt && canonical.type === rebuilt.type) recordNodeResolution({
+		before: rebuilt,
+		after: canonical,
+		position,
+		steps: context.steps
+	});
+	else if (canonical !== rebuilt) context.replacementRanges.splice(replacementRangeStart, context.replacementRanges.length - replacementRangeStart, {
+		from: position,
+		to: position + node.nodeSize,
+		newSize: canonical.nodeSize,
+		slice: new Slice(Fragment.from(canonical), 0, 0)
+	});
+	return canonical;
 };
 const coalesceReplacementRanges = (replacementRanges) => {
 	const coalesced = [];

package/dist/markdown/internals.js

@@ -1,5 +1,6 @@
 import { createBuiltInStyleIndex } from "../docx/builtInStyles.js";
 import { createListLabelCounter } from "../prosemirror/listLabels.js";
+import { createStyleResolver, resolveStyleParagraphNumbering } from "../prosemirror/styles/styleResolver.js";
 import { createNoteReferenceNumbering, noteReferenceMarker, noteReferenceToken } from "../utils/noteReferenceLabels.js";
 //#region src/markdown/internals.ts
 /**
@@ -18,7 +19,13 @@ import { createNoteReferenceNumbering, noteReferenceMarker, noteReferenceToken }
 * make the render quadratic.
 */
 function newContext(opts = {}, styles) {
+	const resolver = createStyleResolver(styles);
+	const numbering = /* @__PURE__ */ new Map();
 	return {
+		paragraphNumbering: (styleId) => {
+			if (!numbering.has(styleId)) numbering.set(styleId, resolveStyleParagraphNumbering(resolver, styleId));
+			return numbering.get(styleId);
+		},
 		builtInStyles: createBuiltInStyleIndex(styles?.styles ?? [], styles?.docDefaults),
 		opts: {
 			annotations: opts.annotations ?? "html",

package/dist/markdown/renderParagraph.js

@@ -1,4 +1,7 @@
 import { isQuoteStyle, resolveHeadingLevel } from "../docx/builtInStyles.js";
+import { resolveCachedListRendering, resolveListRenderingDefinition } from "../docx/listRendering.js";
+import { getCachedNumberingMap } from "../docx/numberingParser.js";
+import { mergeParagraphNumbering } from "../docx/numberingReference.js";
 import { listLabelAttrsFromRendering } from "../prosemirror/listLabels.js";
 import { inlineBreaksToHtml } from "./escape.js";
 import { renderParagraphInline } from "./renderRuns.js";
@@ -32,7 +35,12 @@ function renderParagraph(ctx, pkg, para) {
 * does not define as prose, as every other reader reads them.
 */
 function renderParagraphBlock(ctx, pkg, para) {
-	const label = ctx.nextListLabel(listLabelAttrs(para));
+	const numPrFromStyle = ctx.paragraphNumbering(para.formatting?.styleId) ?? para.formatting?.numPrFromStyle;
+	const numPr = mergeParagraphNumbering(numPrFromStyle, para.formatting?.numPr);
+	let list = para.listRendering;
+	if (numPr?.kind === "none" || pkg?.numbering !== void 0 && numPr === void 0) list = void 0;
+	else if (pkg?.numbering !== void 0 && numPr?.kind === "reference") list = resolveCachedListRendering(para.listRendering, resolveListRenderingDefinition(numPr, getCachedNumberingMap(pkg.numbering))) ?? void 0;
+	const label = ctx.nextListLabel(list ? listLabelAttrsFromRendering(list, numPrFromStyle) : UNNUMBERED);
 	const inline = renderParagraphInline(ctx, pkg, para.content, para.paraId);
 	const styleId = para.formatting?.styleId;
 	const headingLevel = markdownHeadingLevel(ctx, para);
@@ -49,8 +57,8 @@ function renderParagraphBlock(ctx, pkg, para) {
 			isListItem: false
 		};
 	}
-	if (para.listRendering && label !== void 0) return {
-		markdown: renderListItem(ctx, para.listRendering, label, inline),
+	if (list && label !== void 0) return {
+		markdown: renderListItem(ctx, list, label, inline),
 		isListItem: true
 	};
 	ctx.listIndentWidths = [];
@@ -72,15 +80,6 @@ function markdownHeadingLevel(ctx, para) {
 }
 const UNNUMBERED = Object.freeze({});
 /**
-* The attrs the page's list counter reads, projected from the paragraph the
-* way the editor projects them (`toProseDoc`). A paragraph without a list
-* rendering counts as unnumbered.
-*/
-function listLabelAttrs(para) {
-	const list = para.listRendering;
-	return list ? listLabelAttrsFromRendering(list, para.formatting?.numPrFromStyle) : UNNUMBERED;
-}
-/**
 * A plain paragraph whose visible text begins with markdown block syntax (e.g.
 * `# Not a heading`, `- value`, `1. value`, `> quote`) would be reclassified as
 * a heading/list/blockquote on re-parse, even though Word carries no matching

package/dist/markdown/renderRuns.js

@@ -1,5 +1,5 @@
 import { getHyperlinkRuns } from "../docx/hyperlinkParser.js";
-import { RELATIONSHIP_TYPES, resolveRelationshipIdOfType } from "../docx/relsParser.js";
+import { RELATIONSHIP_TYPES, resolveRelationshipIdOfType, resolveRelativePath } from "../docx/relsParser.js";
 import { decodeOoxmlSymbolCharacter } from "../utils/ooxmlSymbol.js";
 import { wrapComment, wrapDeletion, wrapInsertion, wrapMoveFrom, wrapMoveTo } from "./annotations.js";
 import { escapeAltText, escapeInline, escapeLinkUrl } from "./escape.js";
@@ -226,7 +226,7 @@ function renderRunContent(ctx, pkg, content, paraId) {
 		case "noteMarker": break;
 		case "drawing": {
 			const ref = resolveRelationshipIdOfType(pkg?.relationships, item.image.rId, RELATIONSHIP_TYPES.image);
-			const media = ref.status === "resolved" ? pkg?.media?.get(ref.relationship.target) : void 0;
+			const media = ref.status === "resolved" ? pkg?.media?.get(resolveRelativePath("word/document.xml", ref.relationship.target)) : void 0;
 			if (media) {
 				const reg = registerImage(ctx, media, item.image, paraId);
 				const alt = reg.alt ? escapeAltText(reg.alt) : "";
@@ -490,17 +490,7 @@ function renderParagraphInline(ctx, pkg, content, paraId, edges = {
 			case "simpleField":
 			case "complexField": {
 				const runs = item.type === "simpleField" ? item.content : item.fieldResult;
-				for (const child of runs) {
-					if (child.type === "run") {
-						out += renderRuns(ctx, pkg, [child], paraId);
-						continue;
-					}
-					if (child.type === "hyperlink") {
-						out += renderHyperlink(ctx, pkg, child, paraId);
-						continue;
-					}
-					out += child.type === "inlineWrapper" ? renderParagraphInline(ctx, pkg, child.content, paraId, UNKNOWN_NEIGHBORS) : child.text;
-				}
+				for (const child of runs) out += child.type === "preservedInline" ? child.text : renderParagraphInline(ctx, pkg, [child], paraId, UNKNOWN_NEIGHBORS);
 				break;
 			}
 			case "inlineSdt":

package/dist/markdown/types.d.ts

@@ -1,3 +1,4 @@
+import { document_d_exports } from "../types/document.js";
 import { NoteReferenceKind, NoteReferenceNumbering } from "../utils/noteReferenceLabels.js";
 import { BuiltInStyleIndex } from "../docx/builtInStyles.js";
 import { ListLabelCounter } from "../prosemirror/listLabels.js";
@@ -140,6 +141,8 @@ type RenderContext = {
   nextListLabel: ListLabelCounter;
   /** The document's styles indexed by the built-in they are; classifies headings and quotes. */
   builtInStyles: BuiltInStyleIndex;
+  /** Authoritative paragraph numbering inherited through the style cascade. */
+  paragraphNumbering: (styleId: string | undefined) => document_d_exports.ParagraphFormatting["numPr"];
   /**
    * Active native Markdown ancestor marker widths, indexed by OOXML level.
    * Missing levels contribute no columns. Prose, headings and container

package/dist/panel-layout.d.ts

@@ -5,17 +5,17 @@
  *
  * The editor measures the width it has once, and this module decides how
  * each panel is presented. Every track the page shares the row with is
- * counted here, so the page, the outline and the comments cannot overlap:
- * a panel either gets a track of its own or becomes a drawer the user opens
- * on purpose. A drawer takes no track.
+ * counted here, so the page, the outline and the comments cannot overlap.
+ * Explicitly opening the outline gives it a clamped track beside the viewport;
+ * comments keep their existing column-or-drawer behavior.
  *
  * Space goes to the page first, then the outline rail, then the comments
  * column, then the full outline column:
  *
  * - comments: a column when the page, the comments and the outline rail fit;
  *   otherwise a drawer.
- * - outline: a column when it fits beside the page and the comments column;
- *   otherwise a rail of heading ticks when that fits; otherwise a drawer.
+ * - outline: a column when it fits beside the page and comments; otherwise a
+ *   rail of heading ticks when that fits, or a toolbar toggle for the opened track.
  *
  * The tier names the result: `wide` when every panel has its full column,
  * `medium` when the outline is a rail, `narrow` when a panel is a drawer.
@@ -29,6 +29,8 @@ declare const PANEL_METRICS: {
   readonly outlineColumnWidth: 256;
   /** The outline rail in the `medium` tier, border included. */
   readonly outlineRailWidth: 32;
+  /** Minimum width and height of a shared panel control. */
+  readonly controlMinimumSize: 32;
   /** A comment card column. */
   readonly commentsWidth: 280;
   /** Space between the page edge and the comment cards, and after them. */
@@ -41,8 +43,8 @@ declare const PANEL_METRICS: {
 /** Width the comments take beside the page: gap, cards, gap. */
 declare const COMMENTS_TRACK_WIDTH: number;
 type PanelLayoutTier = "wide" | "medium" | "narrow";
-/** How the outline is shown: a column, a rail of ticks, a drawer, or not at all. */
-type OutlinePresentation = "none" | "column" | "rail" | "drawer";
+/** How the outline is shown: a column, tick rail, drawer, or explicitly opened track. */
+type OutlinePresentation = "none" | "column" | "rail" | "drawer" | "expanded";
 /** How the comments are shown: a column beside the page, a drawer, or not at all. */
 type CommentsPresentation = "hidden" | "column" | "drawer";
 type PanelLayoutInput = {
@@ -50,8 +52,8 @@ type PanelLayoutInput = {
   availableWidth: number;
   /** Width of the widest page at the current zoom. */
   pageWidth: number;
-  /** Whether the document has an outline to show. */
-  outline: "absent" | "available";
+  /** Whether the document outline is absent, available, or explicitly opened. */
+  outline: "absent" | "available" | "expanded";
   /** Whether the user (or the auto-open) wants the comments shown. */
   comments: "closed" | "open";
 };

package/dist/panel-layout.js

@@ -5,17 +5,17 @@
 *
 * The editor measures the width it has once, and this module decides how
 * each panel is presented. Every track the page shares the row with is
-* counted here, so the page, the outline and the comments cannot overlap:
-* a panel either gets a track of its own or becomes a drawer the user opens
-* on purpose. A drawer takes no track.
+* counted here, so the page, the outline and the comments cannot overlap.
+* Explicitly opening the outline gives it a clamped track beside the viewport;
+* comments keep their existing column-or-drawer behavior.
 *
 * Space goes to the page first, then the outline rail, then the comments
 * column, then the full outline column:
 *
 * - comments: a column when the page, the comments and the outline rail fit;
 *   otherwise a drawer.
-* - outline: a column when it fits beside the page and the comments column;
-*   otherwise a rail of heading ticks when that fits; otherwise a drawer.
+* - outline: a column when it fits beside the page and comments; otherwise a
+*   rail of heading ticks when that fits, or a toolbar toggle for the opened track.
 *
 * The tier names the result: `wide` when every panel has its full column,
 * `medium` when the outline is a rail, `narrow` when a panel is a drawer.
@@ -29,6 +29,8 @@ const PANEL_METRICS = {
 	outlineColumnWidth: 256,
 	/** The outline rail in the `medium` tier, border included. */
 	outlineRailWidth: 32,
+	/** Minimum width and height of a shared panel control. */
+	controlMinimumSize: 32,
 	/** A comment card column. */
 	commentsWidth: 280,
 	/** Space between the page edge and the comment cards, and after them. */
@@ -49,7 +51,7 @@ const pageTrackWidth = (pageWidth) => pageWidth + 2 * PANEL_METRICS.pageMargin;
 const panelLayoutThresholds = ({ pageWidth, outline, comments }) => {
 	const page = pageTrackWidth(pageWidth);
 	const commentsTrack = comments === "open" ? COMMENTS_TRACK_WIDTH : 0;
-	const hasOutline = outline === "available";
+	const hasOutline = outline !== "absent";
 	return {
 		wide: page + commentsTrack + (hasOutline ? PANEL_METRICS.outlineColumnWidth : 0),
 		medium: page + commentsTrack + (hasOutline ? PANEL_METRICS.outlineRailWidth : 0)
@@ -62,7 +64,7 @@ const OUTLINE_TRACK_WIDTH = {
 	drawer: 0
 };
 const tierFor = (outline, comments) => {
-	if (outline === "drawer" || comments === "drawer") return "narrow";
+	if (outline === "drawer" || outline === "expanded" || comments === "drawer") return "narrow";
 	if (outline === "rail") return "medium";
 	return "wide";
 };
@@ -73,11 +75,13 @@ const computePanelLayout = (input) => {
 	const page = pageTrackWidth(input.pageWidth);
 	const comments = (() => {
 		if (input.comments === "closed") return "hidden";
-		return availableWidth >= thresholds.medium ? "column" : "drawer";
+		const requiredWidth = input.outline === "expanded" ? thresholds.wide : thresholds.medium;
+		return availableWidth >= requiredWidth ? "column" : "drawer";
 	})();
 	const commentsGutter = comments === "column" ? COMMENTS_TRACK_WIDTH : 0;
 	const outline = (() => {
 		if (input.outline === "absent") return "none";
+		if (input.outline === "expanded") return "expanded";
 		const beside = page + commentsGutter;
 		if (availableWidth >= thresholds.wide) return "column";
 		if (availableWidth >= beside + PANEL_METRICS.outlineRailWidth) return "rail";
@@ -87,7 +91,7 @@ const computePanelLayout = (input) => {
 		tier: tierFor(outline, comments),
 		outline,
 		comments,
-		outlineTrackWidth: OUTLINE_TRACK_WIDTH[outline],
+		outlineTrackWidth: outline === "expanded" ? Math.min(PANEL_METRICS.outlineColumnWidth, Math.max(PANEL_METRICS.controlMinimumSize, (availableWidth - commentsGutter) / 2)) : OUTLINE_TRACK_WIDTH[outline],
 		commentsGutter,
 		thresholds
 	};

package/dist/prosemirror/addTrackedDeletionMark.d.ts

@@ -0,0 +1,18 @@
+import { Mark } from "prosemirror-model";
+import { Transform } from "prosemirror-transform";
+//#region src/prosemirror/addTrackedDeletionMark.d.ts
+type AddTrackedDeletionMarkOptions = {
+  tr: Transform;
+  from: number;
+  to: number;
+  mark: Mark;
+  insertionPolicy: "preserve-pending" | "retract-own";
+};
+/**
+ * Already deleted runs keep their revision identity and enclosing insertion path.
+ * An own insertion containing deleted descendants is marked rather than retracted:
+ * removing its carrier would also remove another pending revision.
+ */
+declare const addTrackedDeletionMark: ({ tr, from, to, mark, insertionPolicy }: AddTrackedDeletionMarkOptions) => void;
+//#endregion
+export { addTrackedDeletionMark };

package/dist/prosemirror/addTrackedDeletionMark.js

@@ -0,0 +1,87 @@
+import { expectTrackedChangeMarkAttrs } from "./attrs/index.js";
+import { trackedRevisionLayerOf } from "./trackedRevisionPath.js";
+import { canCarryTrackedRunMark } from "./trackedRunInlineAtoms.js";
+import { panic } from "better-result";
+//#region src/prosemirror/addTrackedDeletionMark.ts
+/**
+* Already deleted runs keep their revision identity and enclosing insertion path.
+* An own insertion containing deleted descendants is marked rather than retracted:
+* removing its carrier would also remove another pending revision.
+*/
+const addTrackedDeletionMark = ({ tr, from, to, mark, insertionPolicy }) => {
+	if (mark.type.name !== "deletion") panic("A tracked deletion requires a deletion mark");
+	const preservedDeletions = [];
+	const protectedCarriers = /* @__PURE__ */ new Set();
+	tr.doc.nodesBetween(from, to, (node, position) => {
+		const existing = node.marks.find(({ type }) => type.name === "deletion");
+		if (node.isInline && existing) {
+			const start = Math.max(from, position);
+			const end = Math.min(to, position + node.nodeSize);
+			if (start < end) preservedDeletions.push({
+				from: start,
+				to: end,
+				mark: existing
+			});
+			const at = tr.doc.resolve(position);
+			for (let depth = 1; depth <= at.depth; depth++) {
+				const ancestor = at.node(depth);
+				if (canCarryTrackedRunMark(ancestor)) protectedCarriers.add(ancestor);
+			}
+		}
+		return true;
+	});
+	const mapFrom = tr.mapping.maps.length;
+	const ranges = [];
+	const descendantDeletions = [];
+	const deletionFor = (node) => {
+		const insertion = node.marks.find(({ type }) => type.name === "insertion");
+		const ancestors = insertion ? expectTrackedChangeMarkAttrs(insertion)._docxRevisionAncestors : null;
+		return insertion && ancestors?.length ? mark.type.create({
+			...mark.attrs,
+			_docxRevisionAncestors: [...ancestors, trackedRevisionLayerOf(insertion, node)]
+		}) : mark;
+	};
+	tr.doc.nodesBetween(from, to, (node, position) => {
+		if (!canCarryTrackedRunMark(node)) return true;
+		if (node.marks.some(({ type }) => type.name === "deletion")) return false;
+		const start = Math.max(from, position);
+		const end = Math.min(to, position + node.nodeSize);
+		if (start >= end) return false;
+		const insertion = node.marks.find(({ type }) => type.name === "insertion");
+		const ownInsertion = insertion !== void 0 && insertion.attrs["author"] === mark.attrs["author"];
+		const deletion = deletionFor(node);
+		const disposition = insertionPolicy === "retract-own" && ownInsertion && !protectedCarriers.has(node) ? "retract" : "mark";
+		const previous = ranges.at(-1);
+		if (previous?.to === start && previous.disposition === disposition && previous.mark.eq(deletion)) previous.to = end;
+		else ranges.push({
+			from: start,
+			to: end,
+			mark: deletion,
+			disposition
+		});
+		if (disposition === "mark") node.descendants((child, offset) => {
+			if (child.marks.some(({ type }) => type.name === "deletion")) return false;
+			const childDeletion = deletionFor(child);
+			if (childDeletion === mark) return true;
+			const childStart = Math.max(from, position + 1 + offset);
+			const childEnd = Math.min(to, position + 1 + offset + child.nodeSize);
+			if (childStart < childEnd) descendantDeletions.push({
+				from: childStart,
+				to: childEnd,
+				mark: childDeletion
+			});
+			return true;
+		});
+		return false;
+	});
+	for (const range of ranges.toReversed()) if (range.disposition === "retract") tr.delete(range.from, range.to);
+	else tr.addMark(range.from, range.to, range.mark);
+	const mapping = tr.mapping.slice(mapFrom);
+	for (const preserved of [...descendantDeletions, ...preservedDeletions]) {
+		const start = mapping.map(preserved.from);
+		const end = mapping.map(preserved.to);
+		if (start < end) tr.addMark(start, end, preserved.mark);
+	}
+};
+//#endregion
+export { addTrackedDeletionMark };

package/dist/prosemirror/attrs/index.js

@@ -8,6 +8,8 @@ import { attrsRecord, attrsResult, expectAttrs, expectCachedNodeAttrs, expectNod
 import { COUNTER_FORMAT_VALUES, EMPHASIS_MARK_VALUES, FIELD_TYPE_VALUES, FONT_HINT_VALUES, FONT_THEME_VALUES, HIGHLIGHT_COLOR_VALUES, IMAGE_HORIZONTAL_ALIGNMENT_VALUES, IMAGE_HORIZONTAL_RELATIVE_TO_VALUES, IMAGE_VERTICAL_ALIGNMENT_VALUES, IMAGE_VERTICAL_RELATIVE_TO_VALUES, IMAGE_WRAP_TEXT_VALUES, IMAGE_WRAP_TYPE_VALUES, LINE_SPACING_RULE_VALUES, OUTLINE_STYLE_ATTR_VALUES, PARAGRAPH_ALIGNMENT_VALUES, POSITIONAL_TAB_ALIGNMENT_VALUES, POSITIONAL_TAB_LEADER_VALUES, POSITIONAL_TAB_RELATIVE_TO_VALUES, SDT_LOCK_VALUES, SDT_TYPE_VALUES, SHADING_PATTERN_VALUES, TABLE_CELL_VERTICAL_ALIGNMENT_VALUES, TABLE_JUSTIFICATION_VALUES, TABLE_ROW_HEIGHT_RULE_VALUES, TABLE_WIDTH_TYPE_VALUES, TAB_LEADER_VALUES, TAB_STOP_ALIGNMENT_VALUES, TEXT_DIRECTION_VALUES, TEXT_EFFECT_VALUES, UNDERLINE_STYLE_VALUES } from "../../types/documentEnumValues.js";
 import { canonicalJson } from "../../utils/canonicalJson.js";
 import { normalizeHorizontalScalePercent } from "../../utils/horizontalScale.js";
+import { PICTURE_NAME_DOM_ATTRIBUTES } from "../imagePictureNames.js";
+import { isNoteReferenceOccurrenceId } from "../noteReferenceOccurrenceId.js";
 import { paragraphNumberingFromAttrValue } from "../numberingAttr.js";
 import { outlineLevelFromAttrValue } from "../outlineLevelAttr.js";
 import { isParagraphDirection } from "../paragraphDirection.js";
@@ -488,6 +490,9 @@ const readImageAttrs = (node) => {
 	expectNodeType(node, "image", issues);
 	requiredString(attrs, "src", "image.attrs.src", issues);
 	optionalString(attrs, "docPrName", "image.attrs.docPrName", issues);
+	optionalNestedRecord(attrs, "pictureNames", "image.attrs.pictureNames", issues, (names, path, nestedIssues) => {
+		for (const key of Object.keys(PICTURE_NAME_DOM_ATTRIBUTES)) optionalString(names, key, `${path}.${key}`, nestedIssues);
+	});
 	optionalString(attrs, "alt", "image.attrs.alt", issues);
 	optionalString(attrs, "title", "image.attrs.title", issues);
 	optionalString(attrs, "rId", "image.attrs.rId", issues);
@@ -953,6 +958,10 @@ const readFootnoteRefMarkAttrs = (mark) => {
 	const issues = [];
 	expectMarkType(mark, "footnoteRef", issues);
 	requiredStringOrNumber(attrs, "id", "footnoteRef.attrs.id", issues);
+	if (!isNoteReferenceOccurrenceId(attrs["occurrenceId"])) issues.push({
+		path: "footnoteRef.attrs.occurrenceId",
+		message: "Expected a nonblank occurrence identity."
+	});
 	optionalOneOf(attrs, "noteType", "footnoteRef.attrs.noteType", issues, NOTE_TYPES);
 	optionalOneOf(attrs, "vertAlign", "footnoteRef.attrs.vertAlign", issues, NOTE_REF_VERT_ALIGNS);
 	optionalBoolean(attrs, "customMarkFollows", "footnoteRef.attrs.customMarkFollows", issues);

package/dist/prosemirror/commands/comments.js

@@ -10,20 +10,23 @@ import { resolveEmptyFieldResultRuns } from "../emptyFieldResultRuns.js";
 import { JOINED_RUNS_RESTYLED_META } from "../extensions/features/JoinedRunStyleExtension.js";
 import { markChangedParagraphRanges, markStructuralChange, markTrackedSectionEndpointRemoval } from "../extensions/features/ParagraphChangeTrackerExtension.js";
 import "../extensions/nodes/SdtExtension.js";
+import { canonicalFieldNode } from "../fieldRepresentation.js";
 import { resolveStateStory } from "../markupViewProjection.js";
 import { joinAtParagraphMark } from "../paragraphMarkJoin.js";
 import { getDocumentNumbering } from "../plugins/documentNumbering.js";
 import { getDocumentStyleResolver } from "../plugins/documentStyleState.js";
+import { resolvedPreservedXmlAttrs } from "../preservedXmlReview.js";
 import { rebaseParagraphRuns, setParagraphAttrsWithRebasedRunFormatting } from "../rebaseParagraphRunFormatting.js";
 import { rejoinRunsAt } from "../rejoinRunCarriers.js";
 import { getFolioNodeRevisionCarriers, nodePropertyRevisionSites } from "../revisionCarriers.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../runFormattingMarkNames.js";
-import { reconstructRejectedRunFormattingMarks } from "../runPropertyChangeResolution.js";
+import { reconstructRejectedRunFormattingMarks, restoreHistoricalRunFormatting } from "../runPropertyChangeResolution.js";
 import { paragraphRunStyleContext, paragraphRunStyleContextAt } from "../runStyleFormatting.js";
 import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
 import { isTableCellRetainedInReviewView } from "../tableCellRevisionVisibility.js";
 import { markRowEmptiedInBatch, reconcileTableGridAfterColumnRemoval, removeRowsWithoutCellsAfterBatch, removeTableRow } from "../tableGridMutation.js";
 import { runInCellPending, runParagraphIntoTable } from "../tableRunIn.js";
+import { retainedTrackedRevisionMark, trackedRevisionPathOf } from "../trackedRevisionPath.js";
 import { holdsNoContent } from "../zeroWidthAnchors.js";
 import { inlineBookmarksForParagraphJoin } from "./paragraphBookmarkJoin.js";
 import { hasSerializableParagraphPropertyChange, paragraphPropertiesSnapshot } from "./propertyChangeScope.js";
@@ -32,10 +35,16 @@ import { resolveParagraphChangeAttrs } from "./resolveParagraphProperties.js";
 import { hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge } from "./tableCellMergeResolution.js";
 import { panic } from "better-result";
 import { PARAGRAPH_MARK_CHANGE_KINDS, REVIEW_CARRIERS } from "@stll/docx-core/model";
+import { Fragment } from "prosemirror-model";
 import { TableMap } from "prosemirror-tables";
 import { Mapping } from "prosemirror-transform";
 //#region src/prosemirror/commands/comments.ts
 /**
+* Comment and Track Changes Commands
+*
+* PM commands for adding/removing comments and accepting/rejecting tracked changes.
+*/
+/**
 * Add a comment mark to the current selection.
 */
 function addCommentMark(commentId) {
@@ -67,21 +76,6 @@ function removeCommentMark(commentId) {
 		return true;
 	};
 }
-const revisionLayerOf = (mark) => {
-	const attrs = expectTrackedChangeMarkAttrs(mark);
-	let type;
-	if (mark.type.name === "insertion") type = attrs.moveKind === "moveTo" ? "moveTo" : "insertion";
-	else type = attrs.moveKind === "moveFrom" ? "moveFrom" : "deletion";
-	return {
-		type,
-		revisionId: attrs.revisionId,
-		author: attrs.author,
-		...attrs.date ? { date: attrs.date } : {},
-		...attrs.utcDate ? { utcDate: attrs.utcDate } : {},
-		...attrs.initials ? { initials: attrs.initials } : {},
-		outerWrapperCount: attrs._docxOuterWrapperCount ?? 0
-	};
-};
 const revisionLayerRemovesContent = (layer, mode) => mode === "accept" ? layer.type === "deletion" || layer.type === "moveFrom" : layer.type === "insertion" || layer.type === "moveTo";
 /**
 * Resolve a tracked change: accept or reject.
@@ -189,6 +183,19 @@ function resolveChange(from, to, mode, revisionIds) {
 				const runPropertyChangeMark = node.marks.find((mark) => mark.type.name === "runPropertyChange");
 				const removesNode = removeType !== void 0 && node.marks.some((mark) => mark.type === removeType && matchesRevision(mark));
 				if (removesNode || runPropertyChangeMark !== void 0 || node.marks.some((mark) => (mark.type === insertionType || mark.type === deletionType) && matchesRevision(mark))) resolvedBoundaries.push(rangeFrom, rangeTo);
+				if (mode === "reject" && node.marks.find((mark) => mark.type === keepType && matchesRevision(mark) && expectTrackedChangeMarkAttrs(mark)._historicalFormatting && !expectTrackedChangeMarkAttrs(mark)._docxRevisionAncestors?.some((layer) => (layer.type === "deletion" || layer.type === "moveFrom") && revisionSet !== null && !revisionSet.has(layer.revisionId))) && !removesNode) {
+					const nextMarks = restoreHistoricalRunFormatting({
+						node,
+						paragraphContext: paragraphRunStyleContextAt({
+							doc: tr.doc,
+							pos: rangeFrom,
+							styleResolver
+						}),
+						styleResolver
+					});
+					for (const mark of node.marks) if (RUN_FORMATTING_MARK_NAMES.has(mark.type.name)) tr.removeMark(rangeFrom, rangeTo, mark);
+					for (const mark of nextMarks) if (RUN_FORMATTING_MARK_NAMES.has(mark.type.name)) tr.addMark(rangeFrom, rangeTo, mark);
+				}
 				if (runPropertyChangeMark) resolveRunPropertyChange({
 					tr,
 					node,
@@ -201,7 +208,7 @@ function resolveChange(from, to, mode, revisionIds) {
 				});
 				const nestedMark = node.marks.find((mark) => (mark.type === insertionType || mark.type === deletionType) && (expectTrackedChangeMarkAttrs(mark)._docxRevisionAncestors?.length ?? 0) > 0);
 				if (nestedMark) {
-					const path = [...expectTrackedChangeMarkAttrs(nestedMark)._docxRevisionAncestors ?? [], revisionLayerOf(nestedMark)];
+					const path = trackedRevisionPathOf(nestedMark);
 					const selected = (layer) => revisionSet === null || revisionSet.has(layer.revisionId);
 					if (path.some(selected)) if (path.some((layer) => selected(layer) && revisionLayerRemovesContent(layer, mode))) deleteRanges.push({
 						from: rangeFrom,
@@ -209,23 +216,13 @@ function resolveChange(from, to, mode, revisionIds) {
 					});
 					else {
 						tr.removeMark(rangeFrom, rangeTo, nestedMark);
-						const remaining = path.filter((layer) => !selected(layer));
-						const active = remaining.at(-1);
-						if (active) {
-							const type = active.type === "insertion" || active.type === "moveTo" ? insertionType : deletionType;
-							if (!type) panic("A nested tracked revision has no editor mark type");
-							tr.addMark(rangeFrom, rangeTo, type.create({
-								revisionId: active.revisionId,
-								author: active.author,
-								date: active.date ?? null,
-								utcDate: active.utcDate ?? null,
-								initials: active.initials ?? null,
-								moveKind: active.type === "moveTo" || active.type === "moveFrom" ? active.type : null,
-								_historicalFormatting: active.type === "deletion" || active.type === "moveFrom" ? true : null,
-								_docxOuterWrapperCount: active.outerWrapperCount,
-								_docxRevisionAncestors: remaining.length > 1 ? remaining.slice(0, -1) : null
-							}));
-						}
+						const retained = retainedTrackedRevisionMark(nestedMark, (layer) => !selected(layer));
+						if (retained) tr.addMark(rangeFrom, rangeTo, retained);
+					}
+					const current = tr.doc.nodeAt(pos);
+					if (current) {
+						const attrs = resolvedPreservedXmlAttrs(node, current.marks);
+						if (attrs !== node.attrs) tr.setNodeMarkup(pos, void 0, attrs);
 					}
 					return true;
 				}
@@ -233,6 +230,10 @@ function resolveChange(from, to, mode, revisionIds) {
 					from: rangeFrom,
 					to: rangeTo
 				});
+				if (!removesNode && keepType && node.marks.some((mark) => mark.type === keepType && matchesRevision(mark))) {
+					const attrs = resolvedPreservedXmlAttrs(node, node.marks.filter((mark) => !(mark.type === keepType && matchesRevision(mark))));
+					if (attrs !== node.attrs) tr.setNodeMarkup(pos, void 0, attrs);
+				}
 				if (!removeKeptMarksInBulk) {
 					for (const mark of node.marks) if (keepType && mark.type === keepType && matchesRevision(mark)) tr.removeMark(rangeFrom, rangeTo, mark);
 				}
@@ -255,7 +256,17 @@ function resolveChange(from, to, mode, revisionIds) {
 				}
 				rangesToDelete = coalescedDeleteRanges;
 			}
-			for (const range of rangesToDelete.toReversed()) tr.delete(range.from, range.to);
+			for (const range of rangesToDelete.toReversed()) {
+				const start = tr.doc.resolve(range.from);
+				const field = start.parent;
+				if (field.type.name === "structuredField" && start.parentOffset === 0 && range.to === start.end()) {
+					const position = start.before();
+					const empty = canonicalFieldNode(field.copy(Fragment.empty));
+					tr.replaceWith(position, position + field.nodeSize, empty);
+					continue;
+				}
+				tr.delete(range.from, range.to);
+			}
 			if (deleteTextBoxesAnchoredAt(tr, droppedTextBoxAnchorIds(state.doc, tr.doc))) markStructuralChange(tr);
 			tableRowStructuralOps.sort((left, right) => right.rowPos - left.rowPos);
 			let resolvedTableRowStructure = false;
@@ -418,6 +429,20 @@ function resolveChange(from, to, mode, revisionIds) {
 				boundaries: resolvedBoundaries.map((position) => tr.mapping.map(position)).filter((position) => !seams.has(position)),
 				styleResolver
 			});
+			const resolvedFields = [];
+			tr.doc.descendants((node, position) => {
+				const canonical = canonicalFieldNode(node);
+				if (canonical !== node) resolvedFields.push({
+					node: canonical,
+					position
+				});
+			});
+			for (const { node, position } of resolvedFields.toReversed()) {
+				const field = tr.doc.nodeAt(position);
+				if (!field) continue;
+				if (field.type === node.type) tr.setNodeMarkup(position, void 0, node.attrs, node.marks);
+				else tr.replaceWith(position, position + field.nodeSize, node);
+			}
 			if (tr.steps.length > 0) dispatch(tr);
 		}
 		return true;