@openleaf-editor/plugins-table 0.1.0-beta.3 → 0.1.0-beta.5

package/README.md

@@ -67,6 +67,42 @@ Without that, every remaining column inherited the previous `<col>`'s width and
 class. Column resize still patches widths onto the same elements, so the two
 paths do not fight.
 
+Merge and split keep that contract too. A merged cell's `colwidth` is one
+entry per column it covers — the concatenation of those columns' widths, filled
+from other cells in the column and then from the stored colgroup, never folded
+into a single number — and `scope` follows the new span: a header that covers
+two columns is `scope="colgroup"`, and a body cell that still carried `scope`
+from an earlier header conversion has it cleared. Split writes each entry back
+onto the cell that covers that column.
+
+Inserting a row or column copies the neighbour cell's alignment and background
+so the new cells look like the ones the author was in. It does not copy `class`
+(often a band the author wanted on one row), `scope` (owned by the header pass
+above), or — on a new column — `colwidth`, because a new column is an unmeasured
+`<col>` and stamping the neighbour's width would make the next resize fight it.
+A body row inserted below a header copies from a body neighbour of the same
+type, not from the header's chrome.
+
+## Nested tables
+
+A cell may contain a table — `table_cell` is `block+`, and Insert table inside a
+cell is how you make one. Two editing rules follow from that:
+
+- **Column resize.** Dragging a column border targets the table whose border the
+  pointer is on. When the pointer sits on an outer column edge that crosses a
+  nested table, the outer grid wins, so parent column widths can be restored
+  without first leaving the inner table.
+- **Paste.** A whole table pasted at a text caret inside a cell is inserted as a
+  nested table, and it keeps the table's own attributes — caption, colgroup,
+  header and footer row counts, `border`, `class`. That is true of external HTML
+  (a browser, Word, or Excel table, which arrives as a closed table) and of an
+  internal copy of every cell (which arrives as that same table node, open by
+  one). Loose cells pasted at a text caret are wrapped in a new table and nested
+  the same way; a copied rectangle is not a table, so it does not inherit a
+  caption it did not carry. A cell selection still maps pasted cells onto the
+  selected rectangle. In no case does a caret-paste rewrite `colspan` on cells
+  the author did not select.
+
 ## License
 
 Apache-2.0.
@@ -83,9 +119,9 @@ the ones you want in the element's `toolbar` attribute:
 | `rowProperties` | Row properties dialog |
 | `cellProperties` | Cell properties dialog |
 | `tableCaption` | Caption dialog |
-| `addRowBefore`, `addRowAfter`, `deleteRow` | Row commands. They keep `headerRows` / `footerRows` in step so `<thead>` and `<tfoot>` stay on the header and footer rows the author actually has. |
-| `addColumnBefore`, `addColumnAfter`, `deleteColumn` | Column commands |
-| `mergeCells`, `splitCell` | Cell merge and split |
+| `addRowBefore`, `addRowAfter`, `deleteRow` | Row commands. They keep `headerRows` / `footerRows` in step so `<thead>` and `<tfoot>` stay on the header and footer rows the author actually has. A new row copies the neighbour cell's alignment, background, and `colwidth`. |
+| `addColumnBefore`, `addColumnAfter`, `deleteColumn` | Column commands. A new column copies alignment and background, not `colwidth`. |
+| `mergeCells`, `splitCell` | Cell merge and split. They keep per-column `colwidth` and rewrite `scope` for the new span. |
 | `toggleHeaderRow` | Promote or demote the header row |
 | `deleteTable` | Delete the whole table |
 

package/dist/commands.d.ts

@@ -6,6 +6,13 @@
  * delete also reindex the stored colgroup here: the upstream commands only move
  * cells, and `colgroupFromCellWidths` never runs unless a cell already has
  * `colwidth`.
+ *
+ * `mergeCells` and `splitCell` stay the stock commands. This file wraps them
+ * so that after they run, `colwidth` is one entry per covered column (the
+ * same array `colgroupFromCellWidths` already walks) and `applyCellScope`
+ * sees the new span. The colgroup sync plugin does the same repair for a
+ * stock `mergeCells` dispatched from elsewhere, so the two paths cannot
+ * disagree.
  */
 import type { Node, ResolvedPos } from 'prosemirror-model';
 import type { Command, EditorState } from 'prosemirror-state';
@@ -40,6 +47,8 @@ export declare const addRowAfter: Command;
 export declare const addRowBefore: Command;
 export declare const deleteRow: Command;
 export declare const toggleHeaderRow: Command;
+export declare const mergeCells: Command;
+export declare const splitCell: Command;
 export declare function selectedCellPositions(state: EditorState): number[];
 /**
  * Patch declarations onto a style attribute, validating every value written.

package/dist/commands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../src/commands.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../src/commands.ts"],"names":[],"mappings":"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"}

package/dist/commands.js

@@ -6,10 +6,17 @@
  * delete also reindex the stored colgroup here: the upstream commands only move
  * cells, and `colgroupFromCellWidths` never runs unless a cell already has
  * `colwidth`.
+ *
+ * `mergeCells` and `splitCell` stay the stock commands. This file wraps them
+ * so that after they run, `colwidth` is one entry per covered column (the
+ * same array `colgroupFromCellWidths` already walks) and `applyCellScope`
+ * sees the new span. The colgroup sync plugin does the same repair for a
+ * stock `mergeCells` dispatched from elsewhere, so the two paths cannot
+ * disagree.
  */
 import { canInsert, isNodeActive, parseDeclarations, safeColor, safeTableStyleValue, serializeDeclarations, } from '@openleaf-editor/core';
 import { Plugin, TextSelection } from 'prosemirror-state';
-import { addColumnAfter as addColumnAfterRaw, addColumnBefore as addColumnBeforeRaw, addRowAfter as addRowAfterRaw, addRowBefore as addRowBeforeRaw, CellSelection, deleteColumn as deleteColumnRaw, deleteRow as deleteRowRaw, TableMap, toggleHeaderRow as toggleHeaderRowRaw, } from 'prosemirror-tables';
+import { addColumnAfter as addColumnAfterRaw, addColumnBefore as addColumnBeforeRaw, addRowAfter as addRowAfterRaw, addRowBefore as addRowBeforeRaw, CellSelection, deleteColumn as deleteColumnRaw, deleteRow as deleteRowRaw, mergeCells as mergeCellsRaw, splitCell as splitCellRaw, TableMap, toggleHeaderRow as toggleHeaderRowRaw, } from 'prosemirror-tables';
 export function inTable(state) {
     return isNodeActive(state, 'table');
 }
@@ -56,7 +63,39 @@ export function insertTable(rows = 3, cols = 3) {
     };
 }
 /**
- * Rewrite header cell `scope` for the table the selection is in.
+ * The `scope` this header should carry, given where it sits and how far it spans.
+ *
+ * Axis is the rule `applyCellScope` has always used: the first row, and every
+ * header that is not the row-opening cell, heads a column. `colspan` / `rowspan`
+ * then promote that axis to the HTML group tokens — a two-column header is
+ * `colgroup`, not `col`, which is what a screen reader needs to hear.
+ */
+function expectedHeaderScope(rowIndex, cellIndex, colspan, rowspan) {
+    const axis = rowIndex === 0 || cellIndex > 0 ? 'col' : 'row';
+    if (axis === 'col' && colspan > 1)
+        return 'colgroup';
+    if (axis === 'row' && rowspan > 1)
+        return 'rowgroup';
+    return axis;
+}
+function scopeOf(node) {
+    const scope = node.attrs['scope'];
+    return scope === null || scope === undefined || scope === '' ? null : String(scope);
+}
+function scopeSpanMismatch(current, expected) {
+    return ((current === 'col' && expected === 'colgroup') ||
+        (current === 'colgroup' && expected === 'col') ||
+        (current === 'row' && expected === 'rowgroup') ||
+        (current === 'rowgroup' && expected === 'row'));
+}
+/**
+ * Rewrite header cell `scope` for a table.
+ *
+ * `fillMissing` is how insert and toggle-header give a new `<th>` the same
+ * `scope` `insertTable` uses. Merge and split already have a scope, just the
+ * wrong one for the new span, so the colgroup sync plugin calls this with
+ * `fillMissing: false` and only repairs contradictions — otherwise a keystroke
+ * inside a table would invent `scope` on headers the author had left bare.
  *
  * The selection is captured and restored around the rewrite. Every change here
  * is a `setNodeMarkup`, which replaces the cell node, and mapping a text
@@ -65,21 +104,23 @@ export function insertTable(rows = 3, cols = 3) {
  * out of the cell the author was editing, so the next table command found no
  * cell and did nothing at all.
  */
-function applyCellScope(tr) {
+function applyCellScope(tr, tablePos, fillMissing = true) {
     const header = tr.doc.type.schema.nodes['table_header'];
     const cell = tr.doc.type.schema.nodes['table_cell'];
     if (!header || !cell)
         return tr;
-    let tablePos = -1;
-    for (let depth = tr.selection.$from.depth; depth > 0; depth -= 1) {
-        if (tr.selection.$from.node(depth).type.spec['tableRole'] === 'table') {
-            tablePos = tr.selection.$from.before(depth);
-            break;
+    let pos = tablePos ?? -1;
+    if (pos < 0) {
+        for (let depth = tr.selection.$from.depth; depth > 0; depth -= 1) {
+            if (tr.selection.$from.node(depth).type.spec['tableRole'] === 'table') {
+                pos = tr.selection.$from.before(depth);
+                break;
+            }
         }
     }
-    if (tablePos < 0)
+    if (pos < 0)
         return tr;
-    const table = tr.doc.nodeAt(tablePos);
+    const table = tr.doc.nodeAt(pos);
     if (!table)
         return tr;
     // Only a plain text selection needs restoring: CellSelection maps itself and
@@ -87,22 +128,28 @@ function applyCellScope(tr) {
     const restore = tr.selection instanceof TextSelection ? tr.selection.from : null;
     const stepsBefore = tr.steps.length;
     table.forEach((row, rowOffset, rowIndex) => {
-        const rowPos = tablePos + 1 + rowOffset;
+        const rowPos = pos + 1 + rowOffset;
         row.forEach((cellNode, cellOffset, cellIndex) => {
-            const pos = rowPos + 1 + cellOffset;
-            if (cellNode.type === cell && cellNode.attrs['scope']) {
-                tr.setNodeMarkup(pos, undefined, { ...cellNode.attrs, scope: null });
+            const cellPos = rowPos + 1 + cellOffset;
+            if (cellNode.type === cell) {
+                if (cellNode.attrs['scope']) {
+                    tr.setNodeMarkup(cellPos, undefined, { ...cellNode.attrs, scope: null });
+                }
                 return;
             }
             if (cellNode.type !== header)
                 return;
-            const scope = cellNode.attrs['scope'];
-            if (scope !== null && scope !== undefined && scope !== '')
+            const expected = expectedHeaderScope(rowIndex, cellIndex, cellNode.attrs['colspan'] || 1, cellNode.attrs['rowspan'] || 1);
+            const current = scopeOf(cellNode);
+            if (current === expected)
                 return;
-            tr.setNodeMarkup(pos, undefined, {
-                ...cellNode.attrs,
-                scope: rowIndex === 0 || cellIndex > 0 ? 'col' : 'row',
-            });
+            // A set `scope` is author intent — a first-row cell can still be a row
+            // header — unless the span has outgrown the token (`col` on colspan=2).
+            if (current !== null && !scopeSpanMismatch(current, expected))
+                return;
+            if (current === null && !fillMissing)
+                return;
+            tr.setNodeMarkup(cellPos, undefined, { ...cellNode.attrs, scope: expected });
         });
     });
     // Mapped through only the steps this pass added, so the caret lands where it
@@ -189,13 +236,225 @@ function applyColgroupColumnChange(tr, range, kind) {
         return;
     tr.setNodeMarkup(pos, undefined, { ...table.attrs, colgroup: next });
 }
-export const addColumnAfter = withColgroupColumns('after', withCellScope(addColumnAfterRaw));
-export const addColumnBefore = withColgroupColumns('before', withCellScope(addColumnBeforeRaw));
+/**
+ * Visual cell attributes Word/Excel authors expect a new row or column to
+ * inherit from the cell they were in.
+ *
+ * Copied: `align`, `valign`, `style` (background and padding), `bgcolor`, and
+ * — on a new *row* only — `colwidth`, so every cell in a column still carries
+ * the same stored widths the next resize will read.
+ *
+ * Not copied, on purpose:
+ * - `class` — often a band (`odd`/`even`) the author wanted on one row
+ * - `scope` / `headers` / `abbr` — identity of the source cell; `applyCellScope`
+ *   owns `scope`
+ * - `colwidth` on a new *column* — `withColgroupColumns` inserts a bare `<col>`
+ *   so later columns keep their own widths; stamping the neighbour's colwidth
+ *   onto the new cells would make the sync plugin fight that bare column
+ * - header vs body type — stock `addRow` / `addColumn` already copy the type,
+ *   and `maintainTableSections` refuses to insert into `<thead>` / `<tfoot>`
+ * - header `style` onto a body cell — the neighbour lookup requires matching
+ *   type, so a body row inserted below a header copies from the body row on
+ *   the other side, not from the header chrome
+ */
+const COPIED_CELL_ATTRS = ['align', 'valign', 'style', 'bgcolor'];
+function withCopiedCellFormatting(command) {
+    return (state, dispatch, view) => {
+        if (!dispatch)
+            return command(state, undefined, view);
+        const found = findTable(state.selection.$from);
+        const before = found ? { pos: found.pos, node: found.node } : null;
+        return command(state, (tr) => {
+            if (before)
+                copyFormattingOntoInsertedCells(tr, before);
+            dispatch(tr);
+        }, view);
+    };
+}
+function copyFormattingOntoInsertedCells(tr, before) {
+    const pos = tr.mapping.map(before.pos);
+    const after = tr.doc.nodeAt(pos);
+    if (!after || after.type.spec['tableRole'] !== 'table')
+        return;
+    const insertedRow = insertedRowIndex(before.node, after);
+    const insertedCol = insertedRow === null ? insertedColumnIndex(before.node, after) : null;
+    if (insertedRow === null && insertedCol === null)
+        return;
+    const map = TableMap.get(after);
+    after.forEach((row, rowOffset, rowIndex) => {
+        const rowPos = pos + 1 + rowOffset;
+        let col = 0;
+        row.forEach((cell, cellOffset) => {
+            const colspan = cell.attrs['colspan'] || 1;
+            const hit = insertedRow !== null ? rowIndex === insertedRow : col === insertedCol;
+            if (hit &&
+                !cell.textContent &&
+                colspan === 1 &&
+                (cell.attrs['rowspan'] || 1) === 1) {
+                const source = neighbourCell(after, map, rowIndex, col, insertedRow !== null ? 'row' : 'col', cell.type);
+                if (source) {
+                    tr.setNodeMarkup(rowPos + 1 + cellOffset, undefined, {
+                        ...cell.attrs,
+                        ...copiedCellAttrs(source, insertedRow !== null),
+                    });
+                }
+            }
+            col += colspan;
+        });
+    });
+}
+function insertedRowIndex(before, after) {
+    if (after.childCount !== before.childCount + 1)
+        return null;
+    const text = (row) => row.textContent;
+    for (let at = 0; at <= before.childCount; at += 1) {
+        let matches = true;
+        for (let i = 0; i < before.childCount; i += 1) {
+            const afterIndex = i < at ? i : i + 1;
+            if (text(before.child(i)) !== text(after.child(afterIndex))) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches)
+            return at;
+    }
+    return null;
+}
+function insertedColumnIndex(before, after) {
+    const beforeMap = TableMap.get(before);
+    const afterMap = TableMap.get(after);
+    if (afterMap.width !== beforeMap.width + 1 || afterMap.height !== beforeMap.height) {
+        return null;
+    }
+    const textAt = (table, map, row, col) => table.nodeAt(map.map[row * map.width + col] ?? 0)?.textContent ?? '';
+    for (let at = 0; at <= beforeMap.width; at += 1) {
+        let matches = true;
+        outer: for (let row = 0; row < beforeMap.height; row += 1) {
+            for (let col = 0; col < beforeMap.width; col += 1) {
+                const afterCol = col < at ? col : col + 1;
+                if (textAt(before, beforeMap, row, col) !== textAt(after, afterMap, row, afterCol)) {
+                    matches = false;
+                    break outer;
+                }
+            }
+        }
+        if (matches)
+            return at;
+    }
+    return null;
+}
+function neighbourCell(table, map, row, col, axis, type) {
+    const prefer = axis === 'row' ? (row > 0 ? -1 : 1) : col > 0 ? -1 : 1;
+    const limit = axis === 'row' ? map.height : map.width;
+    for (const dir of [prefer, -prefer]) {
+        const at = (axis === 'row' ? row : col) + dir;
+        if (at < 0 || at >= limit)
+            continue;
+        const index = axis === 'row' ? at * map.width + col : row * map.width + at;
+        const node = table.nodeAt(map.map[index] ?? 0);
+        if (node && node.type === type)
+            return node;
+    }
+    return null;
+}
+function copiedCellAttrs(source, includeColwidth) {
+    const next = {};
+    for (const key of COPIED_CELL_ATTRS) {
+        if (source.attrs[key] != null)
+            next[key] = source.attrs[key];
+    }
+    if (includeColwidth &&
+        source.attrs['colwidth'] != null &&
+        (source.attrs['colspan'] || 1) === 1) {
+        // A spanning neighbour holds one width per column it covers. Copying that
+        // array onto a colspan=1 cell would disagree with the schema's length check.
+        next['colwidth'] = source.attrs['colwidth'];
+    }
+    return next;
+}
+/**
+ * Snapshot each column's width before a merge or split, then write those
+ * widths back onto the cells the command produced.
+ *
+ * Stock `mergeCells` grows `colwidth` with `addColSpan`, which inserts `0` for
+ * every newly covered column rather than taking the other cell's width. Stock
+ * `splitCell` then treats `0` as "no width". The array is one entry per
+ * covered column — the same invariant `colgroupFromCellWidths` already
+ * documents — so "sum" here means concatenate, not fold into a single number.
+ * Folding would make the next resize fight the colgroup: the spanning cell
+ * would report one width for every column it covers.
+ *
+ * Missing entries are filled from another cell in the same column, then from
+ * the stored colgroup. A column nobody knows a width for stays unknown: we do
+ * not invent one, and we do not divide a neighbour's width across the hole
+ * (100 and unknown is not 50/50). An odd pair such as 100 and 101 stays
+ * `[100, 101]` so a later split restores the same integers.
+ */
+function withPreservedColumnWidths(command) {
+    return (state, dispatch, view) => {
+        if (!dispatch)
+            return command(state, undefined, view);
+        const found = findTable(state.selection.$from);
+        const snapshot = found ? { pos: found.pos, widths: columnWidths(found.node) } : null;
+        return command(state, (tr) => {
+            if (snapshot) {
+                const pos = tr.mapping.map(snapshot.pos);
+                const table = tr.doc.nodeAt(pos);
+                if (table?.type.spec['tableRole'] === 'table') {
+                    writeColwidthOntoCells(tr, pos, table, snapshot.widths);
+                }
+            }
+            dispatch(tr);
+        }, view);
+    };
+}
+function writeColwidthOntoCells(tr, tablePos, table, widths, spanningOnly = false) {
+    const map = TableMap.get(table);
+    const seen = new Set();
+    for (let i = 0; i < map.map.length; i += 1) {
+        const rel = map.map[i] ?? 0;
+        if (seen.has(rel))
+            continue;
+        seen.add(rel);
+        const cell = table.nodeAt(rel);
+        if (!cell)
+            continue;
+        const colspan = cell.attrs['colspan'] || 1;
+        if (spanningOnly && colspan < 2)
+            continue;
+        const col = i % map.width;
+        const next = colwidthForSpan(widths, col, col + colspan);
+        const current = cell.attrs['colwidth'];
+        // Incomplete knowledge (`null`) is not a reason to wipe a partial array
+        // stock merge left behind. Only write when every covered column is known.
+        if (next === null || sameColwidth(current, next))
+            continue;
+        tr.setNodeMarkup(tablePos + 1 + rel, undefined, { ...cell.attrs, colwidth: next });
+    }
+}
+function colwidthForSpan(widths, left, right) {
+    const slice = widths.slice(left, right);
+    if (slice.length === 0 || slice.some((width) => width == null))
+        return null;
+    return slice;
+}
+function sameColwidth(a, b) {
+    if (a == null && b == null)
+        return true;
+    if (a == null || b == null)
+        return false;
+    return a.length === b.length && a.every((width, i) => width === b[i]);
+}
+export const addColumnAfter = withColgroupColumns('after', withCellScope(withCopiedCellFormatting(addColumnAfterRaw)));
+export const addColumnBefore = withColgroupColumns('before', withCellScope(withCopiedCellFormatting(addColumnBeforeRaw)));
 export const deleteColumn = withColgroupColumns('delete', deleteColumnRaw);
-export const addRowAfter = withCellScope(maintainTableSections(addRowAfterRaw, 'after'));
-export const addRowBefore = withCellScope(maintainTableSections(addRowBeforeRaw, 'before'));
+export const addRowAfter = withCellScope(withCopiedCellFormatting(maintainTableSections(addRowAfterRaw, 'after')));
+export const addRowBefore = withCellScope(withCopiedCellFormatting(maintainTableSections(addRowBeforeRaw, 'before')));
 export const deleteRow = withCellScope(maintainTableSections(deleteRowRaw, 'delete'));
 export const toggleHeaderRow = withCellScope(toggleHeaderRowRaw);
+export const mergeCells = withCellScope(withPreservedColumnWidths(mergeCellsRaw));
+export const splitCell = withCellScope(withPreservedColumnWidths(splitCellRaw));
 /**
  * Keep `headerRows` / `footerRows` attached to the rows that actually live in
  * those sections.
@@ -637,40 +896,57 @@ function setWidth(col, width) {
 export function setTableColgroup(widths) {
     return setTableAttrs({ colgroup: colgroupHtmlFromWidths(widths) });
 }
-function colgroupFromCellWidths(table) {
+/**
+ * One width per column, from cells first, then the stored colgroup.
+ *
+ * The first row is not enough: merging it is exactly when its `colwidth`
+ * becomes `[100, 0]`, and the other rows still hold the second column's 200.
+ * Falling through to the colgroup covers the case where the width never lived
+ * on a cell at all — inherited `<col width>` furniture — so a later resize
+ * does not invent zeros that then blank those `<col>`s.
+ */
+function columnWidths(table) {
     const map = TableMap.get(table);
-    const widths = [];
-    let any = false;
-    // A cell spanning several columns appears in the map once per column it
-    // covers, and its `colwidth` holds one entry per covered column. `offset`
-    // tracks how far into that run this column is: reading entry 0 every time
-    // wrote the first column's width to every <col> the cell spans, so resizing a
-    // later column of a merged cell corrupted the stored colgroup.
-    let previous = -1;
-    let offset = 0;
-    for (let col = 0; col < map.width; col += 1) {
-        const pos = map.map[col] ?? 0;
-        if (pos === previous)
-            offset += 1;
-        else {
-            previous = pos;
-            offset = 0;
-        }
-        const cell = table.nodeAt(pos);
-        const colwidth = cell?.attrs['colwidth'];
-        const width = colwidth?.[offset];
-        if (width) {
-            widths.push(String(width));
-            any = true;
-        }
-        else {
-            widths.push('');
+    const widths = Array.from({ length: map.width }, () => null);
+    for (let row = 0; row < map.height; row += 1) {
+        let previous = -1;
+        let offset = 0;
+        for (let col = 0; col < map.width; col += 1) {
+            const pos = map.map[row * map.width + col] ?? 0;
+            if (pos === previous)
+                offset += 1;
+            else {
+                previous = pos;
+                offset = 0;
+            }
+            if (widths[col] != null)
+                continue;
+            const cell = table.nodeAt(pos);
+            const width = cell?.attrs['colwidth']?.[offset];
+            if (typeof width === 'number' && width > 0)
+                widths[col] = width;
         }
     }
+    const fromGroup = widthsFromColgroup(table.attrs['colgroup'], map.width);
+    for (let col = 0; col < map.width; col += 1) {
+        if (widths[col] != null)
+            continue;
+        const raw = fromGroup[col];
+        if (!raw)
+            continue;
+        const parsed = Number.parseInt(raw, 10);
+        if (parsed > 0)
+            widths[col] = parsed;
+    }
+    return widths;
+}
+function colgroupFromWidths(table, widths) {
+    if (widths.every((width) => width == null))
+        return null;
     // Patched onto whatever the table already stored, for the same reason the
     // properties dialog patches: a column resize must not cost an inherited
     // colgroup its class or its other attributes.
-    return any ? colgroupHtmlWithWidths(table.attrs['colgroup'], widths) : null;
+    return colgroupHtmlWithWidths(table.attrs['colgroup'], widths.map((width) => (width != null ? String(width) : '')));
 }
 /**
  * What `colgroupFromCellWidths` last said about a given table node.
@@ -690,16 +966,6 @@ function colgroupFromCellWidths(table) {
  * has moved past is collectable.
  */
 const colgroupForNode = new WeakMap();
-function cachedColgroupFromCellWidths(table) {
-    const known = colgroupForNode.get(table);
-    // `null` is a real answer -- "this table has no resized columns" -- so the
-    // miss test is `undefined`, not falsiness.
-    if (known !== undefined)
-        return known;
-    const computed = colgroupFromCellWidths(table);
-    colgroupForNode.set(table, computed);
-    return computed;
-}
 /**
  * Keep `<colgroup>` in lockstep with column resizing.
  *
@@ -724,13 +990,27 @@ export function colgroupSyncPlugin() {
                 // Cached on the node: a transaction elsewhere in the document reuses
                 // every table node it did not touch, so an untouched table answers from
                 // the map instead of rebuilding its TableMap and reparsing its colgroup.
-                const next = cachedColgroupFromCellWidths(node);
-                if (next === null)
-                    return false;
-                if (next === node.attrs['colgroup'])
+                // `null` is a real answer -- "this table has no resized columns" -- so
+                // the miss test is `undefined`, not falsiness.
+                const known = colgroupForNode.get(node);
+                if (known !== undefined)
                     return false;
-                tr ??= state.tr;
-                tr.setNodeMarkup(pos, undefined, { ...node.attrs, colgroup: next });
+                // One walk for widths, then the existing write helpers no-op when the
+                // cell already agrees. A separate "does this need repair?" pass was a
+                // second copy of the same loop.
+                const widths = columnWidths(node);
+                const next = colgroupFromWidths(node, widths);
+                colgroupForNode.set(node, next);
+                const working = tr ?? state.tr;
+                const stepsBefore = working.steps.length;
+                writeColwidthOntoCells(working, pos, node, widths, true);
+                applyCellScope(working, pos, false);
+                const current = working.doc.nodeAt(pos) ?? node;
+                if (next !== null && next !== current.attrs['colgroup']) {
+                    working.setNodeMarkup(pos, undefined, { ...current.attrs, colgroup: next });
+                }
+                if (working.steps.length > stepsBefore)
+                    tr = working;
                 return false;
             });
             return tr;