@portone/docx-editor 0.1.0

package/dist/table/gridBorders.js

@@ -0,0 +1,192 @@
+// src/table/gridBorders.ts
+import { Plugin } from "prosemirror-state";
+import { TableMap } from "prosemirror-tables";
+import { Transform } from "prosemirror-transform";
+import {
+  cellBorderDefaults,
+  cellMarginsOf,
+  gridEdgesOf,
+  insideBordersOf,
+  layerCellMargins,
+  layerInsideBorders,
+  NO_BORDER_DEFAULTS,
+  NO_CELL_MARGINS,
+  NO_INSIDE_BORDERS,
+  readCellProps
+} from "../docx/tableFormatting.js";
+import {
+  spanCount,
+  toCellFormat,
+  toCellMargins,
+  toInsideBorders,
+  toTableFormat
+} from "../model/format.js";
+function text(value) {
+  return typeof value === "string" ? value : null;
+}
+function tableCellSources(table) {
+  const tblPr = text(table.attrs.tblPr);
+  return {
+    outer: toTableFormat(table.attrs.format),
+    inside: layerInsideBorders(
+      toInsideBorders(table.attrs.styleInside) ?? NO_INSIDE_BORDERS,
+      insideBordersOf(tblPr)
+    ),
+    margins: layerCellMargins(
+      toCellMargins(table.attrs.styleCellMargins) ?? NO_CELL_MARGINS,
+      cellMarginsOf(tblPr)
+    )
+  };
+}
+function cellDefaultsAt(map, pos, sources) {
+  return cellBorderDefaults(
+    gridEdgesOf(map.findCell(pos), { rows: map.height, cols: map.width }),
+    sources.outer,
+    sources.inside
+  );
+}
+var CELL_FORMAT_KEYS = [
+  "borderTop",
+  "borderBottom",
+  "borderLeft",
+  "borderRight",
+  "background",
+  "verticalAlign",
+  "paddingTopPt",
+  "paddingRightPt",
+  "paddingBottomPt",
+  "paddingLeftPt"
+];
+function sameCellFormat(a, b) {
+  if (!a || !b) return a === b;
+  return CELL_FORMAT_KEYS.every((key) => a[key] === b[key]);
+}
+function hasDirectBorder(cell, key) {
+  return cell.direct?.[key] !== void 0;
+}
+function reconcileSharedBorder(first, firstKey, second, secondKey) {
+  const firstIsDirect = hasDirectBorder(first, firstKey);
+  const secondIsDirect = hasDirectBorder(second, secondKey);
+  if (firstIsDirect === secondIsDirect) return;
+  if (firstIsDirect) {
+    second.format[secondKey] = "none";
+  } else {
+    first.format[firstKey] = "none";
+  }
+}
+function reconcileSharedBorders(map, cells) {
+  for (let row = 0; row < map.height; row += 1) {
+    for (let col = 1; col < map.width; col += 1) {
+      const leftPos = map.map[row * map.width + col - 1];
+      const rightPos = map.map[row * map.width + col];
+      if (leftPos === rightPos) continue;
+      const left = cells.get(leftPos);
+      const right = cells.get(rightPos);
+      if (left && right) {
+        reconcileSharedBorder(left, "borderRight", right, "borderLeft");
+      }
+    }
+  }
+  for (let row = 1; row < map.height; row += 1) {
+    for (let col = 0; col < map.width; col += 1) {
+      const topPos = map.map[(row - 1) * map.width + col];
+      const bottomPos = map.map[row * map.width + col];
+      if (topPos === bottomPos) continue;
+      const top = cells.get(topPos);
+      const bottom = cells.get(bottomPos);
+      if (top && bottom) {
+        reconcileSharedBorder(top, "borderBottom", bottom, "borderTop");
+      }
+    }
+  }
+}
+function cellFixes(table) {
+  const map = TableMap.get(table);
+  const sources = tableCellSources(table);
+  const cells = /* @__PURE__ */ new Map();
+  for (const pos of new Set(map.map)) {
+    const cell = table.nodeAt(pos);
+    if (!cell) continue;
+    const tcPr = text(cell.attrs.tcPr);
+    const format = readCellProps(
+      tcPr,
+      cellDefaultsAt(map, pos, sources),
+      sources.margins
+    );
+    cells.set(pos, {
+      pos,
+      attrs: cell.attrs,
+      format: { ...format },
+      direct: readCellProps(tcPr, NO_BORDER_DEFAULTS)
+    });
+  }
+  reconcileSharedBorders(map, cells);
+  const fixes = [];
+  for (const cell of cells.values()) {
+    const format = Object.keys(cell.format).length === 0 ? null : cell.format;
+    if (sameCellFormat(format, toCellFormat(cell.attrs.format))) continue;
+    fixes.push({ pos: cell.pos, attrs: { ...cell.attrs, format } });
+  }
+  return fixes;
+}
+function tablesOf(doc) {
+  const tables = [];
+  doc.descendants((node, pos) => {
+    if (node.type.spec.tableRole === "table") tables.push({ pos, table: node });
+    return !node.isTextblock;
+  });
+  return tables;
+}
+function sameSpans(a, b) {
+  return spanCount(a.attrs.colspan) === spanCount(b.attrs.colspan) && spanCount(a.attrs.rowspan) === spanCount(b.attrs.rowspan);
+}
+function sameRow(a, b) {
+  return a.childCount === b.childCount && a.children.every((cell, index) => sameSpans(cell, b.child(index)));
+}
+function sameGrid(a, b) {
+  return a.childCount === b.childCount && a.children.every((row, index) => sameRow(row, b.child(index)));
+}
+function sameCellFormattingInputs(a, b) {
+  return a.children.every(
+    (row, rowIndex) => row.children.every(
+      (cell, cellIndex) => cell.attrs.tcPr === b.child(rowIndex).child(cellIndex).attrs.tcPr
+    )
+  );
+}
+function sameFormattingInputs(a, b) {
+  return sameGrid(a, b) && a.attrs.tblPr === b.attrs.tblPr && a.attrs.format === b.attrs.format && a.attrs.styleInside === b.attrs.styleInside && a.attrs.styleCellMargins === b.attrs.styleCellMargins && sameCellFormattingInputs(a, b);
+}
+function withDerivedGridBorders(doc) {
+  const transform = new Transform(doc);
+  for (const { pos, table } of tablesOf(doc)) {
+    for (const fix of cellFixes(table)) {
+      transform.setNodeMarkup(pos + 1 + fix.pos, null, fix.attrs);
+    }
+  }
+  return transform.doc;
+}
+function gridBorders() {
+  return new Plugin({
+    appendTransaction(transactions, oldState, newState) {
+      if (!transactions.some((transaction) => transaction.docChanged)) {
+        return null;
+      }
+      const before = tablesOf(oldState.doc);
+      const tr = newState.tr;
+      tablesOf(newState.doc).forEach(({ pos, table }, index) => {
+        const was = before[index]?.table;
+        if (was && sameFormattingInputs(was, table)) return;
+        for (const fix of cellFixes(table)) {
+          tr.setNodeMarkup(pos + 1 + fix.pos, null, fix.attrs);
+        }
+      });
+      return tr.docChanged ? tr : null;
+    }
+  });
+}
+export {
+  cellDefaultsAt,
+  gridBorders,
+  tableCellSources,
+  withDerivedGridBorders
+};

package/dist/table/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The public surface of table editing.
+ *
+ * Only what the toolbar needs is exported. Following the ProseMirror convention,
+ * calling a command without `dispatch` only reports whether it can run right now, and that answer
+ * takes in the lock: a structural edit that would carry a locked cell off reports that it does not
+ * apply, rather than being refused after the click (`schema/locks`).
+ *
+ * Everything here works on a table already in the document; putting a new one into the body is
+ * `insertTable` in `./commands`, which reads the page geometry the editor holds.
+ */
+export type { ActiveCellPadding, CellBorderPreset, MixedCellValue, } from "./cellFormatting";
+export { activeCellBackground, activeCellBorderColor, activeCellPadding, activeCellVerticalAlign, canSetCellBorderColor, canSetCellFormatting, setCellBackground, setCellBorderColor, setCellBorders, setCellPadding, setCellVerticalAlign, } from "./cellFormatting";
+export type { TableCommand } from "./commands";
+export { addColumnAfter, addColumnBefore, addRowAfter, addRowBefore, deleteColumn, deleteRow, deleteTable, isInTable, mergeCells, splitCell, } from "./commands";
+export { canMergeCells, canSplitCell } from "./merge";

package/dist/table/index.js

@@ -0,0 +1,52 @@
+// src/table/index.ts
+import {
+  activeCellBackground,
+  activeCellBorderColor,
+  activeCellPadding,
+  activeCellVerticalAlign,
+  canSetCellBorderColor,
+  canSetCellFormatting,
+  setCellBackground,
+  setCellBorderColor,
+  setCellBorders,
+  setCellPadding,
+  setCellVerticalAlign
+} from "./cellFormatting.js";
+import {
+  addColumnAfter,
+  addColumnBefore,
+  addRowAfter,
+  addRowBefore,
+  deleteColumn,
+  deleteRow,
+  deleteTable,
+  isInTable,
+  mergeCells,
+  splitCell
+} from "./commands.js";
+import { canMergeCells, canSplitCell } from "./merge.js";
+export {
+  activeCellBackground,
+  activeCellBorderColor,
+  activeCellPadding,
+  activeCellVerticalAlign,
+  addColumnAfter,
+  addColumnBefore,
+  addRowAfter,
+  addRowBefore,
+  canMergeCells,
+  canSetCellBorderColor,
+  canSetCellFormatting,
+  canSplitCell,
+  deleteColumn,
+  deleteRow,
+  deleteTable,
+  isInTable,
+  mergeCells,
+  setCellBackground,
+  setCellBorderColor,
+  setCellBorders,
+  setCellPadding,
+  setCellVerticalAlign,
+  splitCell
+};

package/dist/table/merge.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The grid math and moving the content around are left to `prosemirror-tables`; only
+ * the formatting of the resulting cells is rewritten.
+ */
+import type { EditorState, Transaction } from "prosemirror-state";
+/**
+ * Whether several cells can be merged into one.
+ * The selection has to be a rectangle spanning more than one cell, no merged cell may stick out
+ * past that rectangle, and the lock guard has to let the merge through: a locked cell may not be
+ * swallowed by another (`schema/locks`).
+ *
+ * The two queries are defined from the very transaction the commands run, so they cannot drift
+ * from them. They live here rather than beside the commands because `./commands` imports these
+ * builders, and the other way round would turn that import around.
+ */
+export declare function canMergeCells(state: EditorState): boolean;
+/**
+ * Whether a split is possible. The cursor has to sit inside a cell that is merged horizontally or
+ * vertically, and the lock guard has to let the split through: the cells a split makes would each
+ * carry the original's lock, which is a lock planted in places it was never put (`schema/locks`).
+ */
+export declare function canSplitCell(state: EditorState): boolean;
+/**
+ * `null` if the grid does not allow the merge. The lock is not asked here: what the guard
+ * would turn down is what `canMergeCells` and the command are for, and the transaction is
+ * what they ask about.
+ *
+ * The size of the merged cell (colspan, rowspan, colwidth) keeps whatever upstream
+ * decided, and its formatting comes from the top-left cell.
+ */
+export declare function buildMergeCellsTransaction(state: EditorState): Transaction | null;
+/**
+ * `null` for a cell that is not merged, or outside a table. As with the merge, the lock is asked
+ * of the finished transaction by `canSplitCell` and the command rather than here.
+ */
+export declare function buildSplitCellTransaction(state: EditorState): Transaction | null;

package/dist/table/merge.js

@@ -0,0 +1,125 @@
+// src/table/merge.ts
+import {
+  mergeCells as pmMergeCells,
+  splitCell as pmSplitCell,
+  selectedRect,
+  TableMap
+} from "prosemirror-tables";
+import {
+  spanCount,
+  toTableWidth,
+  widthNumber,
+  withWidthNumber
+} from "../model/format.js";
+import { transactionAllowed } from "../schema/locks.js";
+import { inheritCellAttrs } from "./format.js";
+import { cellWidthForGridCol, gridSpanWidth, tableGridCols } from "./widths.js";
+function tableAfter(tr, tableStart) {
+  const tablePos = tr.mapping.map(tableStart - 1);
+  const table = tr.doc.nodeAt(tablePos);
+  if (!table) return null;
+  return { tablePos, table, map: TableMap.get(table) };
+}
+function cellAt(rect, row, col) {
+  const pos = rect.map.map[row * rect.map.width + col];
+  return pos == null ? null : rect.table.nodeAt(pos);
+}
+function canMergeCells(state) {
+  const tr = buildMergeCellsTransaction(state);
+  return tr !== null && transactionAllowed(tr, state.doc);
+}
+function canSplitCell(state) {
+  const tr = buildSplitCellTransaction(state);
+  return tr !== null && transactionAllowed(tr, state.doc);
+}
+function coveredWidthSum(rect, type) {
+  let sum = 0;
+  let previous = null;
+  for (let col = rect.left; col < rect.right; col++) {
+    const pos = rect.map.map[rect.top * rect.map.width + col];
+    if (pos === previous) continue;
+    previous = pos;
+    const cell = pos == null ? null : rect.table.nodeAt(pos);
+    const width = cell ? toTableWidth(cell.attrs.tcW) : null;
+    const value = width ? widthNumber(width) : null;
+    if (!width || width.type !== type || value === null) return null;
+    sum += value;
+  }
+  return sum;
+}
+function mergedCellWidth(rect, source) {
+  const reference = toTableWidth(source.attrs.tcW);
+  if (!reference) return null;
+  const spanned = gridSpanWidth(
+    tableGridCols(rect.table),
+    rect.left,
+    rect.right,
+    reference.type
+  ) ?? coveredWidthSum(rect, reference.type);
+  return spanned === null ? reference : withWidthNumber(reference, spanned);
+}
+function writeMergedFormat(tr, rect, source) {
+  const after = tableAfter(tr, rect.tableStart);
+  if (!after) return;
+  const { tablePos, table, map } = after;
+  const pos = map.map[rect.top * map.width + rect.left];
+  const merged = table.nodeAt(pos);
+  if (!merged) return;
+  tr.setNodeMarkup(tablePos + 1 + pos, null, {
+    ...merged.attrs,
+    ...inheritCellAttrs(source, { tcW: mergedCellWidth(rect, source) })
+  });
+}
+function buildMergeCellsTransaction(state) {
+  if (!pmMergeCells(state)) return null;
+  const rect = selectedRect(state);
+  const source = cellAt(rect, rect.top, rect.left);
+  const captured = [];
+  pmMergeCells(state, (tr2) => captured.push(tr2));
+  const tr = captured[0];
+  if (!tr || !source) return null;
+  writeMergedFormat(tr, rect, source);
+  return tr;
+}
+function writeSplitFormats(tr, rect, source) {
+  const after = tableAfter(tr, rect.tableStart);
+  if (!after) return;
+  const { tablePos, table, map } = after;
+  const gridCols = tableGridCols(table);
+  const width = toTableWidth(source.attrs.tcW);
+  const colspan = spanCount(source.attrs.colspan);
+  for (let row = rect.top; row < rect.bottom; row++) {
+    for (let col = rect.left; col < rect.right; col++) {
+      const pos = map.map[row * map.width + col];
+      const cell = pos == null ? null : table.nodeAt(pos);
+      if (!cell) continue;
+      const isOriginalSpot = row === rect.top && col === rect.left;
+      tr.setNodeMarkup(tablePos + 1 + pos, null, {
+        ...cell.attrs,
+        ...inheritCellAttrs(source, {
+          tcW: cellWidthForGridCol(gridCols, col, width, colspan),
+          sdtPrefix: isOriginalSpot ? source.attrs.sdtPrefix : null,
+          sdtContentsLocked: isOriginalSpot ? source.attrs.sdtContentsLocked : false,
+          sdtDeletionLocked: isOriginalSpot ? source.attrs.sdtDeletionLocked : false
+        })
+      });
+    }
+  }
+}
+function buildSplitCellTransaction(state) {
+  if (!pmSplitCell(state)) return null;
+  const rect = selectedRect(state);
+  const source = cellAt(rect, rect.top, rect.left);
+  const captured = [];
+  pmSplitCell(state, (tr2) => captured.push(tr2));
+  const tr = captured[0];
+  if (!tr || !source) return null;
+  writeSplitFormats(tr, rect, source);
+  return tr;
+}
+export {
+  buildMergeCellsTransaction,
+  buildSplitCellTransaction,
+  canMergeCells,
+  canSplitCell
+};

package/dist/table/resize.d.ts

@@ -0,0 +1,55 @@
+/**
+ * A boundary drag moves the grid and the cell widths together exactly as a column
+ * insertion does.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import type { EditorState, Transaction } from "prosemirror-state";
+import { type PageGeometry } from "../docx/pageGeometry";
+/**
+ * The floor a column can be narrowed to (dxa).
+ *
+ * Word's default cell padding is 0.08 inch (115 dxa) on the left and on the right, 230
+ * in total.
+ * A column narrower than that cannot fit even a single character, so the cell looks
+ * collapsed.
+ * With a little slack added, 240 dxa (12pt, about 0.42cm) is taken as the floor.
+ */
+export declare const MIN_COLUMN_DXA = 240;
+/** A single boundary being dragged. `col` is the index of the grid column left of it */
+export interface ColumnEdge {
+    /** The position where the table node sits */
+    tablePos: number;
+    col: number;
+    /**
+     * The width (dxa) the column left of the boundary wants to take. The limits are
+     * re-applied here
+     */
+    width: number;
+}
+/**
+ * The limit a table can be widened to (dxa).
+ *
+ * The body width of the paper the document names, minus the table indent (`w:tblInd`).
+ * For a table already stored wider than that, its current width is the limit, so
+ * dragging can only narrow it.
+ */
+export declare function maxGridTotal(table: PMNode, geometry: PageGeometry): number;
+/**
+ * The grid column widths after the boundary has moved. Null when nothing changes or
+ * there is no room to move into.
+ *
+ * At an inner boundary (`col` is not the last column) the left column receives only
+ * what the right column gives up, so the grid total stays the same. At the end boundary
+ * only the last column changes, so the total moves with it.
+ * No column ever ends up narrower than this table's floor, and the grid total never
+ * exceeds `maxTotal`.
+ */
+export declare function resizedGridCols(gridCols: number[], col: number, width: number, maxTotal: number): number[] | null;
+/**
+ * Because it is one single transaction, a single undo returns everything to the state
+ * before the drag.
+ *
+ * The geometry is the paper the open document names, which is what the table is kept
+ * inside. The editor layer reads it off the state; this layer is handed it.
+ */
+export declare function buildResizeColumnTransaction(state: EditorState, edge: ColumnEdge, geometry: PageGeometry): Transaction | null;

package/dist/table/resize.js

@@ -0,0 +1,66 @@
+// src/table/resize.ts
+import { bodyWidth } from "../docx/pageGeometry.js";
+import { toTableFormat } from "../model/format.js";
+import {
+  gridTotal,
+  rescaleCellWidths,
+  tableGridCols,
+  writeGridCols
+} from "./widths.js";
+var MIN_COLUMN_DXA = 240;
+var TWIPS_PER_PT = 20;
+function clamp(value, low, high) {
+  return Math.min(Math.max(value, low), high);
+}
+function minColumnDxa(gridCols) {
+  const even = Math.floor(gridTotal(gridCols) / (2 * gridCols.length));
+  return Math.min(MIN_COLUMN_DXA, Math.max(even, 1));
+}
+function maxGridTotal(table, geometry) {
+  const indentPt = toTableFormat(table.attrs.format)?.indentLeftPt ?? 0;
+  const room = bodyWidth(geometry).twips - Math.round(indentPt * TWIPS_PER_PT);
+  const gridCols = tableGridCols(table);
+  return Math.max(room, gridCols ? gridTotal(gridCols) : 0);
+}
+function resizedGridCols(gridCols, col, width, maxTotal) {
+  const last = gridCols.length - 1;
+  const current = gridCols[col];
+  if (col < 0 || col > last || typeof current !== "number") return null;
+  const floor = minColumnDxa(gridCols);
+  const inner = col < last;
+  const room = inner ? current + gridCols[col + 1] - floor : maxTotal - (gridTotal(gridCols) - current);
+  if (room < floor) return null;
+  const next = clamp(Math.round(width), floor, room);
+  if (next === current) return null;
+  return gridCols.map((entry, at) => {
+    if (at === col) return next;
+    if (inner && at === col + 1) return entry - (next - current);
+    return entry;
+  });
+}
+function tableAt(doc, pos) {
+  const node = pos >= 0 && pos < doc.content.size ? doc.nodeAt(pos) : null;
+  return node?.type.spec.tableRole === "table" ? node : null;
+}
+function buildResizeColumnTransaction(state, edge, geometry) {
+  const table = tableAt(state.doc, edge.tablePos);
+  const gridCols = table ? tableGridCols(table) : null;
+  if (!table || !gridCols) return null;
+  const resized = resizedGridCols(
+    gridCols,
+    edge.col,
+    edge.width,
+    maxGridTotal(table, geometry)
+  );
+  if (!resized) return null;
+  const tr = state.tr;
+  writeGridCols(tr, edge.tablePos + 1, resized);
+  rescaleCellWidths(tr, edge.tablePos + 1, resized);
+  return tr;
+}
+export {
+  MIN_COLUMN_DXA,
+  buildResizeColumnTransaction,
+  maxGridTotal,
+  resizedGridCols
+};

package/dist/table/rowResize.d.ts

@@ -0,0 +1,14 @@
+import type { Node as PMNode } from "prosemirror-model";
+import type { EditorState, Transaction } from "prosemirror-state";
+export declare const MIN_ROW_HEIGHT_PT = 6;
+export interface RowResize {
+    /** Position immediately before the table. */
+    tablePos: number;
+    row: number;
+    heightPt: number;
+}
+/** Converts a pointer delta to a valid row-height floor, accounting for document zoom. */
+export declare function resizedRowHeight(startPt: number, deltaPx: number, scale: number): number;
+/** Absolute document position immediately before one row in a table. */
+export declare function rowPositionAt(tablePos: number, table: PMNode, row: number): number;
+export declare function buildResizeRowTransaction(state: EditorState, resize: RowResize): Transaction | null;

package/dist/table/rowResize.js

@@ -0,0 +1,44 @@
+// src/table/rowResize.ts
+import { editRowHeight } from "../docx/tableFormatting.js";
+import { toRowFormat } from "../model/format.js";
+import { isLockedCell } from "../schema/locks.js";
+var MIN_ROW_HEIGHT_PT = 6;
+function resizedRowHeight(startPt, deltaPx, scale) {
+  const effectiveScale = Number.isFinite(scale) && scale > 0 ? scale : 1;
+  const next = startPt + deltaPx / effectiveScale * (72 / 96);
+  return Math.max(MIN_ROW_HEIGHT_PT, Math.round(next * 20) / 20);
+}
+function rowPositionAt(tablePos, table, row) {
+  let pos = tablePos + 1;
+  for (let index = 0; index < row; index += 1)
+    pos += table.child(index).nodeSize;
+  return pos;
+}
+function buildResizeRowTransaction(state, resize) {
+  const table = state.doc.nodeAt(resize.tablePos);
+  if (!table || table.type.spec.tableRole !== "table" || resize.row < 0 || resize.row >= table.childCount) {
+    return null;
+  }
+  const row = table.child(resize.row);
+  if (row.children.some(isLockedCell)) return null;
+  const edited = editRowHeight(
+    typeof row.attrs.trPr === "string" ? row.attrs.trPr : null,
+    resize.heightPt
+  );
+  if (!edited) return null;
+  return state.tr.setNodeMarkup(
+    rowPositionAt(resize.tablePos, table, resize.row),
+    null,
+    {
+      ...row.attrs,
+      trPr: edited.trPr,
+      format: toRowFormat(edited.format)
+    }
+  );
+}
+export {
+  MIN_ROW_HEIGHT_PT,
+  buildResizeRowTransaction,
+  resizedRowHeight,
+  rowPositionAt
+};

package/dist/table/rows.d.ts

@@ -0,0 +1,32 @@
+/**
+ * In docx a vertically merged cell exists as a single cell only in the row where the
+ * merge starts; in the rows below there is no cell at that position at all (how many
+ * rows the starting cell covers is counted by rowspan).
+ * So the number of cells can differ from row to row, and counting by "the nth cell"
+ * goes wrong. Everything here counts by the table's grid coordinates (TableMap).
+ *
+ * Deletion is left entirely to `prosemirror-tables`' `deleteRow`, which gets shrinking
+ * rowspans right as well.
+ */
+import { type EditorState, type Transaction } from "prosemirror-state";
+/**
+ * Builds the transaction that adds a row right below the row holding the cursor.
+ * `null` when the cursor is outside a table. The cursor moves to the first cell of the
+ * new row.
+ *
+ * Split out of the command so it can be verified from document state alone, without an
+ * editor view.
+ */
+export declare function buildAddRowAfterTransaction(state: EditorState): Transaction | null;
+/** The above version. Only the insertion position differs */
+export declare function buildAddRowBeforeTransaction(state: EditorState): Transaction | null;
+/**
+ * Builds the transaction that deletes the row holding the cursor (or the rows spanned
+ * by a multi-row selection).
+ * `null` outside a table, or when every row of the table is selected.
+ *
+ * The upstream `deleteRow` deletes every row the selection rectangle covers. With the
+ * cursor inside a merged cell the rectangle becomes that whole cell, so all the rows it
+ * covers go away with it.
+ */
+export declare function buildDeleteRowTransaction(state: EditorState): Transaction | null;