@doxi/core 0.11.0

package/dist/commands/table-commands.js

@@ -0,0 +1,884 @@
+import { Fragment } from '../model/fragment.js';
+import { DxNode } from '../model/node.js';
+import { resolve } from '../model/position.js';
+import { Slice } from '../model/slice.js';
+import { tableGrid } from '../model/table-grid.js';
+import { CellSelection } from '../state/cell-selection.js';
+import { TextSelection } from '../state/text-selection.js';
+import { AttrStep } from '../transform/attr-step.js';
+import { ReplaceStep } from '../transform/replace-step.js';
+/**
+ * Table commands.
+ *
+ * The default schema declares:
+ *   table:      { content: 'table_row+', group: 'block', isolating: true }
+ *   table_row:  { content: 'table_cell+', isolating: true }
+ *   table_cell: { content: 'block+', isolating: true,
+ *                 attrs: { widthPx: number|null, background: string|null } }
+ *
+ * Every command sets `selectionOverride` so the cursor lands on an editable
+ * inline position after the structural reshuffle.
+ */
+function setOverride(tr, pos) {
+    ;
+    tr.selectionOverride =
+        new TextSelection(pos, pos);
+}
+function findTableContext(rp) {
+    let cellDepth = -1;
+    for (let d = rp.depth; d >= 1; d--) {
+        if (rp.node(d).type.name === 'table_cell') {
+            cellDepth = d;
+            break;
+        }
+    }
+    if (cellDepth < 2)
+        return null;
+    const rowDepth = cellDepth - 1;
+    const tableDepth = cellDepth - 2;
+    if (tableDepth < 1)
+        return null;
+    const table = rp.node(tableDepth);
+    if (table.type.name !== 'table')
+        return null;
+    const rowIdx = rp.index(rowDepth);
+    const colIdx = rp.index(cellDepth);
+    return {
+        tableDepth,
+        tableStart: rp.before(tableDepth),
+        table,
+        rowIdx,
+        colIdx,
+    };
+}
+function makeEmptyCell(schema) {
+    return schema.node('table_cell', null, [schema.node('paragraph', null)]);
+}
+function makeEmptyRow(schema, cols) {
+    const cells = [];
+    for (let i = 0; i < cols; i++)
+        cells.push(makeEmptyCell(schema));
+    return schema.node('table_row', null, cells);
+}
+function rowCellCount(row) {
+    return row.content.childCount;
+}
+/**
+ * Insert a fresh `rows × cols` table at the cursor.
+ *
+ * If the cursor's top-level block (in its container) is an EMPTY paragraph,
+ * REPLACE that paragraph with the table. Otherwise INSERT the table as the
+ * next sibling of that block.
+ *
+ * Each cell starts with a single empty paragraph. Cursor lands inside the
+ * first cell's paragraph (parentOffset 0).
+ *
+ * Returns false if rows < 1 or cols < 1, if the schema doesn't carry
+ * table / table_row / table_cell, or if the cursor isn't inside any
+ * top-level block.
+ */
+export function insertTable(schema, rows, cols) {
+    return (state, dispatch) => {
+        if (rows < 1 || cols < 1)
+            return false;
+        if (!schema.nodes.table || !schema.nodes.table_row || !schema.nodes.table_cell) {
+            return false;
+        }
+        const rp = resolve(state.doc, state.selection.from);
+        if (rp.depth < 1)
+            return false;
+        // Build the new table.
+        const newRows = [];
+        for (let r = 0; r < rows; r++)
+            newRows.push(makeEmptyRow(schema, cols));
+        const table = schema.node('table', null, newRows);
+        // Find the cursor's containing block in its container. We want depth 1
+        // unless we're inside a cell-like container (table_cell), in which case
+        // we operate on the cell's child block. Mirrors findTopBlockDepth, but
+        // we keep the logic local here to avoid pulling helpers that could
+        // confuse the table-vs-cell case (we never insert nested tables in v0.3b
+        // but the cell case still must work for completeness).
+        let topD = 1;
+        for (let d = rp.depth; d >= 1; d--) {
+            const parent = rp.node(d - 1);
+            const parentSpec = parent.type.spec;
+            if (parent.type.name === 'doc' || parentSpec.isolating === true) {
+                topD = d;
+                break;
+            }
+        }
+        const block = rp.node(topD);
+        if (!dispatch)
+            return true;
+        const isEmptyParagraph = block.type.name === 'paragraph' && block.content.size === 0;
+        let blockStart;
+        let blockEnd;
+        let slice;
+        if (isEmptyParagraph) {
+            blockStart = rp.before(topD);
+            blockEnd = rp.after(topD);
+            slice = new Slice(Fragment.from([table]), 0, 0);
+        }
+        else {
+            const sibling = rp.after(topD);
+            blockStart = sibling;
+            blockEnd = sibling;
+            slice = new Slice(Fragment.from([table]), 0, 0);
+        }
+        const tr = state.tr.step(new ReplaceStep(blockStart, blockEnd, slice));
+        // Cursor lands in first cell. The table [open] is at `blockStart`.
+        // Layout inside table: table[open]=blockStart, row[open]=blockStart+1,
+        // cell[open]=blockStart+2, paragraph[open]=blockStart+3, content=blockStart+4.
+        setOverride(tr, blockStart + 4);
+        dispatch(tr);
+        return true;
+    };
+}
+/** Insert a fresh empty row above the cursor's row. */
+export function addRowAbove() {
+    return (state, dispatch) => {
+        const rp = resolve(state.doc, state.selection.from);
+        const ctx = findTableContext(rp);
+        if (!ctx)
+            return false;
+        if (!dispatch)
+            return true;
+        return spliceRow(state, dispatch, rp, ctx, ctx.rowIdx, 'above');
+    };
+}
+/** Insert a fresh empty row below the cursor's row. */
+export function addRowBelow() {
+    return (state, dispatch) => {
+        const rp = resolve(state.doc, state.selection.from);
+        const ctx = findTableContext(rp);
+        if (!ctx)
+            return false;
+        if (!dispatch)
+            return true;
+        return spliceRow(state, dispatch, rp, ctx, ctx.rowIdx + 1, 'below');
+    };
+}
+function spliceRow(state, dispatch, _rp, ctx, insertAt, direction) {
+    const cols = rowCellCount(ctx.table.content.child(ctx.rowIdx));
+    const newRow = makeEmptyRow(state.schema, cols);
+    const newRows = [];
+    for (let i = 0; i < ctx.table.content.childCount; i++) {
+        if (i === insertAt)
+            newRows.push(newRow);
+        newRows.push(ctx.table.content.child(i));
+    }
+    if (insertAt === ctx.table.content.childCount)
+        newRows.push(newRow);
+    const newTable = state.schema.node('table', ctx.table.attrs, newRows);
+    const slice = new Slice(Fragment.from([newTable]), 0, 0);
+    const tableEnd = ctx.tableStart + ctx.table.nodeSize;
+    const tr = state.tr.step(new ReplaceStep(ctx.tableStart, tableEnd, slice));
+    // Cursor stays where it was. When inserting above, the cursor's row shifted
+    // down by one row's worth of positions; when inserting below, the cursor
+    // is unaffected.
+    let cursor = state.selection.from;
+    if (direction === 'above') {
+        cursor += newRow.nodeSize;
+    }
+    setOverride(tr, cursor);
+    dispatch(tr);
+    return true;
+}
+/** Insert a fresh empty cell at the cursor's column index in every row. */
+export function addColumnLeft() {
+    return (state, dispatch) => {
+        const rp = resolve(state.doc, state.selection.from);
+        const ctx = findTableContext(rp);
+        if (!ctx)
+            return false;
+        if (!dispatch)
+            return true;
+        return spliceColumn(state, dispatch, ctx, ctx.colIdx, state.selection.from, 'left');
+    };
+}
+/** Insert a fresh empty cell to the right of the cursor's column in every row. */
+export function addColumnRight() {
+    return (state, dispatch) => {
+        const rp = resolve(state.doc, state.selection.from);
+        const ctx = findTableContext(rp);
+        if (!ctx)
+            return false;
+        if (!dispatch)
+            return true;
+        return spliceColumn(state, dispatch, ctx, ctx.colIdx + 1, state.selection.from, 'right');
+    };
+}
+function spliceColumn(state, dispatch, ctx, insertAt, cursor, direction) {
+    const newRows = [];
+    for (let r = 0; r < ctx.table.content.childCount; r++) {
+        const row = ctx.table.content.child(r);
+        const newCells = [];
+        for (let c = 0; c < row.content.childCount; c++) {
+            if (c === insertAt)
+                newCells.push(makeEmptyCell(state.schema));
+            newCells.push(row.content.child(c));
+        }
+        if (insertAt === row.content.childCount)
+            newCells.push(makeEmptyCell(state.schema));
+        newRows.push(state.schema.node('table_row', row.attrs, newCells));
+    }
+    const newTable = state.schema.node('table', ctx.table.attrs, newRows);
+    const slice = new Slice(Fragment.from([newTable]), 0, 0);
+    const tableEnd = ctx.tableStart + ctx.table.nodeSize;
+    const tr = state.tr.step(new ReplaceStep(ctx.tableStart, tableEnd, slice));
+    // The new cell has size 4 (table_cell[open], paragraph[open], paragraph[close], cell[close]).
+    // If inserted at-or-before the cursor's column, the cursor shifts by that size.
+    const newCellSize = makeEmptyCell(state.schema).nodeSize;
+    let newCursor = cursor;
+    if (direction === 'left') {
+        // insertAt === ctx.colIdx; the new cell sits before each row's existing
+        // cell at that index, so the cursor's cell shifts by newCellSize.
+        newCursor += newCellSize;
+    }
+    setOverride(tr, newCursor);
+    dispatch(tr);
+    return true;
+}
+/**
+ * Remove the row containing the cursor. Cursor lands in the next or previous
+ * row's same-column cell. If it was the only row, the whole table is replaced
+ * by an empty paragraph (cursor inside).
+ */
+export function deleteRow() {
+    return (state, dispatch) => {
+        const rp = resolve(state.doc, state.selection.from);
+        const ctx = findTableContext(rp);
+        if (!ctx)
+            return false;
+        if (!dispatch)
+            return true;
+        // Single-row table → drop the whole table.
+        if (ctx.table.content.childCount === 1) {
+            return replaceTableWithEmptyParagraph(state, dispatch, ctx);
+        }
+        const newRows = [];
+        for (let r = 0; r < ctx.table.content.childCount; r++) {
+            if (r === ctx.rowIdx)
+                continue;
+            newRows.push(ctx.table.content.child(r));
+        }
+        const newTable = state.schema.node('table', ctx.table.attrs, newRows);
+        const slice = new Slice(Fragment.from([newTable]), 0, 0);
+        const tableEnd = ctx.tableStart + ctx.table.nodeSize;
+        const tr = state.tr.step(new ReplaceStep(ctx.tableStart, tableEnd, slice));
+        // Cursor target: same column in the next row (or previous if this was the
+        // last). Compute absolute position of that cell's first inline pos in the
+        // NEW table.
+        const targetRowIdx = ctx.rowIdx < newRows.length ? ctx.rowIdx : newRows.length - 1;
+        const cursor = firstInlineOfCellAt(ctx.tableStart, newTable, targetRowIdx, ctx.colIdx);
+        setOverride(tr, cursor);
+        dispatch(tr);
+        return true;
+    };
+}
+/**
+ * Remove the column containing the cursor from every row. Cursor lands in the
+ * previous column or the next if it was the first. If it was the only column,
+ * the whole table is replaced by an empty paragraph.
+ */
+export function deleteColumn() {
+    return (state, dispatch) => {
+        const rp = resolve(state.doc, state.selection.from);
+        const ctx = findTableContext(rp);
+        if (!ctx)
+            return false;
+        if (!dispatch)
+            return true;
+        const firstRow = ctx.table.content.child(0);
+        if (firstRow.content.childCount === 1) {
+            return replaceTableWithEmptyParagraph(state, dispatch, ctx);
+        }
+        const newRows = [];
+        for (let r = 0; r < ctx.table.content.childCount; r++) {
+            const row = ctx.table.content.child(r);
+            const cells = [];
+            for (let c = 0; c < row.content.childCount; c++) {
+                if (c === ctx.colIdx)
+                    continue;
+                cells.push(row.content.child(c));
+            }
+            newRows.push(state.schema.node('table_row', row.attrs, cells));
+        }
+        const newTable = state.schema.node('table', ctx.table.attrs, newRows);
+        const slice = new Slice(Fragment.from([newTable]), 0, 0);
+        const tableEnd = ctx.tableStart + ctx.table.nodeSize;
+        const tr = state.tr.step(new ReplaceStep(ctx.tableStart, tableEnd, slice));
+        const newColCount = newRows[0].content.childCount;
+        const targetColIdx = ctx.colIdx > 0 ? ctx.colIdx - 1 : 0;
+        const clampedCol = Math.min(targetColIdx, newColCount - 1);
+        const cursor = firstInlineOfCellAt(ctx.tableStart, newTable, ctx.rowIdx, clampedCol);
+        setOverride(tr, cursor);
+        dispatch(tr);
+        return true;
+    };
+}
+/**
+ * Remove the whole table containing the cursor. The table is replaced by an
+ * empty paragraph; cursor lands inside.
+ */
+export function deleteTable() {
+    return (state, dispatch) => {
+        const rp = resolve(state.doc, state.selection.from);
+        const ctx = findTableContext(rp);
+        if (!ctx)
+            return false;
+        if (!dispatch)
+            return true;
+        return replaceTableWithEmptyParagraph(state, dispatch, ctx);
+    };
+}
+function replaceTableWithEmptyParagraph(state, dispatch, ctx) {
+    const paragraphType = state.schema.nodes.paragraph;
+    if (!paragraphType)
+        return false;
+    const para = state.schema.node('paragraph', null);
+    const slice = new Slice(Fragment.from([para]), 0, 0);
+    const tableEnd = ctx.tableStart + ctx.table.nodeSize;
+    const tr = state.tr.step(new ReplaceStep(ctx.tableStart, tableEnd, slice));
+    // Cursor inside the new paragraph: ctx.tableStart points at the [open] of
+    // the new paragraph; content starts one position later.
+    setOverride(tr, ctx.tableStart + 1);
+    dispatch(tr);
+    return true;
+}
+/**
+ * Move the selection to the first inline position of the next cell in
+ * document order. If the cursor is in the last cell of the last row, append
+ * a fresh empty row and place the cursor in its first cell — done in a
+ * single transaction so undo collapses cleanly and the selection override
+ * lines up with the new structure.
+ *
+ * Returns false when the cursor is not inside any table cell (so the keymap
+ * can fall through).
+ */
+export function tabToNextCell() {
+    return (state, dispatch) => {
+        const rp = resolve(state.doc, state.selection.from);
+        const ctx = findTableContext(rp);
+        if (!ctx)
+            return false;
+        const row = ctx.table.content.child(ctx.rowIdx);
+        const cols = rowCellCount(row);
+        const rowCount = ctx.table.content.childCount;
+        const isLastCellInRow = ctx.colIdx === cols - 1;
+        const isLastRow = ctx.rowIdx === rowCount - 1;
+        if (!dispatch)
+            return true;
+        if (!isLastCellInRow) {
+            // Move to next cell in the same row.
+            const target = firstInlineOfCellAt(ctx.tableStart, ctx.table, ctx.rowIdx, ctx.colIdx + 1);
+            const tr = state.tr;
+            setOverride(tr, target);
+            dispatch(tr);
+            return true;
+        }
+        if (!isLastRow) {
+            // Move to first cell of the next row.
+            const target = firstInlineOfCellAt(ctx.tableStart, ctx.table, ctx.rowIdx + 1, 0);
+            const tr = state.tr;
+            setOverride(tr, target);
+            dispatch(tr);
+            return true;
+        }
+        // Last cell of last row → append a new empty row in a single transaction
+        // and land the cursor in its first cell.
+        const newRow = makeEmptyRow(state.schema, cols);
+        const newRows = [];
+        for (let i = 0; i < ctx.table.content.childCount; i++) {
+            newRows.push(ctx.table.content.child(i));
+        }
+        newRows.push(newRow);
+        const newTable = state.schema.node('table', ctx.table.attrs, newRows);
+        const slice = new Slice(Fragment.from([newTable]), 0, 0);
+        const tableEnd = ctx.tableStart + ctx.table.nodeSize;
+        const tr = state.tr.step(new ReplaceStep(ctx.tableStart, tableEnd, slice));
+        const target = firstInlineOfCellAt(ctx.tableStart, newTable, rowCount, 0);
+        setOverride(tr, target);
+        dispatch(tr);
+        return true;
+    };
+}
+/**
+ * Move the selection to the first inline position of the previous cell.
+ * Returns false when the cursor is at the very first cell of the table OR
+ * not inside any cell.
+ */
+export function tabToPrevCell() {
+    return (state, dispatch) => {
+        const rp = resolve(state.doc, state.selection.from);
+        const ctx = findTableContext(rp);
+        if (!ctx)
+            return false;
+        const isFirstCellInRow = ctx.colIdx === 0;
+        const isFirstRow = ctx.rowIdx === 0;
+        if (isFirstCellInRow && isFirstRow)
+            return false;
+        if (!dispatch)
+            return true;
+        if (!isFirstCellInRow) {
+            const target = firstInlineOfCellAt(ctx.tableStart, ctx.table, ctx.rowIdx, ctx.colIdx - 1);
+            const tr = state.tr;
+            setOverride(tr, target);
+            dispatch(tr);
+            return true;
+        }
+        // First cell of a non-first row → last cell of previous row.
+        const prevRow = ctx.table.content.child(ctx.rowIdx - 1);
+        const target = firstInlineOfCellAt(ctx.tableStart, ctx.table, ctx.rowIdx - 1, rowCellCount(prevRow) - 1);
+        const tr = state.tr;
+        setOverride(tr, target);
+        dispatch(tr);
+        return true;
+    };
+}
+/**
+ * Set the `widthPx` attribute on every cell in `columnIndex` of the table
+ * whose [open] token sits at `tableStart` in the doc. Dispatches a single
+ * transaction containing one AttrStep per affected cell.
+ *
+ * Used by the column-resize pointer controller in `view/table-resize.ts`.
+ *
+ * Returns false if there's no table at `tableStart` or `columnIndex` is
+ * out of range in any row.
+ */
+export function setCellWidth(tableStart, columnIndex, widthPx) {
+    return (state, dispatch) => {
+        if (tableStart < 0 || tableStart >= state.doc.content.size)
+            return false;
+        if (columnIndex < 0)
+            return false;
+        // Locate the table node whose [open] sits at `tableStart`. The doc tree
+        // walk mirrors the AttrStep.apply boundary-resolution logic: we find the
+        // child of rp.parent whose offset === rp.parentOffset.
+        let rp;
+        try {
+            rp = resolve(state.doc, tableStart);
+        }
+        catch {
+            return false;
+        }
+        const parent = rp.parent;
+        let offset = 0;
+        let table = null;
+        for (let i = 0; i < parent.content.childCount; i++) {
+            const child = parent.content.child(i);
+            if (offset === rp.parentOffset) {
+                table = child;
+                break;
+            }
+            offset += child.nodeSize;
+        }
+        if (!table || table.type.name !== 'table')
+            return false;
+        // Validate columnIndex is in range for every row, and collect each cell's
+        // absolute [open] position in the doc.
+        const cellPositions = [];
+        // tableStart points at table[open]; row[open] starts at tableStart + 1.
+        let pos = tableStart + 1;
+        for (let r = 0; r < table.content.childCount; r++) {
+            const row = table.content.child(r);
+            if (columnIndex >= row.content.childCount)
+                return false;
+            // pos is row[open]; first cell[open] sits at pos + 1.
+            let cellPos = pos + 1;
+            for (let c = 0; c < columnIndex; c++) {
+                cellPos += row.content.child(c).nodeSize;
+            }
+            cellPositions.push(cellPos);
+            pos += row.nodeSize;
+        }
+        if (!dispatch)
+            return true;
+        let tr = state.tr;
+        for (const cellPos of cellPositions) {
+            tr = tr.step(new AttrStep(cellPos, 'widthPx', widthPx));
+        }
+        dispatch(tr);
+        return true;
+    };
+}
+/**
+ * Find the model position of the table containing the cell whose [open] sits
+ * at `cellPos`, by walking up from the resolved position. Returns the
+ * `tableStart` (absolute position of the table [open]) and the table node.
+ */
+function findTableForCellPos(doc, cellPos) {
+    // cellPos points at the cell's [open]; resolving cellPos + 1 lands us
+    // INSIDE the cell. From there, the table is 2 depths up (cell -> row -> table).
+    let rp;
+    try {
+        rp = resolve(doc, cellPos + 1);
+    }
+    catch {
+        return null;
+    }
+    // Walk up to find the table node.
+    for (let d = rp.depth; d >= 1; d--) {
+        if (rp.node(d).type.name === 'table') {
+            return { tableStart: rp.before(d), table: rp.node(d) };
+        }
+    }
+    return null;
+}
+/**
+ * Merge the cells in the current CellSelection into a single cell. The merged
+ * master is the top-left cell of the bounding rectangle; its content becomes
+ * the concatenation of every selected cell's block content (top-left first,
+ * then left-to-right, top-to-bottom). Spans are set so the master covers the
+ * original rectangle.
+ *
+ * Returns false when:
+ *   - state.selection is not a CellSelection.
+ *   - the bounding rectangle would orphan a spanned cell at its edge
+ *     (a cell's master is inside the rect but the cell extends outside,
+ *     OR a cell straddles the rect boundary).
+ *   - the rectangle is 1×1 (nothing to merge).
+ *
+ * After dispatch, the model selection becomes a TextSelection at the first
+ * inline position of the merged master cell.
+ */
+export function mergeCells() {
+    return (state, dispatch) => {
+        const sel = state.selection;
+        if (!(sel instanceof CellSelection))
+            return false;
+        // 1) Locate the containing table via the anchor cell's position.
+        const located = findTableForCellPos(state.doc, sel.anchorCell);
+        if (!located)
+            return false;
+        const { tableStart, table } = located;
+        // 2) Build the grid.
+        const grid = tableGrid(table, tableStart);
+        // 3) Map the two corner cell positions to (row, col).
+        const anchorCell = grid.byPos(sel.anchorCell);
+        const headCell = grid.byPos(sel.headCell);
+        if (!anchorCell || !headCell)
+            return false;
+        // 4) Compute the bounding rectangle, EXTENDING it to include any spanned
+        //    cells whose masters are inside the rect but whose spans push beyond.
+        let r0 = Math.min(anchorCell.row, headCell.row);
+        let c0 = Math.min(anchorCell.col, headCell.col);
+        let r1 = Math.max(anchorCell.row + anchorCell.rowspan - 1, headCell.row + headCell.rowspan - 1);
+        let c1 = Math.max(anchorCell.col + anchorCell.colspan - 1, headCell.col + headCell.colspan - 1);
+        // 4b) Iteratively widen the rect to include any master whose rectangle
+        //     overlaps the current rect (covers the "extends beyond" case).
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (const c of grid.cells) {
+                const cellR1 = c.row + c.rowspan - 1;
+                const cellC1 = c.col + c.colspan - 1;
+                const overlaps = c.row <= r1 && cellR1 >= r0 && c.col <= c1 && cellC1 >= c0;
+                if (!overlaps)
+                    continue;
+                const intrudes = c.row < r0 || c.col < c0 || cellR1 > r1 || cellC1 > c1;
+                if (!intrudes)
+                    continue;
+                // The cell's master is either inside the rect (extending past) or
+                // outside the rect (straddling). In the second case we cannot merge
+                // without splitting the foreign cell.
+                const masterInside = c.row >= r0 && c.col >= c0 && c.row <= r1 && c.col <= c1;
+                if (!masterInside) {
+                    // Straddling — would orphan a span.
+                    return false;
+                }
+                // Master inside but extends past: widen the rect to swallow it.
+                if (cellR1 > r1) {
+                    r1 = cellR1;
+                    changed = true;
+                }
+                if (cellC1 > c1) {
+                    c1 = cellC1;
+                    changed = true;
+                }
+            }
+        }
+        // 5) Reject 1x1 (covers same cell or a span=1 cell).
+        if (r0 === r1 && c0 === c1) {
+            // Only reject if the rect collapses to a single grid slot. Note that a
+            // single colspan>1 master also has r0===r1 && c0!==c1 → not rejected.
+            return false;
+        }
+        if (!dispatch)
+            return true;
+        // 6) Collect cells in the rect in row-major (document) order.
+        const rectCells = [];
+        for (const c of grid.cells) {
+            if (c.row >= r0 && c.row <= r1 && c.col >= c0 && c.col <= c1) {
+                rectCells.push(c);
+            }
+        }
+        // Sort by (row, col) — should already match document order for masters.
+        rectCells.sort((a, b) => (a.row - b.row) || (a.col - b.col));
+        // 7) Build the merged master's content: concatenate every cell's block
+        //    content (top-left first).
+        const mergedBlocks = [];
+        for (const c of rectCells) {
+            for (let i = 0; i < c.node.content.childCount; i++) {
+                mergedBlocks.push(c.node.content.child(i));
+            }
+        }
+        // Guarantee at least one block (cell content must be non-empty).
+        if (mergedBlocks.length === 0) {
+            mergedBlocks.push(state.schema.node('paragraph', null));
+        }
+        const masterOriginal = rectCells[0];
+        const newMaster = state.schema.node('table_cell', {
+            ...masterOriginal.node.attrs,
+            colspan: c1 - c0 + 1,
+            rowspan: r1 - r0 + 1,
+        }, mergedBlocks);
+        // 8) Rebuild the table — walk rows; for each row, emit cells. In the
+        //    rectangle's row range, only emit the master in its starting row;
+        //    skip every cell whose master is in `rectCells` and which is not the
+        //    chosen master.
+        const mergedCellPositions = new Set();
+        for (const c of rectCells)
+            mergedCellPositions.add(c.pos);
+        // `mergedRow` tracks the row in which we plant the new master.
+        const newRows = [];
+        for (let r = 0; r < table.content.childCount; r++) {
+            const row = table.content.child(r);
+            const newCells = [];
+            // Walk row's cells; we need their grid coordinates. We can recover them
+            // via the grid by matching cell positions.
+            // Build per-row cell list from grid.cells filtered by row === r.
+            const rowMasters = grid.cells.filter((c) => c.row === r);
+            // Sort by col for stable traversal.
+            rowMasters.sort((a, b) => a.col - b.col);
+            for (const c of rowMasters) {
+                if (mergedCellPositions.has(c.pos)) {
+                    if (c.pos === masterOriginal.pos) {
+                        // Emit the new merged master in its master row.
+                        newCells.push(newMaster);
+                    }
+                    // else: skip — absorbed into the master.
+                    continue;
+                }
+                newCells.push(c.node);
+            }
+            if (newCells.length === 0) {
+                // Row became empty (entire row absorbed by spans of merged cells).
+                // This shouldn't happen with our row-master semantics — rows whose
+                // cells are all spanned-into from elsewhere keep their non-master
+                // grid slots produced by other masters. But guard anyway: ensure
+                // table_row content (cell+) is satisfied.
+                continue;
+            }
+            newRows.push(state.schema.node('table_row', row.attrs, newCells));
+        }
+        const newTable = state.schema.node('table', table.attrs, newRows);
+        const slice = new Slice(Fragment.from([newTable]), 0, 0);
+        const tableEnd = tableStart + table.nodeSize;
+        const tr = state.tr.step(new ReplaceStep(tableStart, tableEnd, slice));
+        // 9) Cursor at the first inline of the new master.
+        // Compute the master's [open] position in the NEW table.
+        const newMasterRowIdx = newRows.findIndex((rr) => {
+            for (let i = 0; i < rr.content.childCount; i++) {
+                if (rr.content.child(i) === newMaster)
+                    return true;
+            }
+            return false;
+        });
+        let masterColIdx = 0;
+        if (newMasterRowIdx >= 0) {
+            const rr = newRows[newMasterRowIdx];
+            for (let i = 0; i < rr.content.childCount; i++) {
+                if (rr.content.child(i) === newMaster) {
+                    masterColIdx = i;
+                    break;
+                }
+            }
+        }
+        const cursor = firstInlineOfCellAt(tableStart, newTable, Math.max(0, newMasterRowIdx), masterColIdx);
+        setOverride(tr, cursor);
+        dispatch(tr);
+        return true;
+    };
+}
+/**
+ * If the cursor is inside a cell with colspan > 1 or rowspan > 1, split that
+ * cell back into individual 1×1 cells. The original cell keeps its content;
+ * the freed grid positions are filled with fresh empty cells (one empty
+ * paragraph each).
+ *
+ * Returns false if cursor isn't in a cell, or the cell already has
+ * colspan === 1 AND rowspan === 1.
+ */
+export function splitCell() {
+    return (state, dispatch) => {
+        const rp = resolve(state.doc, state.selection.from);
+        const ctx = findTableContext(rp);
+        if (!ctx)
+            return false;
+        // Find this cell in the grid to read its true (row, col, spans).
+        const grid = tableGrid(ctx.table, ctx.tableStart);
+        // The cell at the cursor is the rowIdx'th master row in the grid row OR
+        // we can look up by walking the row's cells. Simpler: compute the cell's
+        // [open] position via the same logic as firstInlineOfCellAt, then byPos.
+        let cellOpenPos = ctx.tableStart + 1; // row[0][open]
+        for (let r = 0; r < ctx.rowIdx; r++) {
+            cellOpenPos += ctx.table.content.child(r).nodeSize;
+        }
+        cellOpenPos += 1; // step inside the row
+        const cursorRow = ctx.table.content.child(ctx.rowIdx);
+        for (let c = 0; c < ctx.colIdx; c++) {
+            cellOpenPos += cursorRow.content.child(c).nodeSize;
+        }
+        const cellInfo = grid.byPos(cellOpenPos);
+        if (!cellInfo)
+            return false;
+        if (cellInfo.colspan === 1 && cellInfo.rowspan === 1)
+            return false;
+        if (!dispatch)
+            return true;
+        // Build the new table. We need to insert empty cells into the appropriate
+        // rows to fill the (rowspan × colspan) rectangle the master used to cover,
+        // and reset the master's spans to 1.
+        const { row: masterRow, col: masterCol, rowspan, colspan } = cellInfo;
+        const r0 = masterRow;
+        const r1 = masterRow + rowspan - 1;
+        const c0 = masterCol;
+        const c1 = masterCol + colspan - 1;
+        const newMasterNode = state.schema.node('table_cell', { ...cellInfo.node.attrs, colspan: 1, rowspan: 1 }, 
+        // Preserve content (which must be non-empty per schema).
+        cellInfo.node.content);
+        // For each row in [r0..r1], we need to assemble a new list of cells. We
+        // walk the grid's view of that row and determine, for each column in
+        // [0..cols-1], which physical cell to emit (skipping spans that aren't
+        // the master's slot).
+        const newRows = [];
+        for (let r = 0; r < ctx.table.content.childCount; r++) {
+            const oldRow = ctx.table.content.child(r);
+            // Outside the split rectangle: keep the row untouched.
+            if (r < r0 || r > r1) {
+                newRows.push(oldRow);
+                continue;
+            }
+            // Inside the rectangle: rebuild the row.
+            // Step 1: collect every master that BEGINS in this row (existing).
+            const rowMasters = grid.cells.filter((c) => c.row === r);
+            rowMasters.sort((a, b) => a.col - b.col);
+            // Step 2: build the list of cells for this row by scanning columns.
+            const newCells = [];
+            let col = 0;
+            const cols = grid.cols;
+            while (col < cols) {
+                // What cell occupies grid slot (r, col)?
+                const occ = grid.cellAt(r, col);
+                const inSplitRect = col >= c0 && col <= c1;
+                if (inSplitRect) {
+                    if (r === r0 && col === c0) {
+                        // The master's slot — emit the de-spanned master node.
+                        newCells.push(newMasterNode);
+                    }
+                    else {
+                        // Freed slot — emit a fresh empty cell.
+                        newCells.push(makeEmptyCell(state.schema));
+                    }
+                    col++;
+                    continue;
+                }
+                // Outside the split rect: if a master STARTS at (r, col), emit it.
+                // Otherwise we're in a span foreign to the split — but in that case
+                // the master begins in a different row's column AND the slot is
+                // occupied by a master in this same row only if rowspan=1 already.
+                // For correctness we only emit when occ is a master beginning at
+                // (r, col).
+                if (occ && occ.row === r && occ.col === col) {
+                    newCells.push(occ.node);
+                    col += occ.colspan;
+                }
+                else {
+                    // Slot owned by a span beginning in another row → no cell to emit
+                    // in THIS row's child list (HTML row layout).
+                    col++;
+                }
+            }
+            // Note: it is possible newCells is empty if every slot in this row is
+            // owned by spans from elsewhere AND the split rect spans the entire
+            // row. We always include the split rect's columns above, so this row
+            // will always emit at least the columns from c0..c1.
+            newRows.push(state.schema.node('table_row', oldRow.attrs, newCells));
+        }
+        const newTable = state.schema.node('table', ctx.table.attrs, newRows);
+        const slice = new Slice(Fragment.from([newTable]), 0, 0);
+        const tableEnd = ctx.tableStart + ctx.table.nodeSize;
+        const tr = state.tr.step(new ReplaceStep(ctx.tableStart, tableEnd, slice));
+        // Cursor: first inline of the (still in place) master cell. Find its
+        // index in its row.
+        const newMasterRow = newRows[r0];
+        let newMasterColIdx = 0;
+        for (let i = 0; i < newMasterRow.content.childCount; i++) {
+            if (newMasterRow.content.child(i) === newMasterNode) {
+                newMasterColIdx = i;
+                break;
+            }
+        }
+        const cursor = firstInlineOfCellAt(ctx.tableStart, newTable, r0, newMasterColIdx);
+        setOverride(tr, cursor);
+        dispatch(tr);
+        return true;
+    };
+}
+/**
+ * Toggle the `header` attr of the table row containing the cursor.
+ * Returns false when the cursor isn't inside a table row.
+ *
+ * The renderer treats header rows specially (either by emitting them
+ * inside `<thead>` OR by adding an `is-header` class to the `<tr>`).
+ * Either is fine for v0.3c — the toolbar styling on the example apps
+ * works against the class.
+ */
+export function toggleHeaderRow() {
+    return (state, dispatch) => {
+        const rp = resolve(state.doc, state.selection.from);
+        // Walk up to find the table_row depth.
+        let rowDepth = -1;
+        for (let d = rp.depth; d >= 1; d--) {
+            if (rp.node(d).type.name === 'table_row') {
+                rowDepth = d;
+                break;
+            }
+        }
+        if (rowDepth < 1)
+            return false;
+        const row = rp.node(rowDepth);
+        const current = row.attrs.header ?? false;
+        const rowPos = rp.before(rowDepth);
+        if (!dispatch)
+            return true;
+        const tr = state.tr.step(new AttrStep(rowPos, 'header', !current));
+        // Preserve the cursor.
+        setOverride(tr, state.selection.from);
+        dispatch(tr);
+        return true;
+    };
+}
+/**
+ * Compute the absolute position of the first inline position of the cell at
+ * (rowIdx, colIdx) within a freshly-constructed table whose [open] sits at
+ * `tableStart`.
+ */
+function firstInlineOfCellAt(tableStart, table, rowIdx, colIdx) {
+    // tableStart points at the table's [open]; content starts at tableStart+1.
+    let pos = tableStart + 1;
+    for (let r = 0; r < rowIdx; r++) {
+        pos += table.content.child(r).nodeSize;
+    }
+    // Now `pos` is the [open] of the target row; step inside.
+    pos += 1;
+    const row = table.content.child(rowIdx);
+    for (let c = 0; c < colIdx; c++) {
+        pos += row.content.child(c).nodeSize;
+    }
+    // `pos` is the [open] of the target cell. Step inside the cell, then into
+    // the first paragraph's content (one more open token).
+    return pos + 2;
+}
+//# sourceMappingURL=table-commands.js.map