@stll/folio-core 0.52.0 → 0.54.0

package/dist/prosemirror/commands/resolveParagraphProperties.d.ts

@@ -0,0 +1,16 @@
+import { RunStyleResolver } from "../runStyleFormatting.js";
+import { NumberingMap } from "../../docx/numberingParser.js";
+import { Node } from "prosemirror-model";
+//#region src/prosemirror/commands/resolveParagraphProperties.d.ts
+type ResolveParagraphPropertiesOptions = {
+  node: Node;
+  boundaryCovered: boolean;
+  mode: "accept" | "reject";
+  revisionSet: ReadonlySet<number> | null;
+  styleResolver: RunStyleResolver | null;
+  numbering: NumberingMap | null;
+};
+/** Resolve paragraph and section property records before resolving their inline content. */
+declare const resolveParagraphChangeAttrs: ({ node, boundaryCovered, mode, revisionSet, styleResolver, numbering }: ResolveParagraphPropertiesOptions) => Record<string, unknown> | null;
+//#endregion
+export { resolveParagraphChangeAttrs };

package/dist/prosemirror/commands/resolveParagraphProperties.js

@@ -0,0 +1,73 @@
+import { expectParagraphAttrs } from "../attrs/index.js";
+import { rejectedListRenderingPatch } from "../listRendering.js";
+import { styleResolvedParagraphFormatting } from "../paragraphFormattingProvenance.js";
+import { resolveParagraphDefaultTextFormatting } from "../styles/paragraphStyleCascade.js";
+import { paragraphRejectAttrPatch, paragraphRejectOriginalFormatting, removeParagraphPropertyChanges, sectionRejectProperties } from "./propertyChangeScope.js";
+//#region src/prosemirror/commands/resolveParagraphProperties.ts
+/** Resolve paragraph and section property records before resolving their inline content. */
+const resolveParagraphChangeAttrs = ({ node, boundaryCovered, mode, revisionSet, styleResolver, numbering }) => {
+	let nextAttrs = null;
+	const propertyChanges = expectParagraphAttrs(node)._propertyChanges;
+	if (Array.isArray(propertyChanges) && propertyChanges.length > 0 && boundaryCovered) {
+		const matchesPropertyChange = (change) => revisionSet === null || revisionSet.has(change.info.id);
+		if (propertyChanges.some(matchesPropertyChange)) {
+			const rejection = mode === "reject" ? removeParagraphPropertyChanges(propertyChanges, matchesPropertyChange) : null;
+			let remaining;
+			if (rejection === null) remaining = propertyChanges.filter((change) => !matchesPropertyChange(change));
+			else if (rejection.type === "unchanged") remaining = propertyChanges;
+			else remaining = rejection.remaining;
+			nextAttrs = {
+				...node.attrs,
+				_propertyChanges: remaining.length > 0 ? remaining : null
+			};
+			if (rejection?.type === "restore-previous") {
+				const currentAttrs = expectParagraphAttrs(node);
+				const inheritedAlignment = currentAttrs.alignmentFromStyle;
+				const restoredStyleId = rejection.previousFormatting?.styleId ?? void 0;
+				const sameStyle = restoredStyleId === (currentAttrs.styleId ?? void 0);
+				let previousFormattingFromStyle;
+				let resolvedFromStyle = sameStyle ? currentAttrs._resolvedFormatting : void 0;
+				if (styleResolver) {
+					previousFormattingFromStyle = styleResolver.resolveParagraphStyle(restoredStyleId).paragraphFormatting;
+					if (!sameStyle) {
+						resolvedFromStyle = styleResolvedParagraphFormatting(previousFormattingFromStyle);
+						nextAttrs["_resolvedFormatting"] = resolvedFromStyle;
+					}
+				} else if (inheritedAlignment !== void 0) previousFormattingFromStyle = { alignment: inheritedAlignment };
+				const inheritedFormatting = previousFormattingFromStyle === void 0 && resolvedFromStyle === void 0 ? void 0 : {
+					...previousFormattingFromStyle,
+					...resolvedFromStyle
+				};
+				Object.assign(nextAttrs, paragraphRejectAttrPatch(rejection.previousFormatting, inheritedFormatting), rejectedListRenderingPatch({
+					current: expectParagraphAttrs(node),
+					previousFormatting: rejection.previousFormatting,
+					numbering
+				}));
+				const restoredFormatting = paragraphRejectOriginalFormatting(rejection.previousFormatting, node.attrs["_originalFormatting"]);
+				nextAttrs["_originalFormatting"] = restoredFormatting;
+				if (styleResolver) nextAttrs["defaultTextFormatting"] = resolveParagraphDefaultTextFormatting(rejection.previousFormatting?.styleId, restoredFormatting ?? void 0, styleResolver) ?? null;
+			}
+		}
+	}
+	const sectionProperties = expectParagraphAttrs(node)._sectionProperties;
+	const sectionChanges = sectionProperties?.propertyChanges;
+	if (sectionProperties && Array.isArray(sectionChanges) && sectionChanges.length > 0 && boundaryCovered) {
+		const matches = sectionChanges.filter((c) => revisionSet === null || c.info && revisionSet.has(c.info.id));
+		if (matches.length > 0) {
+			const remaining = sectionChanges.filter((c) => revisionSet !== null && (!c.info || !revisionSet.has(c.info.id)));
+			let restored = { ...sectionProperties };
+			if (mode === "reject") for (const change of matches.toReversed()) restored = sectionRejectProperties({
+				live: restored,
+				previousProperties: change.previousProperties,
+				previousReferences: change.previousReferences
+			});
+			delete restored.propertyChanges;
+			if (remaining.length > 0) restored.propertyChanges = remaining;
+			nextAttrs = nextAttrs ?? { ...node.attrs };
+			nextAttrs["_sectionProperties"] = restored;
+		}
+	}
+	return nextAttrs;
+};
+//#endregion
+export { resolveParagraphChangeAttrs };

package/dist/prosemirror/commands/sectionBreak.js

@@ -1,3 +1,4 @@
+import { markSectionBreakRemoval } from "../extensions/features/ParagraphChangeTrackerExtension.js";
 import { mintSectionProperties, sectionPropertiesOf } from "../sectionCarrier.js";
 import { TextSelection } from "prosemirror-state";
 //#region src/prosemirror/commands/sectionBreak.ts
@@ -150,7 +151,7 @@ const rewriteSelectedSectionRecords = (rewrite) => (state, dispatch) => {
 			const paragraph = transaction.doc.nodeAt(position);
 			if (paragraph) transaction.setNodeMarkup(position, void 0, withSectionProperties(paragraph.attrs, properties));
 		}
-		dispatch(transaction.scrollIntoView());
+		dispatch(markSectionBreakRemoval(transaction, state.doc).scrollIntoView());
 	}
 	return true;
 };

package/dist/prosemirror/commands/tableCellMergeResolution.d.ts

@@ -1,8 +1,21 @@
-import { Transaction } from "prosemirror-state";
+import { document_d_exports } from "../../types/document.js";
+import { DecodedTableCellParagraphSourcePayload } from "../../docx/paragraphPropertySource.js";
 import { Node } from "prosemirror-model";
+import { Transaction } from "prosemirror-state";
 //#region src/prosemirror/commands/tableCellMergeResolution.d.ts
+declare const tableCellContinuationPayload: (node: Node) => DecodedTableCellParagraphSourcePayload | null;
 declare const hasMatchingCollapsedTableCellMerge: (node: Node, revisionSet: Set<number> | null) => boolean;
+/**
+ * Whether accepting a pending vertical merge folds the cell into the one above.
+ * The saved `w:vMerge` continuation is read back as its own cell when it carries
+ * content, so accepting such a merge keeps the cell standing; folding it would
+ * hide text that reappears when the document is reopened.
+ */
+declare const acceptedMergeFoldsIntoCellAbove: (cell: Node) => boolean;
 declare const resolveVisibleTableCellMerge: (tr: Transaction, cellPos: number, mode: "accept" | "reject") => boolean;
+declare const tableCellContinuationCells: (cell: Node, rowspan: number) => document_d_exports.TableCell[];
+declare const tableCellContinuationFromNode: (cell: Node) => document_d_exports.TableCell;
 declare const resolveCollapsedTableCellMerge: (tr: Transaction, cellPos: number, mode: "accept" | "reject", revisionSet: Set<number> | null) => boolean;
+declare const createRestoredTableCell: (origin: Node, source: document_d_exports.TableCell) => Node | null;
 //#endregion
-export { hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge };
+export { acceptedMergeFoldsIntoCellAbove, createRestoredTableCell, hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge, tableCellContinuationCells, tableCellContinuationFromNode, tableCellContinuationPayload };

package/dist/prosemirror/commands/tableCellMergeResolution.js

@@ -1,8 +1,10 @@
 import { decodeTableCellParagraphSourcePayload, restoreTableCellsWithParagraphPropertySources, transportTableCellsWithParagraphPropertySources } from "../../docx/paragraphPropertySource.js";
+import { isTableCellMergeRevisionContinuation } from "../../docx/tableParser.js";
 import { standaloneTableCellFromProseMirror } from "../conversion/fromProseDoc.js";
-import { standaloneTableCellToProseMirror } from "../conversion/toProseDoc.js";
+import { standaloneTableCellToProseMirror, tableCellHasMeaningfulContent } from "../conversion/toProseDoc.js";
 import { getTableCellMergeChange } from "../tableCellMergeRevision.js";
-import { Result } from "better-result";
+import { removeRowsWithoutCellsInRange } from "../tableGridMutation.js";
+import { Result, panic } from "better-result";
 import { TableMap } from "prosemirror-tables";
 //#region src/prosemirror/commands/tableCellMergeResolution.ts
 const tableCellContinuationPayload = (node) => {
@@ -35,15 +37,22 @@ const tableCellContext = (doc, cellPos) => {
 	}
 	return null;
 };
+/**
+* Whether accepting a pending vertical merge folds the cell into the one above.
+* The saved `w:vMerge` continuation is read back as its own cell when it carries
+* content, so accepting such a merge keeps the cell standing; folding it would
+* hide text that reappears when the document is reopened.
+*/
+const acceptedMergeFoldsIntoCellAbove = (cell) => !tableCellHasMeaningfulContent(standaloneTableCellFromProseMirror(cell));
 const resolveVisibleTableCellMerge = (tr, cellPos, mode) => {
 	const cell = tr.doc.nodeAt(cellPos);
 	const marker = cell?.attrs["cellMarker"];
 	if (!cell || !isTableCellMergeRevisionAttr(marker)) return false;
+	if (mode === "accept" ? isTableCellMergeRevisionContinuation(marker.verticalMerge) && acceptedMergeFoldsIntoCellAbove(cell) : isTableCellMergeRevisionContinuation(marker.verticalMergeOriginal)) return mergeTableCellWithCellAbove(tr, cellPos);
 	if (mode === "accept") {
 		tr.setNodeAttribute(cellPos, "cellMarker", null);
 		return true;
 	}
-	if ((marker.verticalMergeOriginal ?? "rest") === "continue") return mergeTableCellWithCellAbove(tr, cellPos);
 	const originalFormatting = cell.attrs["_originalFormatting"];
 	let nextOriginalFormatting = originalFormatting;
 	if (typeof originalFormatting === "object" && originalFormatting !== null) {
@@ -73,11 +82,18 @@ const mergeTableCellWithCellAbove = (tr, cellPos) => {
 	const aboveRowspan = aboveCell?.attrs["rowspan"];
 	const cellRowspan = cell.attrs["rowspan"];
 	if (!aboveCell || typeof aboveRowspan !== "number" || typeof cellRowspan !== "number" || aboveRowspan < 1 || cellRowspan < 1) return false;
+	removeRowsWithoutCellsInRange({
+		tr,
+		from: cellPos + 1,
+		to: cellPos + cell.nodeSize - 1
+	});
+	const capturedCell = tr.doc.nodeAt(cellPos);
+	if (!capturedCell) panic("Nested table cleanup removed its owning cell");
 	const continuationCells = tableCellContinuationCells(aboveCell, aboveRowspan);
-	continuationCells.push(tableCellContinuationFromNode(cell));
-	const nestedPayload = tableCellContinuationPayload(cell);
+	continuationCells.push(tableCellContinuationFromNode(capturedCell));
+	const nestedPayload = tableCellContinuationPayload(capturedCell);
 	if (nestedPayload) continuationCells.push(...nestedPayload.cells);
-	tr.delete(cellPos, cellPos + cell.nodeSize);
+	tr.delete(cellPos, cellPos + capturedCell.nodeSize);
 	tr.setNodeMarkup(abovePos, void 0, {
 		...aboveCell.attrs,
 		rowspan: aboveRowspan + cellRowspan,
@@ -185,4 +201,4 @@ const createRestoredTableCell = (origin, source) => {
 	return Result.try(() => origin.type.schema.nodeFromJSON(restored.toJSON())).unwrapOr(null);
 };
 //#endregion
-export { hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge };
+export { acceptedMergeFoldsIntoCellAbove, createRestoredTableCell, hasMatchingCollapsedTableCellMerge, resolveCollapsedTableCellMerge, resolveVisibleTableCellMerge, tableCellContinuationCells, tableCellContinuationFromNode, tableCellContinuationPayload };

package/dist/prosemirror/containerFinalParagraph.d.ts

@@ -28,18 +28,24 @@ declare const finalParagraphsOf: (doc: Node, paragraphTypeName: string) => {
   position: number;
   node: Node;
 }[];
+type AddedBreakCarrierBeforeOptions = {
+  at: ResolvedPos;
+  paragraphTypeName: string;
+  canCrossTable?: (table: Node) => boolean;
+};
 /**
  * The paragraph an added break can rotate BACK onto from the one at `at`: the
  * paragraph the run of inserted ones was appended after.
  *
  * The walk crosses the inserted paragraphs — their own marks stay where they
  * are, and only which paragraph is left markless changes — and stops at the
- * first one whose mark is free. `null` when there is none: a table in between,
- * which no mark joins across; a paragraph whose mark says something else,
- * which the rotation must not overwrite; or a container whose every paragraph
- * is new.
+ * first one whose mark is free. A table blocks the walk unless the caller
+ * authorizes a wholly inserted table: rejecting it removes that barrier too.
+ * `null` when there is no carrier: a table the caller cannot cross, a
+ * paragraph whose mark the rotation must not overwrite, or a container whose
+ * every paragraph is new.
  */
-declare const addedBreakCarrierBefore: (at: ResolvedPos, paragraphTypeName: string) => {
+declare const addedBreakCarrierBefore: ({ at, paragraphTypeName, canCrossTable }: AddedBreakCarrierBeforeOptions) => {
   position: number;
   node: Node;
 } | null;

package/dist/prosemirror/containerFinalParagraph.js

@@ -66,18 +66,19 @@ const marksAnAddedBreak = (node) => {
 *
 * The walk crosses the inserted paragraphs — their own marks stay where they
 * are, and only which paragraph is left markless changes — and stops at the
-* first one whose mark is free. `null` when there is none: a table in between,
-* which no mark joins across; a paragraph whose mark says something else,
-* which the rotation must not overwrite; or a container whose every paragraph
-* is new.
+* first one whose mark is free. A table blocks the walk unless the caller
+* authorizes a wholly inserted table: rejecting it removes that barrier too.
+* `null` when there is no carrier: a table the caller cannot cross, a
+* paragraph whose mark the rotation must not overwrite, or a container whose
+* every paragraph is new.
 */
-const addedBreakCarrierBefore = (at, paragraphTypeName) => {
+const addedBreakCarrierBefore = ({ at, paragraphTypeName, canCrossTable }) => {
 	let position = at.pos;
 	for (let index = at.index() - 1; index >= 0; index--) {
 		const sibling = at.parent.child(index);
 		position -= sibling.nodeSize;
 		if (sibling.type.name !== paragraphTypeName) {
-			if (isAContainerChild(sibling, paragraphTypeName)) return null;
+			if (isAContainerChild(sibling, paragraphTypeName) && !canCrossTable?.(sibling)) return null;
 			continue;
 		}
 		if (sibling.attrs["pPrMark"] == null) return {

package/dist/prosemirror/contentControlRevisions.d.ts

@@ -1,5 +1,5 @@
-import { Transaction } from "prosemirror-state";
 import { MarkType, Node } from "prosemirror-model";
+import { Transaction } from "prosemirror-state";
 //#region src/prosemirror/contentControlRevisions.d.ts
 declare const ENCLOSING_REVISION_IDS_ATTR = "_docxEnclosingRevisionIds";
 /** The revisions whose element encloses `control`. */

package/dist/prosemirror/conversion/fromProseDoc.d.ts

@@ -1,7 +1,7 @@
 import { document_d_exports } from "../../types/document.js";
 import { TableAttrs, TableCellAttrs, TableRowAttrs } from "../schema/nodes.js";
-import { RunStyleResolver } from "../runStyleFormatting.js";
-import { Mark, Node } from "prosemirror-model";
+import { marksToTextFormatting } from "../runFormattingFromMarks.js";
+import { Node } from "prosemirror-model";
 //#region src/prosemirror/conversion/fromProseDoc.d.ts
 /**
  * Whether a record the editor did not change may come back from the base
@@ -21,17 +21,6 @@ type FromProseDocOptions = {
 };
 /** Convert a ProseMirror document to the document model. */
 declare function fromProseDoc(pmDoc: Node, baseDocument?: document_d_exports.Document, { reuse }?: FromProseDocOptions): document_d_exports.Document;
-/**
- * Convert ProseMirror marks to TextFormatting
- */
-type MarksToTextFormattingOptions = {
-  baseParagraphFormatting?: document_d_exports.TextFormatting | undefined;
-  inheritedFormatting?: document_d_exports.TextFormatting | undefined;
-  paragraphMarkFormatting?: document_d_exports.TextFormatting | undefined;
-  paragraphMarkPrecedesStyle?: boolean | undefined;
-  styleResolver?: RunStyleResolver | null | undefined;
-};
-declare function marksToTextFormatting(marks: readonly Mark[], options?: MarksToTextFormattingOptions): document_d_exports.TextFormatting;
 declare function tableAttrsToFormatting(attrs: TableAttrs): document_d_exports.TableFormatting | undefined;
 /**
  * Convert ProseMirror table row attrs to TableRowFormatting