@atlaskit/editor-plugin-table 0.0.0 → 0.0.1

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

@@ -0,0 +1,271 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+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';
+
+var deleteColumnsCustomStep = function deleteColumnsCustomStep(rect) {
+  return function (tr) {
+    var 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
+
+    var mapStart = tr.mapping.maps.length;
+    var originalDoc = tr.doc;
+    var deletedColumns = [];
+
+    for (var i = rect.left; i < rect.right; i++) {
+      var step = AddColumnStep.create(originalDoc, table.pos, i, true);
+      deletedColumns.push(i);
+      tr.step(step.map(tr.mapping.slice(mapStart)));
+    }
+
+    var tablePosResult = tr.mapping.mapResult(table.pos);
+
+    if (tablePosResult.deleted) {
+      var pos = Math.min(tablePosResult.pos, tr.doc.nodeSize - 1);
+      tr.setSelection(Selection.near(tr.doc.resolve(pos)));
+    } else {
+      var newTable = tr.doc.nodeAt(tablePosResult.pos);
+
+      if (newTable) {
+        var cursorPos = getNextCursorPos(newTable, deletedColumns);
+        tr.setSelection(Selection.near(tr.doc.resolve(table.pos + cursorPos)));
+      }
+    }
+
+    return tr;
+  };
+};
+
+var deleteColumnsLegacy = function deleteColumnsLegacy(rect) {
+  return function (tr) {
+    var table = findTable(tr.selection);
+
+    if (!table) {
+      return tr;
+    }
+
+    var columnsToDelete = [];
+
+    for (var i = rect.left; i < rect.right; i++) {
+      columnsToDelete.push(i);
+    }
+
+    if (!columnsToDelete.length) {
+      return tr;
+    }
+
+    var map = TableMap.get(table.node);
+    var rows = [];
+    var seen = {};
+    var deletedCells = {};
+
+    for (var rowIndex = 0; rowIndex < map.height; rowIndex++) {
+      var rowCells = [];
+      var row = table.node.child(rowIndex);
+
+      var _loop = function _loop(colIndex) {
+        var cellPos = map.map[rowIndex * map.width + colIndex];
+        var cell = table.node.nodeAt(cellPos);
+
+        if (!cell) {
+          return "continue";
+        }
+
+        var 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]) {
+            var overlappingCols = 0;
+            columnsToDelete.forEach(function (colIndexToDelete) {
+              if (colIndex < colIndexToDelete && cell.attrs.colspan + colIndex - 1 >= colIndexToDelete) {
+                overlappingCols += 1;
+              }
+            });
+
+            if (overlappingCols > 0) {
+              var attrs = _objectSpread(_objectSpread({}, cell.attrs), {}, {
+                colspan: cell.attrs.colspan - overlappingCols
+              });
+
+              if (cell.attrs.colwidth) {
+                var minColIndex = Math.min.apply(Math, columnsToDelete);
+                var pos = minColIndex > 0 ? minColIndex - map.colCount(cellPos) : 0;
+                var colwidth = cell.attrs.colwidth.slice() || [];
+                colwidth.splice(pos, overlappingCols);
+                attrs.colwidth = colwidth;
+              }
+
+              var newCell = cell.type.createChecked(attrs, cell.content, cell.marks);
+              rowCells.push(newCell);
+              seen[cellPos] = true;
+              return "continue";
+            }
+          } else if (deletedCells[cellPos]) {
+            // if we're removing a col-spanning cell, we need to add missing cells to columns to the right
+            var _attrs = _objectSpread(_objectSpread({}, cell.attrs), {}, {
+              colspan: 1,
+              rowspan: 1
+            });
+
+            if (cell.attrs.colwidth) {
+              var _pos = colIndex > 0 ? colIndex - map.colCount(cellPos) : 0;
+
+              _attrs.colwidth = cell.attrs.colwidth.slice().splice(_pos, 1);
+            }
+
+            var _newCell = cell.type.createChecked(_attrs, cell.type.schema.nodes.paragraph.createChecked(), cell.marks);
+
+            rowCells.push(_newCell);
+            return "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;
+        }
+      };
+
+      for (var colIndex = 0; colIndex < map.width; colIndex++) {
+        var _ret = _loop(colIndex);
+
+        if (_ret === "continue") continue;
+      }
+
+      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);
+    }
+
+    var newTable = table.node.type.createChecked(table.node.attrs, rows, table.node.marks);
+    var fixedTable = fixRowSpans(newTable);
+
+    if (fixedTable === null) {
+      return setMeta({
+        type: 'DELETE_COLUMNS',
+        problem: 'FIX_ROWSPANS'
+      })(tr);
+    }
+
+    var 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) {
+  var minColumn = Math.min.apply(Math, _toConsumableArray(deletedColumns));
+  var nextColumnWithCursor = minColumn > 0 ? minColumn - 1 : 0;
+  var 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) {
+  var minRowSpans = [];
+
+  for (var rowIndex = 0; rowIndex < table.childCount; rowIndex++) {
+    var rowSpans = [];
+    var row = table.child(rowIndex);
+
+    for (var colIndex = 0; colIndex < row.childCount; colIndex++) {
+      var cell = row.child(colIndex);
+      rowSpans.push(cell.attrs.rowspan);
+    }
+
+    minRowSpans[rowIndex] = Math.min.apply(Math, rowSpans);
+  }
+
+  return minRowSpans;
+}
+
+function fixRowSpans(table) {
+  var map = TableMap.get(table);
+  var minRowSpans = getMinRowSpans(table);
+
+  if (!minRowSpans.some(function (rowspan) {
+    return rowspan > 1;
+  })) {
+    return table;
+  }
+
+  var rows = [];
+
+  for (var rowIndex = 0; rowIndex < map.height; rowIndex++) {
+    var row = table.child(rowIndex);
+
+    if (minRowSpans[rowIndex] === 1) {
+      rows.push(row);
+    } else {
+      var rowCells = [];
+
+      for (var colIndex = 0; colIndex < row.childCount; colIndex++) {
+        var cell = row.child(colIndex);
+        var rowspan = cell.attrs.rowspan - minRowSpans[rowIndex] + 1;
+
+        if (rowspan < 1) {
+          return null;
+        }
+
+        var newCell = cell.type.createChecked(_objectSpread(_objectSpread({}, cell.attrs), {}, {
+          rowspan: 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 var deleteColumns = function deleteColumns(rect) {
+  var allowAddColumnCustomStep = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  return function (tr) {
+    if (allowAddColumnCustomStep) {
+      return deleteColumnsCustomStep(rect)(tr);
+    }
+
+    return deleteColumnsLegacy(rect)(tr);
+  };
+};

package/dist/esm/plugins/table/transforms/delete-rows.js

@@ -0,0 +1,156 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import { Selection } from 'prosemirror-state';
+import { TableMap } from '@atlaskit/editor-tables/table-map';
+import { findTable } from '@atlaskit/editor-tables/utils';
+import { removeEmptyColumns } from './merge';
+import { setMeta } from './metadata';
+export var deleteRows = function deleteRows(rect) {
+  var isHeaderRowRequired = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  return function (tr) {
+    var table = findTable(tr.selection);
+
+    if (!table) {
+      return tr;
+    }
+
+    var rowsToDelete = [];
+    var map = TableMap.get(table.node);
+
+    for (var i = rect.top; i < rect.bottom; i++) {
+      // skip header row if its required
+      if (isHeaderRowRequired) {
+        var cell = table.node.nodeAt(map.map[i * map.width]);
+
+        if (cell && cell.type !== cell.type.schema.nodes.tableHeader) {
+          rowsToDelete.push(i);
+        }
+      } else {
+        rowsToDelete.push(i);
+      }
+    }
+
+    if (!rowsToDelete.length) {
+      return tr;
+    }
+
+    var rows = [];
+    var seen = {};
+    var deletedCells = {};
+
+    var _loop = function _loop(rowIndex) {
+      var rowCells = [];
+      var row = table.node.child(rowIndex);
+
+      var _loop2 = function _loop2(colIndex) {
+        var cellPos = map.map[rowIndex * map.width + colIndex];
+        var cell = table.node.nodeAt(cellPos);
+
+        if (!cell) {
+          return "continue";
+        }
+
+        var cellsInRow = map.cellsInRect({
+          left: 0,
+          top: rowIndex,
+          right: map.width,
+          bottom: rowIndex + 1
+        });
+
+        if (rowsToDelete.indexOf(rowIndex) === -1 && !seen[cellPos]) {
+          // decrement rowspans for row-spanning cells that overlap deleted rows
+          if (cellsInRow.indexOf(cellPos) > -1) {
+            var overlappingRows = 0;
+            rowsToDelete.forEach(function (rowIndexToDelete) {
+              if (rowIndex < rowIndexToDelete && cell.attrs.rowspan + rowIndex - 1 >= rowIndexToDelete) {
+                overlappingRows += 1;
+              }
+            });
+
+            if (overlappingRows > 0) {
+              var newCell = cell.type.createChecked(_objectSpread(_objectSpread({}, cell.attrs), {}, {
+                rowspan: cell.attrs.rowspan - overlappingRows
+              }), cell.content, cell.marks);
+              rowCells.push(newCell);
+              seen[cellPos] = true;
+              return "continue";
+            }
+          } else if (deletedCells[cellPos]) {
+            // if we're removing a row-spanning cell, we need to add missing cells to rows below
+            var attrs = _objectSpread(_objectSpread({}, cell.attrs), {}, {
+              colspan: 1,
+              rowspan: 1
+            });
+
+            if (cell.attrs.colwidth) {
+              var pos = colIndex > 0 ? colIndex - map.colCount(cellPos) : 0;
+              attrs.colwidth = cell.attrs.colwidth.slice().splice(pos, 1);
+            }
+
+            var _newCell = cell.type.createChecked(attrs, cell.type.schema.nodes.paragraph.createChecked(), cell.marks);
+
+            rowCells.push(_newCell);
+            return "continue";
+          } // normal cells that we want to keep
+
+
+          if (!seen[cellPos]) {
+            seen[cellPos] = true;
+            rowCells.push(cell);
+          }
+        } else if (cellsInRow.indexOf(cellPos) > -1) {
+          deletedCells[cellPos] = true;
+        }
+      };
+
+      for (var colIndex = 0; colIndex < map.width; colIndex++) {
+        var _ret = _loop2(colIndex);
+
+        if (_ret === "continue") continue;
+      }
+
+      if (rowCells.length) {
+        rows.push(row.type.createChecked(row.attrs, rowCells, row.marks));
+      }
+    };
+
+    for (var rowIndex = 0; rowIndex < map.height; rowIndex++) {
+      _loop(rowIndex);
+    }
+
+    if (!rows.length) {
+      return setMeta({
+        type: 'DELETE_ROWS',
+        problem: 'EMPTY_TABLE'
+      })(tr);
+    }
+
+    var newTable = table.node.type.createChecked(table.node.attrs, rows, table.node.marks);
+    var fixedTable = removeEmptyColumns(newTable);
+
+    if (fixedTable === null) {
+      return setMeta({
+        type: 'DELETE_ROWS',
+        problem: 'REMOVE_EMPTY_COLUMNS'
+      })(tr);
+    }
+
+    var cursorPos = getNextCursorPos(newTable, rowsToDelete);
+    return setMeta({
+      type: 'DELETE_ROWS'
+    })(tr.replaceWith(table.pos, table.pos + table.node.nodeSize, fixedTable) // move cursor before the deleted rows if possible, otherwise - to the first row
+    .setSelection(Selection.near(tr.doc.resolve(table.pos + cursorPos))));
+  };
+};
+
+function getNextCursorPos(table, deletedRows) {
+  var minRow = Math.min.apply(Math, _toConsumableArray(deletedRows));
+  var nextRowWithCursor = minRow > 0 ? minRow - 1 : 0;
+  var map = TableMap.get(table);
+  return map.map[nextRowWithCursor * map.width];
+}

package/dist/esm/plugins/table/transforms/fix-tables.js

@@ -0,0 +1,229 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import { tableCellMinWidth } from '@atlaskit/editor-common/styles';
+import { akEditorDefaultLayoutWidth, akEditorWideLayoutWidth } from '@atlaskit/editor-shared-styles'; // import { sendLogs } from '../../../utils/sendLogs';
+// import { sendLogs } from '@atlaskit/editor-core/src/utils/sendLogs';
+
+import { sendLogs } from '../todo-stubs';
+import { calculateColumnWidth, contentWidth, getCellsRefsInColumn, getLayoutSize } from '../pm-plugins/table-resizing/utils';
+export var fireAnalytics = function fireAnalytics() {
+  var properties = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return sendLogs({
+    events: [{
+      name: 'atlaskit.fabric.editor.fixtable',
+      product: 'atlaskit',
+      properties: properties,
+      serverTime: new Date().getTime(),
+      server: 'local',
+      user: '-'
+    }]
+  });
+};
+
+var validateTableCellNodeAttrs = function validateTableCellNodeAttrs(_ref, reportInvalidTableCellSpanAttrs) {
+  var colspan = _ref.colspan,
+      rowspan = _ref.rowspan,
+      tableLocalId = _ref.tableLocalId;
+
+  if (colspan && colspan < 0) {
+    reportInvalidTableCellSpanAttrs({
+      nodeType: 'tableCell',
+      attribute: 'colspan',
+      reason: 'negative value',
+      tableLocalId: tableLocalId,
+      spanValue: colspan
+    });
+  }
+
+  if (rowspan && rowspan < 0) {
+    reportInvalidTableCellSpanAttrs({
+      nodeType: 'tableCell',
+      attribute: 'rowspan',
+      reason: 'negative value',
+      tableLocalId: tableLocalId,
+      spanValue: rowspan
+    });
+  }
+
+  return;
+}; // We attempt to patch the document when we have extra, unneeded, column widths
+// Take this node for example:
+//
+//    ['td', { colwidth: [100, 100, 100], colspan: 2 }]
+//
+// This row only spans two columns, yet it contains widths for 3.
+// We remove the third width here, assumed duplicate content.
+
+
+export var removeExtraneousColumnWidths = function removeExtraneousColumnWidths(node, basePos, tr, reportInvalidTableCellSpanAttrs) {
+  var hasProblems = false;
+  tr = replaceCells(tr, node, basePos, function (cell) {
+    var _cell$attrs = cell.attrs,
+        colwidth = _cell$attrs.colwidth,
+        colspan = _cell$attrs.colspan,
+        rowspan = _cell$attrs.rowspan;
+
+    if (reportInvalidTableCellSpanAttrs) {
+      validateTableCellNodeAttrs({
+        colspan: colspan,
+        rowspan: rowspan,
+        tableLocalId: node.attrs.localId
+      }, reportInvalidTableCellSpanAttrs);
+    }
+
+    if (colwidth && colwidth.length > colspan) {
+      hasProblems = true;
+      return cell.type.createChecked(_objectSpread(_objectSpread({}, cell.attrs), {}, {
+        colwidth: colwidth.slice(0, colspan)
+      }), cell.content, cell.marks);
+    }
+
+    return cell;
+  });
+
+  if (hasProblems) {
+    fireAnalytics({
+      message: 'removeExtraneousColumnWidths'
+    });
+    return true;
+  }
+
+  return false;
+};
+export var fixTables = function fixTables(tr, reportInvalidTableCellSpanAttrs) {
+  var hasProblems = false;
+  tr.doc.descendants(function (node, pos) {
+    if (node.type.name === 'table') {
+      // in the unlikely event of having to fix multiple tables at the same time
+      hasProblems = removeExtraneousColumnWidths(node, tr.mapping.map(pos), tr, reportInvalidTableCellSpanAttrs);
+    }
+  });
+
+  if (hasProblems) {
+    return tr;
+  }
+}; // When we get a table with an 'auto' attribute, we want to:
+// 1. render with table-layout: auto
+// 2. capture the column widths
+// 3. set the column widths as attributes, and remove the 'auto' attribute,
+//    so the table renders the same, but is now fixed-width
+//
+// This can be used to migrate table appearances from other sources that are
+// usually rendered with 'auto'.
+//
+// We use this when migrating TinyMCE tables for Confluence, for example:
+// https://pug.jira-dev.com/wiki/spaces/AEC/pages/3362882215/How+do+we+map+TinyMCE+tables+to+Fabric+tables
+
+export var fixAutoSizedTable = function fixAutoSizedTable(view, tableNode, tableRef, tablePos, opts) {
+  var tr = view.state.tr;
+  var domAtPos = view.domAtPos.bind(view);
+  var tableStart = tablePos + 1;
+  var colWidths = parseDOMColumnWidths(domAtPos, tableNode, tableStart, tableRef);
+  var totalContentWidth = colWidths.reduce(function (acc, current) {
+    return acc + current;
+  }, 0);
+  var tableLayout = getLayoutBasedOnWidth(totalContentWidth);
+  var maxLayoutSize = getLayoutSize(tableLayout, opts.containerWidth, {}); // Content width will generally not meet the constraints of the layout
+  // whether it be below or above, so we scale our columns widths
+  // to meet these requirements
+
+  var scale = 1;
+
+  if (totalContentWidth !== maxLayoutSize) {
+    scale = maxLayoutSize / totalContentWidth;
+  }
+
+  var scaledColumnWidths = colWidths.map(function (width) {
+    return Math.floor(width * scale);
+  });
+  tr = replaceCells(tr, tableNode, tablePos, function (cell, _rowIndex, colIndex) {
+    var newColWidths = scaledColumnWidths.slice(colIndex, colIndex + cell.attrs.colspan);
+    return cell.type.createChecked(_objectSpread(_objectSpread({}, cell.attrs), {}, {
+      colwidth: newColWidths.length ? newColWidths : null
+    }), cell.content, cell.marks);
+  }); // clear autosizing on the table node
+
+  return tr.setNodeMarkup(tablePos, undefined, _objectSpread(_objectSpread({}, tableNode.attrs), {}, {
+    layout: tableLayout,
+    __autoSize: false
+  })).setMeta('addToHistory', false);
+};
+
+var getLayoutBasedOnWidth = function getLayoutBasedOnWidth(totalWidth) {
+  if (totalWidth > akEditorWideLayoutWidth) {
+    return 'full-width';
+  } else if (totalWidth > akEditorDefaultLayoutWidth && totalWidth < akEditorWideLayoutWidth) {
+    return 'wide';
+  } else {
+    return 'default';
+  }
+};
+
+function parseDOMColumnWidths(domAtPos, tableNode, tableStart, tableRef) {
+  var row = tableRef.querySelector('tr');
+
+  if (!row) {
+    return [];
+  }
+
+  var cols = [];
+
+  for (var col = 0; col < row.childElementCount; col++) {
+    var currentCol = row.children[col];
+    var colspan = Number(currentCol.getAttribute('colspan') || 1);
+
+    for (var span = 0; span < colspan; span++) {
+      var colIdx = col + span;
+      var cells = getCellsRefsInColumn(colIdx, tableNode, tableStart, domAtPos);
+      var colWidth = calculateColumnWidth(cells, function (_, col) {
+        return contentWidth(col, tableRef).width;
+      });
+      cols[colIdx] = Math.max(colWidth, tableCellMinWidth);
+    }
+  }
+
+  return cols;
+} // TODO: move to prosemirror-utils
+
+
+var replaceCells = function replaceCells(tr, table, tablePos, modifyCell) {
+  var rows = [];
+  var modifiedCells = 0;
+
+  for (var _rowIndex2 = 0; _rowIndex2 < table.childCount; _rowIndex2++) {
+    var row = table.child(_rowIndex2);
+    var cells = [];
+
+    for (var _colIndex = 0; _colIndex < row.childCount; _colIndex++) {
+      var _cell = row.child(_colIndex); // FIXME
+      // The rowIndex and colIndex are not accurate in a merged cell scenario
+      // e.g. table with 5 columns might have only one cell in a row, colIndex will be 1, where it should be 4
+
+
+      var node = modifyCell(_cell, _rowIndex2, _colIndex);
+
+      if (node.sameMarkup(_cell) === false) {
+        modifiedCells++;
+      }
+
+      cells.push(node);
+    }
+
+    if (cells.length) {
+      rows.push(row.type.createChecked(row.attrs, cells, row.marks));
+    }
+  } // Check if the table has changed before replacing.
+  // If no cells are modified our counter will be zero.
+
+
+  if (rows.length && modifiedCells !== 0) {
+    var newTable = table.type.createChecked(table.attrs, rows, table.marks);
+    return tr.replaceWith(tablePos, tablePos + table.nodeSize, newTable);
+  }
+
+  return tr;
+};

package/dist/esm/plugins/table/transforms/index.js

@@ -0,0 +1,7 @@
+export { mergeCells, canMergeCells, removeEmptyColumns } from './merge';
+export { fireAnalytics, fixTables, fixAutoSizedTable } from './fix-tables';
+export { deleteColumns } from './delete-columns';
+export { deleteRows } from './delete-rows';
+export { updateColumnWidths } from './column-width';
+export { setMeta } from './metadata';
+export { replaceSelectedTable } from './replace-table';