@atlaskit/editor-plugin-table 0.0.0 → 0.0.1

package/dist/es2019/plugins/table/toolbar.js

@@ -0,0 +1,287 @@
+import { defineMessages } from 'react-intl-next';
+import RemoveIcon from '@atlaskit/icon/glyph/editor/remove';
+import commonMessages from '@atlaskit/editor-common/messages';
+import { clearHoverSelection, hoverTable } from './commands';
+import { deleteTableWithAnalytics, toggleHeaderColumnWithAnalytics, toggleHeaderRowWithAnalytics, toggleNumberColumnWithAnalytics, insertRowWithAnalytics, deleteRowsWithAnalytics, mergeCellsWithAnalytics, splitCellWithAnalytics, deleteColumnsWithAnalytics, emptyMultipleCellsWithAnalytics, insertColumnWithAnalytics, wrapTableInExpandWithAnalytics } from './commands-with-analytics';
+import { getPluginState } from './pm-plugins/plugin-factory';
+import { pluginKey as tableResizingPluginKey } from './pm-plugins/table-resizing';
+import { TableCssClassName } from './types';
+import { isReferencedSource } from './utils/referentiality';
+import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import { findCellRectClosestToPos, findTable, getSelectionRect, isSelectionType } from '@atlaskit/editor-tables/utils';
+import { canMergeCells } from './transforms';
+import { splitCell } from '@atlaskit/editor-tables/utils';
+import tableMessages from './ui/messages';
+import { messages as ContextualMenuMessages } from './ui/FloatingContextualMenu/ContextualMenu';
+import { findParentDomRefOfType } from 'prosemirror-utils';
+import { closestElement } from '@atlaskit/editor-common/utils'; // TODO: ED-14403 investigate why these translations don't work
+
+export const messages = defineMessages({
+  tableOptions: {
+    id: 'fabric.editor.tableOptions',
+    defaultMessage: 'Table options',
+    description: 'Opens a menu with additional table options'
+  },
+  headerRow: {
+    id: 'fabric.editor.headerRow',
+    defaultMessage: 'Header row',
+    description: 'Marks the first table row as a header row'
+  },
+  headerColumn: {
+    id: 'fabric.editor.headerColumn',
+    defaultMessage: 'Header column',
+    description: 'Marks the first table column as a header row'
+  },
+  numberedColumn: {
+    id: 'fabric.editor.numberedColumn',
+    defaultMessage: 'Numbered column',
+    description: 'Adds an auto-numbering column to your table'
+  },
+  collapseTable: {
+    id: 'fabric.editor.collapseTable',
+    defaultMessage: 'Collapse table',
+    description: 'Wraps table in an expand'
+  }
+});
+export const getToolbarMenuConfig = (config, state, {
+  formatMessage
+}, editorAnalyticsAPI) => {
+  const options = [{
+    id: 'editor.table.headerRow',
+    title: formatMessage(messages.headerRow),
+    onClick: toggleHeaderRowWithAnalytics(editorAnalyticsAPI),
+    selected: state.isHeaderRowEnabled,
+    hidden: !config.allowHeaderRow
+  }, {
+    id: 'editor.table.headerColumn',
+    title: formatMessage(messages.headerColumn),
+    onClick: toggleHeaderColumnWithAnalytics(editorAnalyticsAPI),
+    selected: state.isHeaderColumnEnabled,
+    hidden: !config.allowHeaderColumn
+  }, {
+    id: 'editor.table.numberedColumn',
+    title: formatMessage(messages.numberedColumn),
+    onClick: toggleNumberColumnWithAnalytics(editorAnalyticsAPI),
+    selected: state.isNumberColumnEnabled,
+    hidden: !config.allowNumberColumn
+  }, {
+    id: 'editor.table.collapseTable',
+    title: formatMessage(messages.collapseTable),
+    onClick: wrapTableInExpandWithAnalytics(editorAnalyticsAPI),
+    selected: !!state.isTableCollapsed,
+    disabled: !state.canCollapseTable,
+    hidden: !config.allowCollapse
+  }];
+  return {
+    id: 'editor.table.tableOptions',
+    type: 'dropdown',
+    title: formatMessage(messages.tableOptions),
+    hidden: options.every(option => option.hidden),
+    options
+  };
+}; // Added these options for mobile. Mobile bridge translates this menu and
+// relay it to the native mobile. Native mobile displays the menu
+// with native widgets. It's enabled via a plugin config.
+
+export const getToolbarCellOptionsConfig = (editorState, initialSelectionRect, {
+  formatMessage
+}, getEditorContainerWidth, editorAnalyticsAPI) => {
+  const {
+    top,
+    bottom,
+    right,
+    left
+  } = initialSelectionRect;
+  const numberOfColumns = right - left;
+  const numberOfRows = bottom - top;
+  const options = [{
+    id: 'editor.table.insertColumn',
+    title: formatMessage(tableMessages.insertColumn),
+    onClick: (state, dispatch, view) => {
+      const selectionRect = getClosestSelectionRect(state);
+      const index = selectionRect === null || selectionRect === void 0 ? void 0 : selectionRect.right;
+
+      if (index) {
+        insertColumnWithAnalytics(getEditorContainerWidth, editorAnalyticsAPI)(INPUT_METHOD.FLOATING_TB, index)(state, dispatch, view);
+      }
+
+      return true;
+    },
+    selected: false,
+    disabled: false
+  }, {
+    id: 'editor.table.insertRow',
+    title: formatMessage(tableMessages.insertRow),
+    onClick: (state, dispatch) => {
+      const selectionRect = getClosestSelectionRect(state);
+      const index = selectionRect === null || selectionRect === void 0 ? void 0 : selectionRect.bottom;
+
+      if (index) {
+        insertRowWithAnalytics(editorAnalyticsAPI)(INPUT_METHOD.FLOATING_TB, {
+          index,
+          moveCursorToInsertedRow: true
+        })(state, dispatch);
+      }
+
+      return true;
+    },
+    selected: false,
+    disabled: false
+  }, {
+    id: 'editor.table.removeColumns',
+    title: formatMessage(tableMessages.removeColumns, {
+      0: numberOfColumns
+    }),
+    onClick: (state, dispatch, view) => {
+      const selectionRect = getClosestSelectionRect(state);
+
+      if (selectionRect) {
+        deleteColumnsWithAnalytics(editorAnalyticsAPI)(INPUT_METHOD.FLOATING_TB, selectionRect)(state, dispatch, view);
+      }
+
+      return true;
+    },
+    selected: false,
+    disabled: false
+  }, {
+    id: 'editor.table.removeRows',
+    title: formatMessage(tableMessages.removeRows, {
+      0: numberOfRows
+    }),
+    onClick: (state, dispatch) => {
+      const selectionRect = getClosestSelectionRect(state);
+
+      if (selectionRect) {
+        deleteRowsWithAnalytics(editorAnalyticsAPI)(INPUT_METHOD.FLOATING_TB, selectionRect, false)(state, dispatch);
+      }
+
+      return true;
+    },
+    selected: false,
+    disabled: false
+  }, {
+    id: 'editor.table.mergeCells',
+    title: formatMessage(ContextualMenuMessages.mergeCells),
+    onClick: mergeCellsWithAnalytics(editorAnalyticsAPI),
+    selected: false,
+    disabled: !canMergeCells(editorState.tr)
+  }, {
+    id: 'editor.table.splitCell',
+    title: formatMessage(ContextualMenuMessages.splitCell),
+    onClick: splitCellWithAnalytics(editorAnalyticsAPI),
+    selected: false,
+    disabled: !splitCell(editorState)
+  }, {
+    id: 'editor.table.clearCells',
+    title: formatMessage(ContextualMenuMessages.clearCells, {
+      0: Math.max(numberOfColumns, numberOfRows)
+    }),
+    onClick: (state, dispatch) => {
+      const {
+        targetCellPosition
+      } = getPluginState(state);
+      emptyMultipleCellsWithAnalytics(editorAnalyticsAPI)(INPUT_METHOD.FLOATING_TB, targetCellPosition)(state, dispatch);
+      return true;
+    },
+    selected: false,
+    disabled: false
+  }];
+  return {
+    id: 'editor.table.cellOptions',
+    type: 'dropdown',
+    title: formatMessage(tableMessages.cellOptions),
+    hidden: true,
+    options
+  };
+};
+
+const getClosestSelectionRect = state => {
+  const selection = state.selection;
+  return isSelectionType(selection, 'cell') ? getSelectionRect(selection) : findCellRectClosestToPos(selection.$from);
+};
+
+export const getToolbarConfig = (getEditorContainerWidth, editorAnalyticsAPI) => config => (state, intl) => {
+  const tableObject = findTable(state.selection);
+  const pluginState = getPluginState(state);
+  const resizeState = tableResizingPluginKey.getState(state);
+
+  if (tableObject && pluginState.editorHasFocus) {
+    const nodeType = state.schema.nodes.table;
+    const menu = getToolbarMenuConfig(config, pluginState, intl, editorAnalyticsAPI);
+    const cellItems = getCellItems(config, state, intl, getEditorContainerWidth, editorAnalyticsAPI); // Check if we need to show confirm dialog for delete button
+
+    let confirmDialog;
+    const localId = tableObject.node.attrs.localId;
+
+    if (localId && isReferencedSource(state, localId)) {
+      confirmDialog = {
+        okButtonLabel: intl.formatMessage(tableMessages.confirmDeleteLinkedModalOKButton),
+        message: intl.formatMessage(tableMessages.confirmDeleteLinkedModalMessage)
+      };
+    }
+
+    const getDomRef = editorView => {
+      let element;
+      const domAtPos = editorView.domAtPos.bind(editorView);
+      const parent = findParentDomRefOfType(nodeType, domAtPos)(state.selection);
+
+      if (parent) {
+        const tableRef = parent.querySelector('table') || undefined;
+
+        if (tableRef) {
+          element = closestElement(tableRef, `.${TableCssClassName.TABLE_NODE_WRAPPER}`) || undefined;
+        }
+      }
+
+      return element;
+    };
+
+    return {
+      title: 'Table floating controls',
+      getDomRef,
+      nodeType,
+      offset: [0, 3],
+      items: [menu, separator(menu.hidden), ...cellItems, {
+        type: 'extensions-placeholder',
+        separator: 'end'
+      }, {
+        id: 'editor.table.delete',
+        type: 'button',
+        appearance: 'danger',
+        icon: RemoveIcon,
+        onClick: deleteTableWithAnalytics(editorAnalyticsAPI),
+        disabled: !!resizeState && !!resizeState.dragging,
+        onMouseEnter: hoverTable(true),
+        onMouseLeave: clearHoverSelection(),
+        title: intl.formatMessage(commonMessages.remove),
+        confirmDialog
+      }]
+    };
+  }
+
+  return;
+};
+
+const separator = hidden => {
+  return {
+    type: 'separator',
+    hidden: hidden
+  };
+};
+
+const getCellItems = (pluginConfig, state, {
+  formatMessage
+}, getEditorContainerWidth, editorAnalyticsAPI) => {
+  if (pluginConfig.allowCellOptionsInFloatingToolbar) {
+    const initialSelectionRect = getClosestSelectionRect(state);
+
+    if (initialSelectionRect) {
+      const cellOptions = getToolbarCellOptionsConfig(state, initialSelectionRect, {
+        formatMessage
+      }, getEditorContainerWidth, editorAnalyticsAPI);
+      return [cellOptions, separator(cellOptions.hidden)];
+    }
+  }
+
+  return [];
+};

package/dist/es2019/plugins/table/transforms/column-width.js

@@ -0,0 +1,163 @@
+import { TableMap } from '@atlaskit/editor-tables/table-map';
+import { tableNewColumnMinWidth } from '@atlaskit/editor-common/styles';
+import { hasTableBeenResized } from '../pm-plugins/table-resizing/utils';
+import { setMeta } from './metadata';
+import { getResizeState, normaliseTableLayout } from '../pm-plugins/table-resizing/utils/resize-state';
+import { getTableMaxWidth } from '../pm-plugins/table-resizing/utils/misc';
+import { tableCellMinWidth } from '@atlaskit/editor-common/styles';
+import { scaleTableTo } from '../pm-plugins/table-resizing/utils/scale-table';
+export const updateColumnWidths = (resizeState, table, start) => tr => {
+  const map = TableMap.get(table);
+  const updatedCellsAttrs = {}; // calculating new attributes for each cell
+
+  for (let columnIndex = 0; columnIndex < map.width; columnIndex++) {
+    for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
+      const {
+        width
+      } = resizeState.cols[columnIndex];
+      const mapIndex = rowIndex * map.width + columnIndex;
+      const cellPos = map.map[mapIndex];
+      const attrs = updatedCellsAttrs[cellPos] || { ...table.nodeAt(cellPos).attrs
+      };
+      const colspan = attrs.colspan || 1;
+
+      if (attrs.colwidth && attrs.colwidth.length > colspan) {
+        tr = setMeta({
+          type: 'UPDATE_COLUMN_WIDTHS',
+          problem: 'COLWIDTHS_BEFORE_UPDATE',
+          data: {
+            colwidths: attrs.colwidth,
+            colspan
+          }
+        })(tr);
+        attrs.colwidth = attrs.colwidth.slice(0, colspan);
+      } // Rowspanning cell that has already been handled
+
+
+      if (rowIndex && map.map[mapIndex] === map.map[mapIndex - map.width]) {
+        continue;
+      }
+
+      const colspanIndex = colspan === 1 ? 0 : columnIndex - map.colCount(cellPos);
+
+      if (attrs.colwidth && attrs.colwidth[colspanIndex] === width) {
+        continue;
+      }
+
+      let colwidths = attrs.colwidth ? attrs.colwidth.slice() : Array.from({
+        length: colspan
+      }, _ => 0);
+      colwidths[colspanIndex] = width;
+
+      if (colwidths.length > colspan) {
+        tr = setMeta({
+          type: 'UPDATE_COLUMN_WIDTHS',
+          problem: 'COLWIDTHS_AFTER_UPDATE',
+          data: {
+            colwidths,
+            colspan
+          }
+        })(tr);
+        colwidths = colwidths.slice(0, colspan);
+      }
+
+      updatedCellsAttrs[cellPos] = { ...attrs,
+        colwidth: colwidths.includes(0) ? undefined : colwidths
+      };
+    }
+  } // updating all cells with new attributes
+
+
+  const rows = [];
+  const seen = {};
+
+  for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
+    const row = table.child(rowIndex);
+    const cells = [];
+
+    for (let columnIndex = 0; columnIndex < map.width; columnIndex++) {
+      const mapIndex = rowIndex * map.width + columnIndex;
+      const pos = map.map[mapIndex];
+      const cell = table.nodeAt(pos);
+
+      if (!seen[pos] && cell) {
+        cells.push(cell.type.createChecked(updatedCellsAttrs[pos] || cell.attrs, cell.content, cell.marks));
+        seen[pos] = true;
+      }
+    }
+
+    rows.push(row.type.createChecked(row.attrs, cells, row.marks));
+  }
+
+  const tablePos = start - 1;
+  const selectionBookmark = tr.selection.getBookmark();
+  tr.replaceWith(tablePos, tablePos + table.nodeSize, table.type.createChecked(table.attrs, rows, table.marks));
+  /**
+   * We want to restore to the original selection but w/o applying the mapping. Function
+   * tr.replaceWith puts the selection after the inserted content. We need to manually
+   * set the selection back to original state. Mapping in this case doesn't quite work
+   * e.g. if we change the content before a selection. This is because mapping
+   * means moving it if the content in front of it changed. Instead we can get
+   * bookmark of selection.
+   *
+   * @see https://github.com/ProseMirror/prosemirror/issues/645
+   */
+
+  return tr.setSelection(selectionBookmark.resolve(tr.doc));
+};
+/**
+ * This function is called when user inserts/deletes a column in a table to;
+ * - rescale all columns (if the table did not overflow before the insertion)
+ * - and update column widths.
+ *
+ * This is done manually to avoid a multi-dispatch in TableComponent. See [ED-8288].
+ * @param table
+ * @param view
+ * @returns Updated transaction with rescaled columns for a given table
+ */
+
+export const rescaleColumns = getEditorContainerWidth => (table, view) => tr => {
+  // If the table has been not been resized we skip updating the size
+  // of columns here.
+  if (!view || !hasTableBeenResized(table.node)) {
+    return tr;
+  }
+
+  const {
+    state
+  } = view;
+  const domAtPos = view.domAtPos.bind(view);
+  const maybeTable = domAtPos(table.start).node;
+  const tableRef = maybeTable.closest('table');
+
+  if (!tableRef) {
+    return tr;
+  }
+
+  const layout = normaliseTableLayout(tableRef === null || tableRef === void 0 ? void 0 : tableRef.dataset.layout); // The is the width the table can reach before overflowing
+
+  const maxSize = getTableMaxWidth({
+    table: table.node,
+    tableStart: table.start,
+    state,
+    layout,
+    getEditorContainerWidth
+  });
+  let resizeState = getResizeState({
+    minWidth: tableCellMinWidth,
+    table: table.node,
+    start: table.start,
+    tableRef,
+    domAtPos,
+    maxSize
+  });
+  const previousTableWidth = resizeState.tableWidth - tableNewColumnMinWidth;
+  const tableDidntPreviouslyOverflow = previousTableWidth <= maxSize; // If the new table width will result in the table going into an overflow state
+  // we resize the cells to avoid the overflow occuring
+
+  if (tableDidntPreviouslyOverflow && resizeState.overflow) {
+    resizeState = scaleTableTo(resizeState, maxSize);
+  }
+
+  return updateColumnWidths(resizeState, table.node, table.start)(tr);
+};

package/dist/es2019/plugins/table/transforms/delete-columns.js

@@ -0,0 +1,247 @@
+import { Selection } from 'prosemirror-state';
+import { TableMap } from '@atlaskit/editor-tables/table-map';
+import { findTable } from '@atlaskit/editor-tables/utils';
+import { AddColumnStep } from '@atlaskit/adf-schema/steps';
+import { setMeta } from './metadata';
+import { splitCellsInColumns } from './split';
+
+const deleteColumnsCustomStep = rect => tr => {
+  const table = findTable(tr.selection);
+
+  if (!table) {
+    return tr;
+  } // Need to split all the merge in the ranges (this is the current behaviour)
+  // Maybe is better to split only the last column?
+  // TODO: After talking with Roto about this behaviour, he likes when we dont split the columns, I am keeping this for consistency of the current implementation.
+
+
+  splitCellsInColumns(tr, table.pos, rect.left, rect.right); // Delete the columns
+
+  let mapStart = tr.mapping.maps.length;
+  const originalDoc = tr.doc;
+  const deletedColumns = [];
+
+  for (let i = rect.left; i < rect.right; i++) {
+    const step = AddColumnStep.create(originalDoc, table.pos, i, true);
+    deletedColumns.push(i);
+    tr.step(step.map(tr.mapping.slice(mapStart)));
+  }
+
+  const tablePosResult = tr.mapping.mapResult(table.pos);
+
+  if (tablePosResult.deleted) {
+    const pos = Math.min(tablePosResult.pos, tr.doc.nodeSize - 1);
+    tr.setSelection(Selection.near(tr.doc.resolve(pos)));
+  } else {
+    const newTable = tr.doc.nodeAt(tablePosResult.pos);
+
+    if (newTable) {
+      const cursorPos = getNextCursorPos(newTable, deletedColumns);
+      tr.setSelection(Selection.near(tr.doc.resolve(table.pos + cursorPos)));
+    }
+  }
+
+  return tr;
+};
+
+const deleteColumnsLegacy = rect => tr => {
+  const table = findTable(tr.selection);
+
+  if (!table) {
+    return tr;
+  }
+
+  const columnsToDelete = [];
+
+  for (let i = rect.left; i < rect.right; i++) {
+    columnsToDelete.push(i);
+  }
+
+  if (!columnsToDelete.length) {
+    return tr;
+  }
+
+  const map = TableMap.get(table.node);
+  const rows = [];
+  const seen = {};
+  const deletedCells = {};
+
+  for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
+    const rowCells = [];
+    const row = table.node.child(rowIndex);
+
+    for (let colIndex = 0; colIndex < map.width; colIndex++) {
+      const cellPos = map.map[rowIndex * map.width + colIndex];
+      const cell = table.node.nodeAt(cellPos);
+
+      if (!cell) {
+        continue;
+      }
+
+      const cellsInColumn = map.cellsInRect({
+        left: colIndex,
+        top: 0,
+        right: colIndex + 1,
+        bottom: map.height
+      });
+
+      if (columnsToDelete.indexOf(colIndex) === -1) {
+        // decrement colspans for col-spanning cells that overlap deleted columns
+        if (cellsInColumn.indexOf(cellPos) > -1 && !seen[cellPos]) {
+          let overlappingCols = 0;
+          columnsToDelete.forEach(colIndexToDelete => {
+            if (colIndex < colIndexToDelete && cell.attrs.colspan + colIndex - 1 >= colIndexToDelete) {
+              overlappingCols += 1;
+            }
+          });
+
+          if (overlappingCols > 0) {
+            const attrs = { ...cell.attrs,
+              colspan: cell.attrs.colspan - overlappingCols
+            };
+
+            if (cell.attrs.colwidth) {
+              const minColIndex = Math.min(...columnsToDelete);
+              const pos = minColIndex > 0 ? minColIndex - map.colCount(cellPos) : 0;
+              const colwidth = cell.attrs.colwidth.slice() || [];
+              colwidth.splice(pos, overlappingCols);
+              attrs.colwidth = colwidth;
+            }
+
+            const newCell = cell.type.createChecked(attrs, cell.content, cell.marks);
+            rowCells.push(newCell);
+            seen[cellPos] = true;
+            continue;
+          }
+        } else if (deletedCells[cellPos]) {
+          // if we're removing a col-spanning cell, we need to add missing cells to columns to the right
+          const attrs = { ...cell.attrs,
+            colspan: 1,
+            rowspan: 1
+          };
+
+          if (cell.attrs.colwidth) {
+            const pos = colIndex > 0 ? colIndex - map.colCount(cellPos) : 0;
+            attrs.colwidth = cell.attrs.colwidth.slice().splice(pos, 1);
+          }
+
+          const newCell = cell.type.createChecked(attrs, cell.type.schema.nodes.paragraph.createChecked(), cell.marks);
+          rowCells.push(newCell);
+          continue;
+        } // normal cells that we want to keep
+
+
+        if (!seen[cellPos]) {
+          seen[cellPos] = true;
+          rowCells.push(cell);
+        }
+      } else if (cellsInColumn.indexOf(cellPos) > -1) {
+        deletedCells[cellPos] = true;
+      }
+    }
+
+    if (rowCells.length) {
+      rows.push(row.type.createChecked(row.attrs, rowCells, row.marks));
+    }
+  }
+
+  if (!rows.length) {
+    return setMeta({
+      type: 'DELETE_COLUMNS',
+      problem: 'EMPTY_TABLE'
+    })(tr);
+  }
+
+  const newTable = table.node.type.createChecked(table.node.attrs, rows, table.node.marks);
+  const fixedTable = fixRowSpans(newTable);
+
+  if (fixedTable === null) {
+    return setMeta({
+      type: 'DELETE_COLUMNS',
+      problem: 'FIX_ROWSPANS'
+    })(tr);
+  }
+
+  const cursorPos = getNextCursorPos(newTable, columnsToDelete);
+  return setMeta({
+    type: 'DELETE_COLUMNS'
+  })(tr.replaceWith(table.pos, table.pos + table.node.nodeSize, fixedTable) // move cursor to the left of the deleted columns if possible, otherwise - to the first column
+  .setSelection(Selection.near(tr.doc.resolve(table.pos + cursorPos))));
+};
+
+function getNextCursorPos(table, deletedColumns) {
+  const minColumn = Math.min(...deletedColumns);
+  const nextColumnWithCursor = minColumn > 0 ? minColumn - 1 : 0;
+  const map = TableMap.get(table);
+  return map.map[nextColumnWithCursor];
+} // returns an array of numbers, each number indicates the minimum rowSpan in each row
+
+
+function getMinRowSpans(table) {
+  const minRowSpans = [];
+
+  for (let rowIndex = 0; rowIndex < table.childCount; rowIndex++) {
+    const rowSpans = [];
+    const row = table.child(rowIndex);
+
+    for (let colIndex = 0; colIndex < row.childCount; colIndex++) {
+      const cell = row.child(colIndex);
+      rowSpans.push(cell.attrs.rowspan);
+    }
+
+    minRowSpans[rowIndex] = Math.min(...rowSpans);
+  }
+
+  return minRowSpans;
+}
+
+function fixRowSpans(table) {
+  const map = TableMap.get(table);
+  const minRowSpans = getMinRowSpans(table);
+
+  if (!minRowSpans.some(rowspan => rowspan > 1)) {
+    return table;
+  }
+
+  const rows = [];
+
+  for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
+    const row = table.child(rowIndex);
+
+    if (minRowSpans[rowIndex] === 1) {
+      rows.push(row);
+    } else {
+      const rowCells = [];
+
+      for (let colIndex = 0; colIndex < row.childCount; colIndex++) {
+        const cell = row.child(colIndex);
+        const rowspan = cell.attrs.rowspan - minRowSpans[rowIndex] + 1;
+
+        if (rowspan < 1) {
+          return null;
+        }
+
+        const newCell = cell.type.createChecked({ ...cell.attrs,
+          rowspan
+        }, cell.content, cell.marks);
+        rowCells.push(newCell);
+      }
+
+      rows.push(row.type.createChecked(row.attrs, rowCells, row.marks));
+    }
+  }
+
+  if (!rows.length) {
+    return null;
+  }
+
+  return table.type.createChecked(table.attrs, rows, table.marks);
+}
+
+export const deleteColumns = (rect, allowAddColumnCustomStep = false) => tr => {
+  if (allowAddColumnCustomStep) {
+    return deleteColumnsCustomStep(rect)(tr);
+  }
+
+  return deleteColumnsLegacy(rect)(tr);
+};