@atlaskit/editor-tables 3.1.14 → 3.2.0

package/dist/es2019/utils/is-selected.js

@@ -1,61 +1,22 @@
-import { TableMap } from '../table-map';
-import { isSelectionType } from './is-selection-type';
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
 
-// Checks if a given CellSelection rect is selected
-export const isRectSelected = rect => selection => {
-  if (!isSelectionType(selection, 'cell')) {
-    return false;
-  }
-  const map = TableMap.get(selection.$anchorCell.node(-1));
-  const start = selection.$anchorCell.start(-1);
-  const cells = map.cellsInRect(rect);
-  const selectedCells = map.cellsInRect(map.rectBetween(selection.$anchorCell.pos - start, selection.$headCell.pos - start));
-  for (let i = 0, count = cells.length; i < count; i++) {
-    if (selectedCells.indexOf(cells[i]) === -1) {
-      return false;
-    }
-  }
-  return true;
-};
-
-// Checks if entire column at index `columnIndex` is selected.
-export const isColumnSelected = columnIndex => selection => {
-  if (isSelectionType(selection, 'cell')) {
-    const map = TableMap.get(selection.$anchorCell.node(-1));
-    return isRectSelected({
-      left: columnIndex,
-      right: columnIndex + 1,
-      top: 0,
-      bottom: map.height
-    })(selection);
-  }
-  return false;
-};
-
-// Checks if entire row at index `rowIndex` is selected.
-export const isRowSelected = rowIndex => selection => {
-  if (isSelectionType(selection, 'cell')) {
-    const map = TableMap.get(selection.$anchorCell.node(-1));
-    return isRectSelected({
-      left: 0,
-      right: map.width,
-      top: rowIndex,
-      bottom: rowIndex + 1
-    })(selection);
-  }
-  return false;
-};
-
-// Checks if entire table is selected
-export const isTableSelected = selection => {
-  if (isSelectionType(selection, 'cell')) {
-    const map = TableMap.get(selection.$anchorCell.node(-1));
-    return isRectSelected({
-      left: 0,
-      right: map.width,
-      top: 0,
-      bottom: map.height
-    })(selection);
-  }
-  return false;
-};
+/**
+ * @deprecated Use `import { isRectSelected } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { isRectSelected } from './is-rect-selected';
+/**
+ * @deprecated Use `import { isColumnSelected } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { isColumnSelected } from './is-column-selected';
+/**
+ * @deprecated Use `import { isRowSelected } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { isRowSelected } from './is-row-selected';
+/**
+ * @deprecated Use `import { isTableSelected } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { isTableSelected } from './is-table-selected';

package/dist/es2019/utils/is-table-selected.js

@@ -0,0 +1,17 @@
+import { TableMap } from '../table-map';
+import { isRectSelected } from './is-rect-selected';
+import { isSelectionType } from './is-selection-type';
+
+// Checks if entire table is selected
+export const isTableSelected = selection => {
+  if (isSelectionType(selection, 'cell')) {
+    const map = TableMap.get(selection.$anchorCell.node(-1));
+    return isRectSelected({
+      left: 0,
+      right: map.width,
+      top: 0,
+      bottom: map.height
+    })(selection);
+  }
+  return false;
+};

package/dist/es2019/utils/is-valid-reorder.js

@@ -0,0 +1,14 @@
+export const isValidReorder = (originIndex, targetIndex, targets, type) => {
+  const direction = originIndex > targetIndex ? -1 : 1;
+  const errorMessage = `Target position is invalid, you can't move the ${type} ${originIndex} to ${targetIndex}, the target can't be split. You could use tryToFit option.`;
+  if (direction === 1) {
+    if (targets.slice(0, targets.length - 1).indexOf(targetIndex) !== -1) {
+      throw new Error(errorMessage);
+    }
+  } else {
+    if (targets.slice(1).indexOf(targetIndex) !== -1) {
+      throw new Error(errorMessage);
+    }
+  }
+  return true;
+};

package/dist/es2019/utils/move-column.js

@@ -2,10 +2,10 @@ import { CellSelection } from '../cell-selection';
 import { TableMap } from '../table-map';
 import { determineTableHeaderStateFromTableNode } from './analyse-table';
 import { cloneTr } from './clone-tr';
-import { findTable } from './find';
+import { findTable } from './find-table';
 import { getSelectionRangeInColumn } from './get-selection-range-in-column';
+import { isValidReorder } from './is-valid-reorder';
 import { normalizeDirection } from './normalize-direction';
-import { isValidReorder } from './reorder-utils';
 import { tableNodeTypes } from './table-node-types';
 // :: (originColumnIndex: number, targetColumnIndex: targetColumnIndex, options?: MovementOptions) → (tr: Transaction) → Transaction
 // Returns a new transaction that moves the origin column to the target index;

package/dist/es2019/utils/move-row-in-array-of-rows.js

@@ -0,0 +1,17 @@
+export const moveRowInArrayOfRows = (arrayOfNodes, indexesOrigin, indexesTarget, directionOverride) => {
+  const direction = indexesOrigin[0] > indexesTarget[0] ? -1 : 1;
+  const rowsExtracted = arrayOfNodes.splice(indexesOrigin[0], indexesOrigin.length);
+  const positionOffset = rowsExtracted.length % 2 === 0 ? 1 : 0;
+  let target;
+  if (directionOverride === -1 && direction === 1) {
+    target = indexesTarget[0] - 1;
+  } else if (directionOverride === 1 && direction === -1) {
+    target = indexesTarget[indexesTarget.length - 1] - positionOffset + 1;
+  } else {
+    target = direction === -1 ? indexesTarget[0] : indexesTarget[indexesTarget.length - 1] - positionOffset;
+  }
+
+  // @ts-ignore no idea what this line does
+  arrayOfNodes.splice.apply(arrayOfNodes, [target, 0].concat(rowsExtracted));
+  return arrayOfNodes;
+};

package/dist/es2019/utils/move-row.js

@@ -2,10 +2,10 @@ import { CellSelection } from '../cell-selection';
 import { TableMap } from '../table-map';
 import { determineTableHeaderStateFromTableNode } from './analyse-table';
 import { cloneTr } from './clone-tr';
-import { findTable } from './find';
+import { findTable } from './find-table';
 import { getSelectionRangeInRow } from './get-selection-range-in-row';
+import { isValidReorder } from './is-valid-reorder';
 import { normalizeDirection } from './normalize-direction';
-import { isValidReorder } from './reorder-utils';
 import { tableNodeTypes } from './table-node-types';
 
 // :: (originRowIndex: number, targetRowIndex: targetColumnIndex, options?: MovementOptions) → (tr: Transaction) → Transaction

package/dist/es2019/utils/move-table-column.js

@@ -0,0 +1,10 @@
+import { convertArrayOfRowsToTableNode } from './convert-array-of-rows-to-table-node';
+import { convertTableNodeToArrayOfRows } from './convert-table-node-to-array-of-rows';
+import { moveRowInArrayOfRows } from './move-row-in-array-of-rows';
+import { transpose } from './transpose';
+export const moveTableColumn = (table, indexesOrigin, indexesTarget, direction) => {
+  let rows = transpose(convertTableNodeToArrayOfRows(table.node));
+  rows = moveRowInArrayOfRows(rows, indexesOrigin, indexesTarget, direction);
+  rows = transpose(rows);
+  return convertArrayOfRowsToTableNode(table.node, rows);
+};

package/dist/es2019/utils/move-table-row.js

@@ -0,0 +1,8 @@
+import { convertArrayOfRowsToTableNode } from './convert-array-of-rows-to-table-node';
+import { convertTableNodeToArrayOfRows } from './convert-table-node-to-array-of-rows';
+import { moveRowInArrayOfRows } from './move-row-in-array-of-rows';
+export const moveTableRow = (table, indexesOrigin, indexesTarget, direction) => {
+  let rows = convertTableNodeToArrayOfRows(table.node);
+  rows = moveRowInArrayOfRows(rows, indexesOrigin, indexesTarget, direction);
+  return convertArrayOfRowsToTableNode(table.node, rows);
+};

package/dist/es2019/utils/next-cell.js

@@ -0,0 +1,7 @@
+import { TableMap } from '../table-map';
+export function nextCell($pos, axis, dir) {
+  const start = $pos.start(-1);
+  const map = TableMap.get($pos.node(-1));
+  const moved = map.nextCell($pos.pos - start, axis, dir);
+  return moved == null ? null : $pos.node(0).resolve(start + moved);
+}

package/dist/es2019/utils/pasted-cells.js

@@ -0,0 +1,127 @@
+// Utilities used for copy/paste handling.
+//
+// This module handles pasting cell content into tables, or pasting
+// anything into a cell selection, as replacing a block of cells with
+// the content of the selection. When pasting cells into a cell, that
+// involves placing the block of pasted content so that its top left
+// aligns with the selection cell, optionally extending the table to
+// the right or bottom to make sure it is large enough. Pasting into a
+// cell selection is different, here the cells in the selection are
+// clipped to the selection's rectangle, optionally repeating the
+// pasted cells when they are smaller than the selection.
+
+import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
+import { fitSlice } from './fit-slice';
+import { tableNodeTypes } from './table-node-types';
+
+// Utilities to help with copying and pasting table cells
+/**
+ * Replace any header cells with table cells.
+ *
+ * @param schema
+ * @param cells
+ * @returns Fragment with header cells converted to table cells
+ */
+function stripHeaderType(schema, cells) {
+  const newCells = [];
+  cells.forEach(cell => {
+    var _cellNodeType$createA;
+    // Convert to cell type if not already
+    const cellNodeType = tableNodeTypes(schema).cell;
+    const tableCell = cell.type === cellNodeType ? cell : (_cellNodeType$createA = cellNodeType.createAndFill(cell.attrs, cell.content, cell.marks)) !== null && _cellNodeType$createA !== void 0 ? _cellNodeType$createA : cell;
+    newCells.push(tableCell);
+  });
+  return Fragment.from(newCells);
+}
+
+// : (Schema, [Fragment]) → {width: number, height: number, rows: [Fragment]}
+// Compute the width and height of a set of cells, and make sure each
+// row has the same number of cells.
+function ensureRectangular(schema, rowsFragment) {
+  const rows = rowsFragment;
+  const widths = [];
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i];
+    for (let j = row.childCount - 1; j >= 0; j--) {
+      const {
+        rowspan,
+        colspan
+      } = row.child(j).attrs;
+      for (let r = i; r < i + rowspan; r++) {
+        widths[r] = (widths[r] || 0) + colspan;
+      }
+    }
+  }
+  let width = 0;
+  for (let r = 0; r < widths.length; r++) {
+    width = Math.max(width, widths[r]);
+  }
+  for (let r = 0; r < widths.length; r++) {
+    if (r >= rows.length) {
+      rows.push(Fragment.empty);
+    }
+    if (widths[r] < width) {
+      // Ignored via go/ees005
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const empty = tableNodeTypes(schema).cell.createAndFill();
+      const cells = [];
+      for (let i = widths[r]; i < width; i++) {
+        cells.push(empty);
+      }
+      rows[r] = rows[r].append(Fragment.from(cells));
+    }
+  }
+  return {
+    height: rows.length,
+    width,
+    rows
+  };
+}
+
+// : (Slice) → ?{width: number, height: number, rows: [Fragment]}
+// Get a rectangular area of cells from a slice, or null if the outer
+// nodes of the slice aren't table cells or rows.
+export function pastedCells(slice) {
+  if (!slice.size) {
+    return null;
+  }
+  let {
+    content,
+    openStart,
+    openEnd
+  } = slice;
+  if (!content.firstChild) {
+    throw new Error('pastedCells: no firstChild defined for content');
+  }
+  while (content.childCount === 1 && (openStart > 0 && openEnd > 0 || content.firstChild.type.spec.tableRole === 'table')) {
+    openStart--;
+    openEnd--;
+    content = content.firstChild.content;
+    if (!content.firstChild) {
+      throw new Error('pastedCells: no firstChild defined for content');
+    }
+  }
+  const first = content.firstChild;
+  const role = first.type.spec.tableRole;
+  const {
+    schema
+  } = first.type;
+  const rows = [];
+  if (role === 'row') {
+    for (let i = 0; i < content.childCount; i++) {
+      let cells = content.child(i).content;
+      const left = i ? 0 : Math.max(0, openStart - 1);
+      const right = i < content.childCount - 1 ? 0 : Math.max(0, openEnd - 1);
+      if (left || right) {
+        cells = fitSlice(tableNodeTypes(schema).row, new Slice(cells, left, right)).content;
+      }
+      rows.push(cells);
+    }
+  } else if (role === 'cell' || role === 'header_cell') {
+    rows.push(openStart || openEnd ? fitSlice(tableNodeTypes(schema).row, new Slice(content, openStart, openEnd)).content : content);
+  } else {
+    return null;
+  }
+  const rowsWithoutHeaders = rows.map(row => stripHeaderType(schema, row));
+  return ensureRectangular(schema, rowsWithoutHeaders);
+}

package/dist/es2019/utils/points-at-cell.js

@@ -0,0 +1,3 @@
+export function pointsAtCell($pos) {
+  return $pos.parent.type.spec.tableRole === 'row' && $pos.nodeAfter;
+}

package/dist/es2019/utils/remove-col-span.js

@@ -0,0 +1,17 @@
+export function removeColSpan(attrs, pos, n = 1) {
+  if (!attrs.colspan) {
+    throw new Error('removeColSpan(): attrs.colspan not defined');
+  }
+  const result = {
+    ...attrs,
+    colspan: attrs.colspan - n
+  };
+  if (result.colwidth) {
+    result.colwidth = result.colwidth.slice();
+    result.colwidth.splice(pos, n);
+    if (!result.colwidth.some(w => w > 0)) {
+      result.colwidth = undefined;
+    }
+  }
+  return result;
+}

package/dist/es2019/utils/remove-column-at.js

@@ -0,0 +1,24 @@
+import { TableMap } from '../table-map';
+import { cloneTr } from './clone-tr';
+import { findTable } from './find-table';
+import { removeColumn } from './remove-column';
+import { removeTable } from './remove-table';
+
+// Returns a new transaction that removes a column at index `columnIndex`. If there is only one column left, it will remove the entire table.
+export const removeColumnAt = columnIndex => tr => {
+  const table = findTable(tr.selection);
+  if (table) {
+    const map = TableMap.get(table.node);
+    if (columnIndex === 0 && map.width === 1) {
+      return removeTable(tr);
+    } else if (columnIndex >= 0 && columnIndex <= map.width) {
+      removeColumn(tr, {
+        map,
+        tableStart: table.start,
+        table: table.node
+      }, columnIndex);
+      return cloneTr(tr);
+    }
+  }
+  return tr;
+};

package/dist/es2019/utils/remove-column-closest-to-pos.js

@@ -0,0 +1,12 @@
+import { setTextSelection } from '@atlaskit/editor-prosemirror/utils';
+import { findCellRectClosestToPos } from './find-cell-rect-closest-to-pos';
+import { removeColumnAt } from './remove-column-at';
+
+// Returns a new transaction that removes a column closest to a given `$pos`.
+export const removeColumnClosestToPos = $pos => tr => {
+  const rect = findCellRectClosestToPos($pos);
+  if (rect) {
+    return removeColumnAt(rect.left)(setTextSelection($pos.pos)(tr));
+  }
+  return tr;
+};

package/dist/es2019/utils/remove-column.js

@@ -1,12 +1,12 @@
-import { setTextSelection } from '@atlaskit/editor-prosemirror/utils';
-import { TableMap } from '../table-map';
-import { cloneTr } from './clone-tr';
-import { removeColSpan } from './colspan';
-import { findCellRectClosestToPos, findTable } from './find';
-import { isTableSelected } from './is-selected';
-import { isSelectionType } from './is-selection-type';
-import { removeTable } from './remove-table';
-function removeColumn(tr, {
+import { removeColSpan } from './remove-col-span';
+
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Preserve the existing public entry-point API.
+export { removeColumnAt } from './remove-column-at';
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Preserve the existing public entry-point API.
+export { removeSelectedColumns } from './remove-selected-columns';
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Preserve the existing public entry-point API.
+export { removeColumnClosestToPos } from './remove-column-closest-to-pos';
+export function removeColumn(tr, {
   map,
   table,
   tableStart
@@ -30,68 +30,4 @@ function removeColumn(tr, {
     row += cell.attrs.rowspan;
   }
   return tr;
-}
-
-// Returns a new transaction that removes a column at index `columnIndex`. If there is only one column left, it will remove the entire table.
-export const removeColumnAt = columnIndex => tr => {
-  const table = findTable(tr.selection);
-  if (table) {
-    const map = TableMap.get(table.node);
-    if (columnIndex === 0 && map.width === 1) {
-      return removeTable(tr);
-    } else if (columnIndex >= 0 && columnIndex <= map.width) {
-      removeColumn(tr, {
-        map,
-        tableStart: table.start,
-        table: table.node
-      }, columnIndex);
-      return cloneTr(tr);
-    }
-  }
-  return tr;
-};
-
-// Returns a new transaction that removes selected columns.
-export const removeSelectedColumns = tr => {
-  const {
-    selection
-  } = tr;
-  if (isTableSelected(selection)) {
-    return removeTable(tr);
-  }
-  if (isSelectionType(selection, 'cell')) {
-    const table = findTable(selection);
-    if (table) {
-      const map = TableMap.get(table.node);
-      const rect = map.rectBetween(selection.$anchorCell.pos - table.start, selection.$headCell.pos - table.start);
-      if (rect.left === 0 && rect.right === map.width) {
-        return tr;
-      }
-      const pmTableRect = {
-        ...rect,
-        map,
-        table: table.node,
-        tableStart: table.start
-      };
-      for (let i = pmTableRect.right - 1;; i--) {
-        removeColumn(tr, pmTableRect, i);
-        if (i === pmTableRect.left) {
-          break;
-        }
-        pmTableRect.table = pmTableRect.tableStart ? tr.doc.nodeAt(pmTableRect.tableStart - 1) : tr.doc;
-        pmTableRect.map = TableMap.get(pmTableRect.table);
-      }
-      return cloneTr(tr);
-    }
-  }
-  return tr;
-};
-
-// Returns a new transaction that removes a column closest to a given `$pos`.
-export const removeColumnClosestToPos = $pos => tr => {
-  const rect = findCellRectClosestToPos($pos);
-  if (rect) {
-    return removeColumnAt(rect.left)(setTextSelection($pos.pos)(tr));
-  }
-  return tr;
-};
+}

package/dist/es2019/utils/remove-row-at.js

@@ -0,0 +1,24 @@
+import { TableMap } from '../table-map';
+import { cloneTr } from './clone-tr';
+import { findTable } from './find-table';
+import { removeRow } from './remove-row';
+import { removeTable } from './remove-table';
+
+// Returns a new transaction that removes a row at index `rowIndex`. If there is only one row left, it will remove the entire table.
+export const removeRowAt = rowIndex => tr => {
+  const table = findTable(tr.selection);
+  if (table) {
+    const map = TableMap.get(table.node);
+    if (rowIndex === 0 && map.height === 1) {
+      return removeTable(tr);
+    } else if (rowIndex >= 0 && rowIndex <= map.height) {
+      removeRow(tr, {
+        map,
+        tableStart: table.start,
+        table: table.node
+      }, rowIndex);
+      return cloneTr(tr);
+    }
+  }
+  return tr;
+};

package/dist/es2019/utils/remove-row-closest-to-pos.js

@@ -0,0 +1,12 @@
+import { setTextSelection } from '@atlaskit/editor-prosemirror/utils';
+import { findCellRectClosestToPos } from './find-cell-rect-closest-to-pos';
+import { removeRowAt } from './remove-row-at';
+
+// Returns a new transaction that removes a row closest to a given `$pos`.
+export const removeRowClosestToPos = $pos => tr => {
+  const rect = findCellRectClosestToPos($pos);
+  if (rect) {
+    return removeRowAt(rect.top)(setTextSelection($pos.pos)(tr));
+  }
+  return tr;
+};

package/dist/es2019/utils/remove-row.js

@@ -1,11 +1,10 @@
-import { setTextSelection } from '@atlaskit/editor-prosemirror/utils';
-import { TableMap } from '../table-map';
-import { cloneTr } from './clone-tr';
-import { findCellRectClosestToPos, findTable } from './find';
-import { isTableSelected } from './is-selected';
-import { isSelectionType } from './is-selection-type';
-import { removeTable } from './remove-table';
-function removeRow(tr, {
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Preserve the existing public entry-point API.
+export { removeRowAt } from './remove-row-at';
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Preserve the existing public entry-point API.
+export { removeSelectedRows } from './remove-selected-rows';
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Preserve the existing public entry-point API.
+export { removeRowClosestToPos } from './remove-row-closest-to-pos';
+export function removeRow(tr, {
   map,
   table,
   tableStart
@@ -47,68 +46,4 @@ function removeRow(tr, {
     }
   }
   return tr;
-}
-
-// Returns a new transaction that removes a row at index `rowIndex`. If there is only one row left, it will remove the entire table.
-export const removeRowAt = rowIndex => tr => {
-  const table = findTable(tr.selection);
-  if (table) {
-    const map = TableMap.get(table.node);
-    if (rowIndex === 0 && map.height === 1) {
-      return removeTable(tr);
-    } else if (rowIndex >= 0 && rowIndex <= map.height) {
-      removeRow(tr, {
-        map,
-        tableStart: table.start,
-        table: table.node
-      }, rowIndex);
-      return cloneTr(tr);
-    }
-  }
-  return tr;
-};
-
-// Returns a new transaction that removes selected rows.
-export const removeSelectedRows = tr => {
-  const {
-    selection
-  } = tr;
-  if (isTableSelected(selection)) {
-    return removeTable(tr);
-  }
-  if (isSelectionType(selection, 'cell')) {
-    const table = findTable(selection);
-    if (table) {
-      const map = TableMap.get(table.node);
-      const rect = map.rectBetween(selection.$anchorCell.pos - table.start, selection.$headCell.pos - table.start);
-      if (rect.top === 0 && rect.bottom === map.height) {
-        return tr;
-      }
-      const pmTableRect = {
-        ...rect,
-        map,
-        table: table.node,
-        tableStart: table.start
-      };
-      for (let i = pmTableRect.bottom - 1;; i--) {
-        removeRow(tr, pmTableRect, i);
-        if (i === pmTableRect.top) {
-          break;
-        }
-        pmTableRect.table = pmTableRect.tableStart ? tr.doc.nodeAt(pmTableRect.tableStart - 1) : tr.doc;
-        pmTableRect.map = TableMap.get(pmTableRect.table);
-      }
-      return cloneTr(tr);
-    }
-  }
-  return tr;
-};
-
-// Returns a new transaction that removes a row closest to a given `$pos`.
-export const removeRowClosestToPos = $pos => tr => {
-  const rect = findCellRectClosestToPos($pos);
-  if (rect) {
-    return removeRowAt(rect.top)(setTextSelection($pos.pos)(tr));
-  }
-  return tr;
-};
+}

package/dist/es2019/utils/remove-selected-columns.js

@@ -0,0 +1,43 @@
+import { TableMap } from '../table-map';
+import { cloneTr } from './clone-tr';
+import { findTable } from './find-table';
+import { isSelectionType } from './is-selection-type';
+import { isTableSelected } from './is-table-selected';
+import { removeColumn } from './remove-column';
+import { removeTable } from './remove-table';
+
+// Returns a new transaction that removes selected columns.
+export const removeSelectedColumns = tr => {
+  const {
+    selection
+  } = tr;
+  if (isTableSelected(selection)) {
+    return removeTable(tr);
+  }
+  if (isSelectionType(selection, 'cell')) {
+    const table = findTable(selection);
+    if (table) {
+      const map = TableMap.get(table.node);
+      const rect = map.rectBetween(selection.$anchorCell.pos - table.start, selection.$headCell.pos - table.start);
+      if (rect.left === 0 && rect.right === map.width) {
+        return tr;
+      }
+      const pmTableRect = {
+        ...rect,
+        map,
+        table: table.node,
+        tableStart: table.start
+      };
+      for (let i = pmTableRect.right - 1;; i--) {
+        removeColumn(tr, pmTableRect, i);
+        if (i === pmTableRect.left) {
+          break;
+        }
+        pmTableRect.table = pmTableRect.tableStart ? tr.doc.nodeAt(pmTableRect.tableStart - 1) : tr.doc;
+        pmTableRect.map = TableMap.get(pmTableRect.table);
+      }
+      return cloneTr(tr);
+    }
+  }
+  return tr;
+};