@stll/folio-core 0.61.0 → 0.63.0

package/dist/prosemirror/styles/styleResolver.js

@@ -5,6 +5,23 @@ import { mergeParagraphFormatting } from "../../utils/paragraphFormattingMerge.j
 import { cascadeStyleTextFormatting } from "./styleToggleCascade.js";
 //#region src/prosemirror/styles/styleResolver.ts
 /**
+* Style Resolver for ProseMirror Editor
+*
+* Resolves OOXML style definitions to final paragraph and run properties.
+* Handles the cascade:
+* 1. Document defaults (docDefaults)
+* 2. Normal style (if no explicit styleId)
+* 3. Style chain (basedOn inheritance - already resolved by styleParser)
+* 4. Inline properties
+*
+* For paragraphs inside a table cell, `resolveParagraphStyleInTable` inserts
+* an additional layer between docDefaults and the Normal/style chain: the
+* enclosing table style's modeled paragraph properties (`w:pPr`). See its doc
+* comment for the full cascade order.
+*
+* Based on ECMA-376 style cascade rules.
+*/
+/**
 * Word's default-template Normal style, used as a last-resort fallback for a
 * bare document that ships neither a `Normal` style nor `w:docDefaults`: 8pt
 * (160 twips) after spacing, 1.08x line spacing — the values Word writes into

package/dist/prosemirror/styles/styleToggleCascade.d.ts

@@ -1,7 +1,7 @@
 import { document_d_exports } from "../../types/document.js";
 import { STYLE_TOGGLE_KEYS } from "../../utils/textFormattingMerge.js";
 //#region src/prosemirror/styles/styleToggleCascade.d.ts
-type StyleToggleKey = (typeof STYLE_TOGGLE_KEYS)[number];
+export type StyleToggleKey = (typeof STYLE_TOGGLE_KEYS)[number];
 type ToggleState = {
   value: boolean;
   defaultsActive: boolean;
@@ -29,7 +29,7 @@ type CascadeStyleFromResolvedBaseOptions = {
   styleFormatting: document_d_exports.TextFormatting | undefined;
 };
 /** Continue a style cascade from a compact resolved paragraph snapshot. */
-declare const cascadeStyleFromResolvedBase: ({ baseFormatting, defaultsActiveProperties, styleFormatting }: CascadeStyleFromResolvedBaseOptions) => document_d_exports.TextFormatting | undefined;
+export declare const cascadeStyleFromResolvedBase: ({ baseFormatting, defaultsActiveProperties, styleFormatting }: CascadeStyleFromResolvedBaseOptions) => document_d_exports.TextFormatting | undefined;
 /**
  * Resolve run formatting across OOXML style hierarchy levels.
  *
@@ -39,6 +39,6 @@ declare const cascadeStyleFromResolvedBase: ({ baseFormatting, defaultsActivePro
  * carries its toggle history explicitly, so paragraph and character style resolution may happen
  * in separate passes without an object-identity contract.
  */
-declare function cascadeStyleTextFormatting(levels: readonly StyleToggleLevel[], options?: StyleToggleCascadeOptions): StyleTextFormattingCascade;
+export declare function cascadeStyleTextFormatting(levels: readonly StyleToggleLevel[], options?: StyleToggleCascadeOptions): StyleTextFormattingCascade;
 //#endregion
-export { StyleToggleKey, cascadeStyleFromResolvedBase, cascadeStyleTextFormatting };
+export {};

package/dist/prosemirror/styles/tableStyleRegions.d.ts

@@ -2,13 +2,13 @@ import { document_d_exports } from "../../types/document.js";
 import "../../types/index.js";
 import { ResolvedTableLook } from "../../docx/tableLook.js";
 //#region src/prosemirror/styles/tableStyleRegions.d.ts
-type TableStyleRegion = "wholeTable" | "band1Horz" | "band2Horz" | "band1Vert" | "band2Vert" | "firstCol" | "lastCol" | "firstRow" | "lastRow" | "nwCell" | "neCell" | "swCell" | "seCell";
+export type TableStyleRegion = "wholeTable" | "band1Horz" | "band2Horz" | "band1Vert" | "band2Vert" | "firstCol" | "lastCol" | "firstRow" | "lastRow" | "nwCell" | "neCell" | "swCell" | "seCell";
 /**
  * The horizontal band a row takes by position: every row but a styled first
  * or last row alternates, starting with band 1.
  */
-declare const tableRowBand: (look: ResolvedTableLook, rowIndex: number, totalRows: number) => "band1Horz" | "band2Horz" | undefined;
-type TableCellPlacement = {
+export declare const tableRowBand: (look: ResolvedTableLook, rowIndex: number, totalRows: number) => "band1Horz" | "band2Horz" | undefined;
+export type TableCellPlacement = {
   look: ResolvedTableLook;
   rowIndex: number;
   totalRows: number;
@@ -26,6 +26,5 @@ type TableCellPlacement = {
  * table, banding, columns, rows, then corners (ECMA-376 §17.7.6). A cell's or
  * row's `w:cnfStyle` overrides what its position implies.
  */
-declare const tableCellStyleRegions: ({ look, rowIndex, totalRows, column, colspan, totalColumns, rowBand, rowConditionalFormat: rowCnf, cellConditionalFormat: cellCnf }: TableCellPlacement) => TableStyleRegion[];
-//#endregion
-export { TableCellPlacement, TableStyleRegion, tableCellStyleRegions, tableRowBand };
+export declare const tableCellStyleRegions: ({ look, rowIndex, totalRows, column, colspan, totalColumns, rowBand, rowConditionalFormat: rowCnf, cellConditionalFormat: cellCnf }: TableCellPlacement) => TableStyleRegion[];
+//#endregion

package/dist/prosemirror/tableCellMergeRevision.d.ts

@@ -1,8 +1,7 @@
 import { document_d_exports } from "../types/document.js";
 //#region src/prosemirror/tableCellMergeRevision.d.ts
-type TableCellMergeChange = Extract<NonNullable<document_d_exports.TableCell["structuralChange"]>, {
+export type TableCellMergeChange = Extract<NonNullable<document_d_exports.TableCell["structuralChange"]>, {
   type: "tableCellMerge";
 }>;
-declare const getTableCellMergeChange: (value: unknown) => TableCellMergeChange | null;
-//#endregion
-export { TableCellMergeChange, getTableCellMergeChange };
+export declare const getTableCellMergeChange: (value: unknown) => TableCellMergeChange | null;
+//#endregion

package/dist/prosemirror/tableCellPaste.d.ts

@@ -3,18 +3,18 @@ import { EditorState, Transaction } from "prosemirror-state";
 import { CellSelection, Rect } from "prosemirror-tables";
 //#region src/prosemirror/tableCellPaste.d.ts
 /** A rectangular block of cells, one fragment of cells per row. */
-type PastedCells = {
+export type PastedCells = {
   width: number;
   height: number;
   rows: Fragment[];
 };
 /** What a tracked paste records its changes as. */
-type TableCellPasteRevision = {
+export type TableCellPasteRevision = {
   revisionId: number;
   author: string;
   date: string;
 };
-type TableCellPasteHooks = {
+export type TableCellPasteHooks = {
   /**
    * The revision a split merge, a grown row or a grown column is tracked
    * under; untracked when absent.
@@ -27,15 +27,15 @@ type TableCellPasteHooks = {
    */
   replaceCellContent?: CellContentReplacer;
 };
-type CellContentReplacer = (tr: Transaction, cellPos: number, slice: Slice) => void;
+export type CellContentReplacer = (tr: Transaction, cellPos: number, slice: Slice) => void;
 /**
  * A pasted slice whose table cells are new cells: a copy of a cell must not
  * claim the source cell's identity, revisions, or the continuation cells its
  * merge stored, whatever the paste lands on.
  */
-declare const pastedSliceWithNewTableCells: (slice: Slice) => Slice;
+export declare const pastedSliceWithNewTableCells: (slice: Slice) => Slice;
 /** The cells a slice holds, or null when it holds none (it is not table content). */
-declare const pastedCells: (slice: Slice) => PastedCells | null;
+export declare const pastedCells: (slice: Slice) => PastedCells | null;
 /**
  * The range of a cell's content a paste replaces. A block of whole paragraphs
  * (a pasted cell's content) replaces all of it; open content (text, or
@@ -43,7 +43,7 @@ declare const pastedCells: (slice: Slice) => PastedCells | null;
  * to the end of the last, so it takes on the cell's paragraph formatting the
  * way a paste into a paragraph does.
  */
-declare const cellPasteRange: (cell: Node, cellPos: number, slice: Slice) => {
+export declare const cellPasteRange: (cell: Node, cellPos: number, slice: Slice) => {
   from: number;
   to: number;
 };
@@ -56,19 +56,18 @@ declare const cellPasteRange: (cell: Node, cellPos: number, slice: Slice) => {
  * them, except in a tracked paste, which keeps the table's shape. Selects the
  * pasted block.
  */
-declare const insertTableCells: (tr: Transaction, tableStart: number, { top, left }: Pick<Rect, "top" | "left">, cells: PastedCells, { revision, replaceCellContent }?: TableCellPasteHooks) => Transaction;
+export declare const insertTableCells: (tr: Transaction, tableStart: number, { top, left }: Pick<Rect, "top" | "left">, cells: PastedCells, { revision, replaceCellContent }?: TableCellPasteHooks) => Transaction;
 /**
  * Paste into every cell of a cell selection: each takes the pasted cell at its
  * place in the block, the block repeating to cover the selection, or the
  * pasted content itself when it holds no cells. The table keeps its shape.
  */
-declare const fillSelectedCells: (tr: Transaction, selection: CellSelection, slice: Slice, { replaceCellContent }?: TableCellPasteHooks) => Transaction;
+export declare const fillSelectedCells: (tr: Transaction, selection: CellSelection, slice: Slice, { replaceCellContent }?: TableCellPasteHooks) => Transaction;
 /**
  * Paste `slice` into the table the selection is in: into every selected cell
  * of a cell selection, or, when the slice holds cells, as a block of cells
  * from the cell holding the cursor. False otherwise, so the paste falls
  * through to the ordinary one.
  */
-declare const pasteTableCells: (state: EditorState, slice: Slice, dispatch?: (tr: Transaction) => void, hooks?: TableCellPasteHooks) => boolean;
-//#endregion
-export { CellContentReplacer, PastedCells, TableCellPasteHooks, TableCellPasteRevision, cellPasteRange, fillSelectedCells, insertTableCells, pasteTableCells, pastedCells, pastedSliceWithNewTableCells };
+export declare const pasteTableCells: (state: EditorState, slice: Slice, dispatch?: (tr: Transaction) => void, hooks?: TableCellPasteHooks) => boolean;
+//#endregion

package/dist/prosemirror/tableCellRevisionVisibility.d.ts

@@ -1,6 +1,5 @@
 import { TableCellAttrs } from "./schema/nodes.js";
 //#region src/prosemirror/tableCellRevisionVisibility.d.ts
 /** Whether a tracked cell remains in the requested reviewed view. */
-declare const isTableCellRetainedInReviewView: (kind: NonNullable<TableCellAttrs["cellMarker"]>["kind"] | undefined, view: "original" | "final") => boolean;
-//#endregion
-export { isTableCellRetainedInReviewView };
+export declare const isTableCellRetainedInReviewView: (kind: NonNullable<TableCellAttrs["cellMarker"]>["kind"] | undefined, view: "original" | "final") => boolean;
+//#endregion

package/dist/prosemirror/tableGridMutation.d.ts

@@ -18,9 +18,9 @@ type RemoveTableRowOptions = {
  * slots: a merge reaching through the row further right is never shortened,
  * and the table is left one row shorter than that merge.
  */
-declare const removeTableRow: (tr: Transaction, { map, table, tableStart }: RemoveTableRowOptions, row: number) => void;
+export declare const removeTableRow: (tr: Transaction, { map, table, tableStart }: RemoveTableRowOptions, row: number) => void;
 /** Whether a batch of structural deletions may have emptied rows. */
-type RowsEmptiedInBatch = {
+export type RowsEmptiedInBatch = {
   pending: boolean;
 };
 type MarkRowEmptiedInBatchOptions = {
@@ -29,7 +29,7 @@ type MarkRowEmptiedInBatchOptions = {
   emptied: RowsEmptiedInBatch;
 };
 /** A transient row attribute follows node moves; conversion never serializes it. */
-declare const markRowEmptiedInBatch: ({ tr, rowPosition, emptied }: MarkRowEmptiedInBatchOptions) => void;
+export declare const markRowEmptiedInBatch: ({ tr, rowPosition, emptied }: MarkRowEmptiedInBatchOptions) => void;
 type MarkRowsEmptiedInBatchOptions = {
   tr: Transaction;
   tablePosition: number;
@@ -37,18 +37,18 @@ type MarkRowsEmptiedInBatchOptions = {
   emptied: RowsEmptiedInBatch;
 };
 /** Column removal keeps row indices stable: mark only newly cell-less rows. */
-declare const markRowsEmptiedInBatch: ({ tr, tablePosition, previousTable, emptied }: MarkRowsEmptiedInBatchOptions) => void;
+export declare const markRowsEmptiedInBatch: ({ tr, tablePosition, previousTable, emptied }: MarkRowsEmptiedInBatchOptions) => void;
 /** Sweep current tables in reverse so moves cannot invalidate cleanup targets. */
-declare const removeRowsWithoutCellsAfterBatch: (tr: Transaction, emptied: RowsEmptiedInBatch) => void;
+export declare const removeRowsWithoutCellsAfterBatch: (tr: Transaction, emptied: RowsEmptiedInBatch) => void;
 type RemoveRowsWithoutCellsInRangeOptions = {
   tr: Transaction;
   from: number;
   to: number;
 };
 /** Close marked rows before their owning cell is captured into a continuation payload. */
-declare const removeRowsWithoutCellsInRange: ({ tr, from, to }: RemoveRowsWithoutCellsInRangeOptions) => void;
+export declare const removeRowsWithoutCellsInRange: ({ tr, from, to }: RemoveRowsWithoutCellsInRangeOptions) => void;
 /** Close all cell-less rows after an immediate structural edit. */
-declare const removeRowsWithoutCells: (tr: Transaction, tablePosition: number) => void;
+export declare const removeRowsWithoutCells: (tr: Transaction, tablePosition: number) => void;
 type ReconcileTableGridAfterColumnRemovalOptions = {
   tr: Transaction;
   tablePosition: number;
@@ -63,7 +63,7 @@ type ReconcileTableGridAfterColumnRemovalOptions = {
  * edit that leaves those attrs untouched serializes a new row shape against
  * the old grid; reopening then has to interpret surviving cells as spans.
  */
-declare const reconcileTableGridAfterColumnRemoval: ({ tr, tablePosition, previousTable, removedColumn }: ReconcileTableGridAfterColumnRemovalOptions) => void;
+export declare const reconcileTableGridAfterColumnRemoval: ({ tr, tablePosition, previousTable, removedColumn }: ReconcileTableGridAfterColumnRemovalOptions) => void;
 type ReconcileTableGridAfterColumnInsertionOptions = {
   tr: Transaction;
   tablePosition: number;
@@ -77,7 +77,7 @@ type ReconcileTableGridAfterColumnInsertionOptions = {
  * Without it the table keeps the grid it had, so every row spans one column
  * more than `w:tblGrid` declares.
  */
-declare const reconcileTableGridAfterColumnInsertion: ({ tr, tablePosition, previousTable, insertedColumn }: ReconcileTableGridAfterColumnInsertionOptions) => void;
+export declare const reconcileTableGridAfterColumnInsertion: ({ tr, tablePosition, previousTable, insertedColumn }: ReconcileTableGridAfterColumnInsertionOptions) => void;
 type InsertTableColumnOptions = {
   tr: Transaction;
   tablePosition: number;
@@ -94,12 +94,12 @@ type InsertTableColumnOptions = {
  * there), a cell merged across that place widens instead, and `w:tblGrid`
  * gains the column.
  */
-declare const insertTableColumn: ({ tr, tablePosition, column, templateColumn, createCell }: InsertTableColumnOptions) => void;
+export declare const insertTableColumn: ({ tr, tablePosition, column, templateColumn, createCell }: InsertTableColumnOptions) => void;
 /**
  * Remove grid columns [`left`, `right`), walking the table map: a cell only
  * in them goes, a cell merged across them narrows, `w:tblGrid` loses them,
  * and a row left without a cell of its own goes too.
  */
-declare const removeTableColumns: (tr: Transaction, tablePosition: number, left: number, right: number) => void;
+export declare const removeTableColumns: (tr: Transaction, tablePosition: number, left: number, right: number) => void;
 //#endregion
-export { RowsEmptiedInBatch, insertTableColumn, markRowEmptiedInBatch, markRowsEmptiedInBatch, reconcileTableGridAfterColumnInsertion, reconcileTableGridAfterColumnRemoval, removeRowsWithoutCells, removeRowsWithoutCellsAfterBatch, removeRowsWithoutCellsInRange, removeTableColumns, removeTableRow };
+export {};

package/dist/prosemirror/tableResize.d.ts

@@ -1,13 +1,19 @@
 import { EditorView } from "prosemirror-view";
 //#region src/prosemirror/tableResize.d.ts
 /** 1px ≈ 15 twips at 96dpi (20 twips/pt × 72pt/in ÷ 96px/in). */
-declare const TWIPS_PER_PIXEL = 15;
+export declare const TWIPS_PER_PIXEL = 15;
 /** Minimum column width (~0.2"). */
-declare const MIN_CELL_WIDTH_TWIPS = 300;
+export declare const MIN_CELL_WIDTH_TWIPS = 300;
 /** Minimum row height (~0.14"). */
-declare const MIN_ROW_HEIGHT_TWIPS = 200;
+export declare const MIN_ROW_HEIGHT_TWIPS = 200;
+type RowResizeDeltaOptions = {
+  currentHeight: number;
+  delta: number;
+  minimumHeight: number;
+};
+export declare function clampRowResizeDelta({ currentHeight, delta, minimumHeight }: RowResizeDeltaOptions): number;
 /** Read the [left, right] column widths at `colIndex` in the table starting at `pmStart`. */
-declare function readColumnWidths(view: EditorView, pmStart: number, colIndex: number): {
+export declare function readColumnWidths(view: EditorView, pmStart: number, colIndex: number): {
   left: number;
   right: number;
 } | null;
@@ -16,33 +22,27 @@ declare function readColumnWidths(view: EditorView, pmStart: number, colIndex: n
  * `pmStart`. Returns null if the row has no explicit height — the caller
  * can fall back to measuring the rendered DOM cell.
  */
-declare function readRowHeight(view: EditorView, pmStart: number, rowIndex: number): number | null;
+export declare function readRowHeight(view: EditorView, pmStart: number, rowIndex: number): number | null;
 /** Read the last-column width (the one being resized from the table's right edge). */
-declare function readColumnWidthAt(view: EditorView, pmStart: number, colIndex: number): number | null;
-/**
- * Bake a column-resize into the PM doc: update the table's `columnWidths`
- * attr and every cell at `colIdx` / `colIdx + 1` in every row.
- */
-declare function commitColumnResize(view: EditorView, opts: {
+export declare function readColumnWidthAt(view: EditorView, pmStart: number, colIndex: number): number | null;
+/** Commit a column-pair resize, preserving each spanning cell's full grid width. */
+export declare function commitColumnResize(view: EditorView, opts: {
   pmStart: number;
   colIdx: number;
   newLeft: number;
   newRight: number;
 }): void;
 /** Bake a row-resize into the PM doc: update the target row's `height` + `heightRule`. */
-declare function commitRowResize(view: EditorView, opts: {
+export declare function commitRowResize(view: EditorView, opts: {
   pmStart: number;
   rowIdx: number;
   newHeight: number;
 }): void;
-/**
- * Bake a right-edge resize into the PM doc: grow only the last column.
- * Updates `columnWidths[colIdx]` and the cell at `colIdx` in every row.
- */
-declare function commitRightEdgeResize(view: EditorView, opts: {
+/** Commit a right-edge resize, including cells that span the resized column. */
+export declare function commitRightEdgeResize(view: EditorView, opts: {
   pmStart: number;
   colIdx: number;
   newWidth: number;
 }): void;
 //#endregion
-export { MIN_CELL_WIDTH_TWIPS, MIN_ROW_HEIGHT_TWIPS, TWIPS_PER_PIXEL, commitColumnResize, commitRightEdgeResize, commitRowResize, readColumnWidthAt, readColumnWidths, readRowHeight };
+export {};

package/dist/prosemirror/tableResize.js

@@ -1,11 +1,24 @@
-import { mergeTableCellAttrs } from "./attrs/index.js";
+import { expectTableAttrs, expectTableCellAttrs, mergeTableAttrs, mergeTableCellAttrs } from "./attrs/index.js";
+import { panic } from "better-result";
 //#region src/prosemirror/tableResize.ts
+/**
+* Table-resize commit + width-read helpers shared by the React and Vue
+* adapters. Pure `(view, …) → result` over the PM doc — the gesture state
+* machines (which DOM handle is grabbed, pixel deltas, listener wiring) stay
+* in each adapter.
+*
+* Widths and heights are stored in twips (1/20 of a point) on the PM doc,
+* matching OOXML's `w:tblGrid` and `w:tcW` units.
+*/
 /** 1px ≈ 15 twips at 96dpi (20 twips/pt × 72pt/in ÷ 96px/in). */
 const TWIPS_PER_PIXEL = 15;
 /** Minimum column width (~0.2"). */
 const MIN_CELL_WIDTH_TWIPS = 300;
 /** Minimum row height (~0.14"). */
 const MIN_ROW_HEIGHT_TWIPS = 200;
+function clampRowResizeDelta({ currentHeight, delta, minimumHeight }) {
+	return Math.max(minimumHeight - currentHeight, delta);
+}
 /** Walk up from `pmStart + 1` to find the enclosing table node. */
 function findTableAt(view, pmStart) {
 	try {
@@ -63,44 +76,60 @@ function readColumnWidthAt(view, pmStart, colIndex) {
 	if (width === void 0) return null;
 	return width;
 }
-/**
-* Bake a column-resize into the PM doc: update the table's `columnWidths`
-* attr and every cell at `colIdx` / `colIdx + 1` in every row.
-*/
-function commitColumnResize(view, opts) {
-	const { pmStart, colIdx, newLeft, newRight } = opts;
-	const found = findTableAt(view, pmStart);
-	if (!found) return;
-	const { node, tablePos } = found;
+const commitGridResize = ({ view, table: { node, tablePos }, widths, firstColumn, lastColumn }) => {
 	const tr = view.state.tr;
-	const widths = [...node.attrs["columnWidths"] ?? []];
-	widths[colIdx] = newLeft;
-	widths[colIdx + 1] = newRight;
-	tr.setNodeMarkup(tablePos, void 0, {
-		...node.attrs,
+	tr.setNodeMarkup(tablePos, void 0, mergeTableAttrs(node, {
 		columnWidths: widths,
-		tableLayout: "fixed"
-	});
+		_originalFormatting: {
+			...expectTableAttrs(node)._originalFormatting,
+			layout: "fixed"
+		}
+	}));
 	let rowOffset = tablePos + 1;
 	node.forEach((row) => {
 		let cellOffset = rowOffset + 1;
-		let cellColIdx = 0;
+		let cellColumn = 0;
 		row.forEach((cell) => {
-			const colspan = cell.attrs["colspan"] || 1;
-			if (cellColIdx === colIdx || cellColIdx === colIdx + 1) {
-				const newWidth = cellColIdx === colIdx ? newLeft : newRight;
-				tr.setNodeMarkup(tr.mapping.map(cellOffset), void 0, mergeTableCellAttrs(cell, {
-					width: newWidth,
+			const { colspan } = expectTableCellAttrs(cell);
+			if (!Number.isInteger(colspan) || colspan < 1) panic("A resized table cell must span a positive number of columns.");
+			const endColumn = cellColumn + colspan;
+			if (cellColumn <= lastColumn && endColumn > firstColumn) {
+				let width = 0;
+				for (let column = cellColumn; column < endColumn; column++) {
+					const coveredWidth = widths[column];
+					if (coveredWidth === void 0 || !Number.isFinite(coveredWidth) || coveredWidth <= 0) panic("A resized table cell must cover valid grid columns.");
+					width += coveredWidth;
+				}
+				tr.setNodeMarkup(cellOffset, void 0, mergeTableCellAttrs(cell, {
+					width,
 					widthType: "dxa",
 					colwidth: null
 				}));
 			}
 			cellOffset += cell.nodeSize;
-			cellColIdx += colspan;
+			cellColumn = endColumn;
 		});
 		rowOffset += row.nodeSize;
 	});
 	view.dispatch(tr);
+};
+/** Commit a column-pair resize, preserving each spanning cell's full grid width. */
+function commitColumnResize(view, opts) {
+	const { pmStart, colIdx, newLeft, newRight } = opts;
+	const found = findTableAt(view, pmStart);
+	if (!found) return;
+	const sourceWidths = expectTableAttrs(found.node).columnWidths;
+	if (!sourceWidths || sourceWidths[colIdx] === void 0 || sourceWidths[colIdx + 1] === void 0) return;
+	const widths = [...sourceWidths];
+	widths[colIdx] = newLeft;
+	widths[colIdx + 1] = newRight;
+	commitGridResize({
+		view,
+		table: found,
+		widths,
+		firstColumn: colIdx,
+		lastColumn: colIdx + 1
+	});
 }
 /** Bake a row-resize into the PM doc: update the target row's `height` + `heightRule`. */
 function commitRowResize(view, opts) {
@@ -122,40 +151,22 @@ function commitRowResize(view, opts) {
 	});
 	view.dispatch(tr);
 }
-/**
-* Bake a right-edge resize into the PM doc: grow only the last column.
-* Updates `columnWidths[colIdx]` and the cell at `colIdx` in every row.
-*/
+/** Commit a right-edge resize, including cells that span the resized column. */
 function commitRightEdgeResize(view, opts) {
 	const { pmStart, colIdx, newWidth } = opts;
 	const found = findTableAt(view, pmStart);
 	if (!found) return;
-	const { node, tablePos } = found;
-	const tr = view.state.tr;
-	const widths = [...node.attrs["columnWidths"] ?? []];
+	const sourceWidths = expectTableAttrs(found.node).columnWidths;
+	if (!sourceWidths || sourceWidths[colIdx] === void 0) return;
+	const widths = [...sourceWidths];
 	widths[colIdx] = newWidth;
-	tr.setNodeMarkup(tablePos, void 0, {
-		...node.attrs,
-		columnWidths: widths,
-		tableLayout: "fixed"
+	commitGridResize({
+		view,
+		table: found,
+		widths,
+		firstColumn: colIdx,
+		lastColumn: colIdx
 	});
-	let rowOffset = tablePos + 1;
-	node.forEach((row) => {
-		let cellOffset = rowOffset + 1;
-		let cellColIdx = 0;
-		row.forEach((cell) => {
-			const colspan = cell.attrs["colspan"] || 1;
-			if (cellColIdx === colIdx) tr.setNodeMarkup(tr.mapping.map(cellOffset), void 0, mergeTableCellAttrs(cell, {
-				width: newWidth,
-				widthType: "dxa",
-				colwidth: null
-			}));
-			cellOffset += cell.nodeSize;
-			cellColIdx += colspan;
-		});
-		rowOffset += row.nodeSize;
-	});
-	view.dispatch(tr);
 }
 //#endregion
-export { MIN_CELL_WIDTH_TWIPS, MIN_ROW_HEIGHT_TWIPS, TWIPS_PER_PIXEL, commitColumnResize, commitRightEdgeResize, commitRowResize, readColumnWidthAt, readColumnWidths, readRowHeight };
+export { MIN_CELL_WIDTH_TWIPS, MIN_ROW_HEIGHT_TWIPS, TWIPS_PER_PIXEL, clampRowResizeDelta, commitColumnResize, commitRightEdgeResize, commitRowResize, readColumnWidthAt, readColumnWidths, readRowHeight };

package/dist/prosemirror/tableRunIn.d.ts

@@ -9,7 +9,7 @@ import { StepMap, Transform } from "prosemirror-transform";
  * or merged, so resolving may not keep it. Pending rows or cells elsewhere in
  * the table leave that cell where it is.
  */
-declare const runInCellPending: (table: Node) => boolean;
+export declare const runInCellPending: (table: Node) => boolean;
 type RunParagraphIntoTableOptions = {
   tr: Transform;
   paragraphPos: number;
@@ -23,7 +23,7 @@ type RunParagraphIntoTableOptions = {
  * paragraph-property source it hands over, or null when it did not run in and
  * the caller keeps its own handling.
  */
-declare const runParagraphIntoTable: ({ tr, paragraphPos, styleResolver, removedMark }: RunParagraphIntoTableOptions) => {
+export declare const runParagraphIntoTable: ({ tr, paragraphPos, styleResolver, removedMark }: RunParagraphIntoTableOptions) => {
   position: number;
   map: StepMap;
   transfer: ParagraphPropertySourceTransfer;
@@ -32,14 +32,19 @@ declare const runParagraphIntoTable: ({ tr, paragraphPos, styleResolver, removed
  * Whether resolving every change in `mode` runs `paragraph` on into `next`:
  * its mark goes and `next` is a table.
  */
-declare const runsIntoFollowingTable: (paragraph: Node, next: Node | null | undefined, mode: "accept" | "reject") => boolean;
+type RunsIntoFollowingTableOptions = {
+  parent: Node;
+  index: number;
+  mode: "accept" | "reject";
+};
+export declare const runsIntoFollowingTable: ({ parent, index, mode }: RunsIntoFollowingTableOptions) => boolean;
 /**
  * Before every change in a story is resolved: run each paragraph whose mark
  * goes and that sits right before a table on into that table. Returns each
  * paragraph that took words (its position after the step count given) and
  * the paragraph-property sources handed over.
  */
-declare const runParagraphsIntoTables: (tr: Transform, mode: "accept" | "reject", styleResolver: RunStyleResolver | null) => {
+export declare const runParagraphsIntoTables: (tr: Transform, mode: "accept" | "reject", styleResolver: RunStyleResolver | null) => {
   targets: {
     position: number;
     step: number;
@@ -48,4 +53,4 @@ declare const runParagraphsIntoTables: (tr: Transform, mode: "accept" | "reject"
   transfers: ParagraphPropertySourceTransfer[];
 };
 //#endregion
-export { runInCellPending, runParagraphIntoTable, runParagraphsIntoTables, runsIntoFollowingTable };
+export {};

package/dist/prosemirror/tableRunIn.js

@@ -1,10 +1,12 @@
 import { getProseParagraphPropertySourceToken, recreateProseNodeWithParagraphPropertySource } from "../docx/paragraphPropertySource.js";
 import { expectParagraphAttrs } from "./attrs/index.js";
+import { paragraphRemainsOf } from "./keptRangeBoundaries.js";
 import { rebaseParagraphRuns } from "./rebaseParagraphRunFormatting.js";
 import { paragraphRunStyleContext } from "./runStyleFormatting.js";
-import { holdsNoContent } from "./zeroWidthAnchors.js";
+import { paragraphContentOf } from "./zeroWidthAnchors.js";
 import { Fragment, Slice } from "prosemirror-model";
 import { ReplaceAroundStep, StepMap } from "prosemirror-transform";
+import { paragraphMarkOutcome } from "@stll/docx-core/ops";
 //#region src/prosemirror/tableRunIn.ts
 /**
 * A paragraph whose mark goes, right before a table.
@@ -57,6 +59,7 @@ const runInTarget = (doc, tablePos) => {
 		node
 	} : null;
 };
+const paragraphAfterContentRemoval = (paragraph, removedMark) => removedMark ? paragraph.copy(Fragment.fromArray(paragraph.children.filter((child) => !removedMark.isInSet(child.marks)))) : paragraph;
 /**
 * Run the paragraph at `paragraphPos` on into the table right after it.
 * Returns where the paragraph that took its words now starts and the
@@ -67,7 +70,9 @@ const runParagraphIntoTable = ({ tr, paragraphPos, styleResolver, removedMark })
 	const paragraph = tr.doc.nodeAt(paragraphPos);
 	if (paragraph?.type.name !== "paragraph") return null;
 	if (expectParagraphAttrs(paragraph)._sectionProperties !== void 0) return null;
-	if (holdsNoContent(removedMark ? paragraph.copy(Fragment.fromArray(paragraph.children.filter((child) => !removedMark.isInSet(child.marks)))) : paragraph)) return null;
+	const left = paragraphAfterContentRemoval(paragraph, removedMark);
+	const remains = paragraphRemainsOf(left);
+	if (!paragraphContentOf(left) && (remains.blocks.length > 0 || remains.comments.length === 0)) return null;
 	const tablePos = paragraphPos + paragraph.nodeSize;
 	const target = runInTarget(tr.doc, tablePos);
 	if (!target) return null;
@@ -113,11 +118,38 @@ const markGoes = (paragraph, mode) => {
 	if (!mark) return false;
 	return (mark.kind === "ins" || mark.kind === "moveTo") !== (mode === "accept");
 };
-/**
-* Whether resolving every change in `mode` runs `paragraph` on into `next`:
-* its mark goes and `next` is a table.
-*/
-const runsIntoFollowingTable = (paragraph, next, mode) => paragraph.type.name === "paragraph" && next?.type.spec["tableRole"] === "table" && markGoes(paragraph, mode);
+const runsIntoFollowingTable = ({ parent, index, mode }) => {
+	const paragraph = parent.child(index);
+	const next = parent.maybeChild(index + 1);
+	if (paragraph.type.name !== "paragraph" || next?.type.spec["tableRole"] !== "table" || !markGoes(paragraph, mode)) return false;
+	const remains = paragraphRemainsOf(paragraph);
+	const holdsContent = paragraphContentOf(paragraph);
+	const needsCommentHost = !holdsContent && remains.blocks.length === 0 && remains.comments.length > 0;
+	const removedMark = paragraph.type.schema.marks[mode === "accept" ? "deletion" : "insertion"];
+	let hasPrecedingCommentHost = false;
+	for (let previousIndex = needsCommentHost ? index - 1 : -1; previousIndex >= 0; previousIndex -= 1) {
+		const previous = parent.child(previousIndex);
+		if (previous.type.name !== "paragraph") break;
+		if (!markGoes(previous, mode) || expectParagraphAttrs(previous)._sectionProperties !== void 0) {
+			hasPrecedingCommentHost = true;
+			break;
+		}
+		const retained = paragraphAfterContentRemoval(previous, removedMark);
+		if (paragraphContentOf(retained)) break;
+		if (paragraphRemainsOf(retained).blocks.length > 0) {
+			hasPrecedingCommentHost = true;
+			break;
+		}
+	}
+	return paragraphMarkOutcome({
+		follows: "table",
+		holdsContent,
+		markWasAdded: expectParagraphAttrs(paragraph).pPrMark?.kind === "ins" || expectParagraphAttrs(paragraph).pPrMark?.kind === "moveTo",
+		containerStillEndsWithParagraph: false,
+		followingTableCanReceiveRunIn: expectParagraphAttrs(paragraph)._sectionProperties === void 0 && !runInCellPending(next),
+		needsFollowingCommentHost: needsCommentHost && !hasPrecedingCommentHost
+	}).kind === "run-in";
+};
 /**
 * Before every change in a story is resolved: run each paragraph whose mark
 * goes and that sits right before a table on into that table. Returns each
@@ -134,8 +166,11 @@ const runParagraphsIntoTables = (tr, mode, styleResolver) => {
 		let candidate = null;
 		tr.doc.descendants((node, pos, parent, index) => {
 			if (node.type.name !== "paragraph") return !node.isTextblock;
-			const next = parent?.maybeChild(index + 1);
-			if (runsIntoFollowingTable(node, next, mode) && !tried.has(pos)) candidate = pos;
+			if (parent && runsIntoFollowingTable({
+				parent,
+				index,
+				mode
+			}) && !tried.has(pos)) candidate = pos;
 			return false;
 		});
 		if (candidate === null) return {

package/dist/prosemirror/textBoxAnchorAttrs.d.ts

@@ -3,7 +3,6 @@ import { ReadProseMirrorAttrsResult } from "../internal/prosemirrorAttrBoundary.
 import "./attrs/index.js";
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/textBoxAnchorAttrs.d.ts
-declare const readTextBoxAnchorAttrs: (node: Node) => ReadProseMirrorAttrsResult<TextBoxAnchorAttrs>;
-declare const expectTextBoxAnchorAttrs: (node: Node) => TextBoxAnchorAttrs;
-//#endregion
-export { expectTextBoxAnchorAttrs, readTextBoxAnchorAttrs };
+export declare const readTextBoxAnchorAttrs: (node: Node) => ReadProseMirrorAttrsResult<TextBoxAnchorAttrs>;
+export declare const expectTextBoxAnchorAttrs: (node: Node) => TextBoxAnchorAttrs;
+//#endregion

package/dist/prosemirror/textBoxAnchorAttrs.js

@@ -25,7 +25,10 @@ const expectTextBoxAnchorAttrs = (node) => {
 	const cached = attrsCache.get(node);
 	if (cached) return cached;
 	const result = readTextBoxAnchorAttrs(node);
-	if (!result.ok) panic(`Invalid ProseMirror text box anchor attrs:\n${result.issues.map((issue) => `${issue.path}: ${issue.message}`).join("\n")}`);
+	if (!result.ok) {
+		const details = result.issues.map((issue) => `${issue.path}: ${issue.message}`).join("\n");
+		panic(`Invalid ProseMirror text box anchor attrs:\n${details}`);
+	}
 	attrsCache.set(node, result.value);
 	return result.value;
 };