@atlaskit/editor-tables 3.1.14 → 3.2.0

package/dist/cjs/utils/clone-row-at.js

@@ -0,0 +1,86 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cloneRowAt = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _utils = require("@atlaskit/editor-prosemirror/utils");
+var _tableMap = require("../table-map");
+var _findTable = require("./find-table");
+var _getCellsInRow = require("./get-cells-in-row");
+var _setCellAttrs = require("./set-cell-attrs");
+var _tableNodeTypes = require("./table-node-types");
+var filterCellsInRow = function filterCellsInRow(rowIndex, predicate) {
+  return function (tr) {
+    var foundCells = [];
+    var cells = (0, _getCellsInRow.getCellsInRow)(rowIndex)(tr.selection);
+    if (cells) {
+      for (var j = cells.length - 1; j >= 0; j--) {
+        if (predicate(cells[j], tr)) {
+          foundCells.push(cells[j]);
+        }
+      }
+    }
+    return foundCells;
+  };
+};
+
+// Returns a new transaction that adds a new row after `cloneRowIndex`, cloning the row attributes at `cloneRowIndex`.
+var cloneRowAt = exports.cloneRowAt = function cloneRowAt(rowIndex) {
+  return function (tr) {
+    var table = (0, _findTable.findTable)(tr.selection);
+    if (table) {
+      var map = _tableMap.TableMap.get(table.node);
+      if (rowIndex >= 0 && rowIndex <= map.height) {
+        var tableNode = table.node;
+        var tableNodes = (0, _tableNodeTypes.tableNodeTypes)(tableNode.type.schema);
+        var rowPos = table.start;
+        for (var i = 0; i < rowIndex + 1; i++) {
+          rowPos += tableNode.child(i).nodeSize;
+        }
+        var cloneRow = tableNode.child(rowIndex);
+        // Re-create the same nodes with same attrs, dropping the node content.
+        var cells = [];
+        var rowWidth = 0;
+        cloneRow.forEach(function (cell) {
+          // If we're copying a row with rowspan somewhere, we dont want to copy that cell
+          // We'll increment its span below.
+          if (cell.attrs.rowspan === 1) {
+            rowWidth += cell.attrs.colspan;
+            var node = tableNodes[cell.type.spec.tableRole].createAndFill(cell.attrs, [], cell.marks);
+            if (node) {
+              cells.push(node);
+            }
+          }
+        });
+
+        // If a higher row spans past our clone row, bump the higher row to cover this new row too.
+        if (rowWidth < map.width) {
+          var rowSpanCells = [];
+          var _loop = function _loop(_i) {
+            var foundCells = filterCellsInRow(_i, function (cell, _tr) {
+              var rowspan = cell.node.attrs.rowspan;
+              var spanRange = _i + rowspan;
+              return rowspan > 1 && spanRange > rowIndex;
+            })(tr);
+            rowSpanCells.push.apply(rowSpanCells, (0, _toConsumableArray2.default)(foundCells));
+          };
+          for (var _i = rowIndex; _i >= 0; _i--) {
+            _loop(_i);
+          }
+          if (rowSpanCells.length) {
+            rowSpanCells.forEach(function (cell) {
+              tr = (0, _setCellAttrs.setCellAttrs)(cell, {
+                rowspan: cell.node.attrs.rowspan + 1
+              })(tr);
+            });
+          }
+        }
+        return (0, _utils.safeInsert)(tableNodes.row.create(cloneRow.attrs, cells), rowPos)(tr);
+      }
+    }
+    return tr;
+  };
+};

package/dist/cjs/utils/clone-row.js

@@ -11,9 +11,9 @@ var _cellSelection = require("../cell-selection");
 var _tableMap = require("../table-map");
 var _analyseTable = require("./analyse-table");
 var _cloneTr = require("./clone-tr");
-var _find = require("./find");
+var _findTable = require("./find-table");
 var _getSelectionRangeInRow = require("./get-selection-range-in-row");
-var _reorderUtils = require("./reorder-utils");
+var _isValidReorder = require("./is-valid-reorder");
 var _tableNodeTypes = require("./table-node-types");
 function normalizeDirection(targetDirection, options) {
   var _options$direction;
@@ -27,7 +27,7 @@ var cloneRow = exports.cloneRow = function cloneRow(state, originRowIndex, targe
     selectAfterClone: false
   };
   return function (tr) {
-    var table = (0, _find.findTable)(tr.selection);
+    var table = (0, _findTable.findTable)(tr.selection);
     if (!table) {
       return tr;
     }
@@ -54,7 +54,7 @@ var cloneRow = exports.cloneRow = function cloneRow(state, originRowIndex, targe
       return tr;
     }
     if (!options.tryToFit && indexesTargetRow.length > 1) {
-      (0, _reorderUtils.isValidReorder)(originMin, targetRowIndex, indexesTargetRow, 'row');
+      (0, _isValidReorder.isValidReorder)(originMin, targetRowIndex, indexesTargetRow, 'row');
     }
     var types = (0, _tableNodeTypes.tableNodeTypes)(state.schema);
     var direction = normalizeDirection(targetDirection, options);

package/dist/cjs/utils/colspan.js

@@ -1,55 +1,26 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.addColSpan = addColSpan;
-exports.assertColspan = assertColspan;
-exports.removeColSpan = removeColSpan;
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function removeColSpan(attrs, pos) {
-  var n = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
-  if (!attrs.colspan) {
-    throw new Error('removeColSpan(): attrs.colspan not defined');
+Object.defineProperty(exports, "addColSpan", {
+  enumerable: true,
+  get: function get() {
+    return _addColSpan.addColSpan;
   }
-  var result = _objectSpread(_objectSpread({}, attrs), {}, {
-    colspan: attrs.colspan - n
-  });
-  if (result.colwidth) {
-    result.colwidth = result.colwidth.slice();
-    result.colwidth.splice(pos, n);
-    if (!result.colwidth.some(function (w) {
-      return w > 0;
-    })) {
-      result.colwidth = undefined;
-    }
-  }
-  return result;
-}
-function assertColspan(attrs) {
-  if (typeof attrs.colspan === 'undefined') {
-    throw new Error('addColSpan: attrs.colspan is not defined');
-  }
-  if (typeof attrs.colspan !== 'number' || Number.isNaN(attrs.colspan) || attrs.colspan < 1) {
-    throw new Error("addColSpan: attrs.colspan must be number >= 1, received: ".concat(attrs.colspan));
+});
+Object.defineProperty(exports, "assertColspan", {
+  enumerable: true,
+  get: function get() {
+    return _assertColspan.assertColspan;
   }
-}
-
-// TODO: ED-26961 - replace "addColSpan" from table plugin with this function
-function addColSpan(attrs, pos) {
-  var n = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
-  assertColspan(attrs);
-  var result = _objectSpread(_objectSpread({}, attrs), {}, {
-    colspan: attrs.colspan + n
-  });
-  if (result.colwidth) {
-    result.colwidth = result.colwidth.slice();
-    for (var i = 0; i < n; i++) {
-      result.colwidth.splice(pos, 0, 0);
-    }
+});
+Object.defineProperty(exports, "removeColSpan", {
+  enumerable: true,
+  get: function get() {
+    return _removeColSpan.removeColSpan;
   }
-  return result;
-}
+});
+var _removeColSpan = require("./remove-col-span");
+var _assertColspan = require("./assert-colspan");
+var _addColSpan = require("./add-col-span");

package/dist/cjs/utils/column-is-header.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.columnIsHeader = columnIsHeader;
+var _tableNodeTypes = require("./table-node-types");
+function columnIsHeader(map, table, col) {
+  var headerCell = (0, _tableNodeTypes.tableNodeTypes)(table.type.schema).header_cell;
+  for (var row = 0; row < map.height; row++) {
+    var cell = table.nodeAt(map.map[col + row * map.width]);
+    if (cell && cell.type !== headerCell) {
+      return false;
+    }
+  }
+  return true;
+}

package/dist/cjs/utils/convert-array-of-rows-to-table-node.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertArrayOfRowsToTableNode = void 0;
+var _tableMap = require("../table-map");
+// :: (tableNode: Node, tableArray: Array<Node>) -> Node
+// This function will transform a matrix of nodes
+// into table node respecting merged cells and rows configurations,
+// for example this array will be convert to the table below:
+//
+// ```javascript
+// array = [
+//   [A1, B1, C1, null],
+//   [A2, B2, null, D1],
+//   [A3. B3, C2, null],
+// ]
+// ```
+//
+// ```
+//  ____________________________
+// |      |      |             |
+// |  A1  |  B1  |     C1      |
+// |______|______|______ ______|
+// |      |             |      |
+// |  A2  |     B2      |      |
+// |______|______ ______|      |
+// |      |      |      |  D1  |
+// |  A3  |  B3  |  C2  |      |
+// |______|______|______|______|
+// ```
+//
+var convertArrayOfRowsToTableNode = exports.convertArrayOfRowsToTableNode = function convertArrayOfRowsToTableNode(tableNode, arrayOfNodes) {
+  var rowsPM = [];
+  var map = _tableMap.TableMap.get(tableNode);
+  for (var rowIndex = 0; rowIndex < map.height; rowIndex++) {
+    var row = tableNode.child(rowIndex);
+    var rowCells = [];
+    for (var colIndex = 0; colIndex < map.width; colIndex++) {
+      if (!arrayOfNodes[rowIndex][colIndex]) {
+        continue;
+      }
+      var cellPos = map.map[rowIndex * map.width + colIndex];
+      var cell = arrayOfNodes[rowIndex][colIndex];
+      var oldCell = tableNode.nodeAt(cellPos);
+      if (!cell || !oldCell) {
+        continue;
+      }
+      var newCell = oldCell.type.createChecked(Object.assign({}, cell.attrs), cell.content, cell.marks);
+      rowCells.push(newCell);
+    }
+    rowsPM.push(row.type.createChecked(row.attrs, rowCells, row.marks));
+  }
+  var newTable = tableNode.type.createChecked(tableNode.attrs, rowsPM, tableNode.marks);
+  return newTable;
+};

package/dist/cjs/utils/convert-table-node-to-array-of-rows.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertTableNodeToArrayOfRows = void 0;
+var _tableMap = require("../table-map");
+// :: (tableNode: Node) -> Array<Node>
+// This function will transform the table node
+// into a matrix of rows and columns respecting merged cells,
+// for example this table will be convert to the below:
+//
+// ```
+//  ____________________________
+// |      |      |             |
+// |  A1  |  B1  |     C1      |
+// |______|______|______ ______|
+// |      |             |      |
+// |  A2  |     B2      |      |
+// |______|______ ______|      |
+// |      |      |      |  D1  |
+// |  A3  |  B3  |  C2  |      |
+// |______|______|______|______|
+// ```
+//
+//
+// ```javascript
+// array = [
+//   [A1, B1, C1, null],
+//   [A2, B2, null, D1],
+//   [A3. B3, C2, null],
+// ]
+// ```
+var convertTableNodeToArrayOfRows = exports.convertTableNodeToArrayOfRows = function convertTableNodeToArrayOfRows(tableNode) {
+  var map = _tableMap.TableMap.get(tableNode);
+  var rows = [];
+  for (var rowIndex = 0; rowIndex < map.height; rowIndex++) {
+    var rowCells = [];
+    var seen = {};
+    for (var colIndex = 0; colIndex < map.width; colIndex++) {
+      var cellPos = map.map[rowIndex * map.width + colIndex];
+      var cell = tableNode.nodeAt(cellPos);
+      var rect = map.findCell(cellPos);
+      if (!cell || seen[cellPos] || rect.top !== rowIndex) {
+        rowCells.push(null);
+        continue;
+      }
+      seen[cellPos] = true;
+      rowCells.push(cell);
+    }
+    rows.push(rowCells);
+  }
+  return rows;
+};

package/dist/cjs/utils/find-cell-closest-to-pos.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findCellClosestToPos = void 0;
+var _utils = require("@atlaskit/editor-prosemirror/utils");
+// Ignored via go/ees005
+// eslint-disable-next-line require-unicode-regexp
+var CELL_ROLE_REGEX = /cell/i;
+
+// Iterates over parent nodes, returning a table cell or a table header node closest to a given `$pos`.
+var findCellClosestToPos = exports.findCellClosestToPos = function findCellClosestToPos($pos) {
+  var predicate = function predicate(node) {
+    return node.type.spec.tableRole && CELL_ROLE_REGEX.test(node.type.spec.tableRole);
+  };
+  return (0, _utils.findParentNodeClosestToPos)($pos, predicate);
+};

package/dist/cjs/utils/find-cell-rect-closest-to-pos.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findCellRectClosestToPos = void 0;
+var _tableMap = require("../table-map");
+var _findCellClosestToPos = require("./find-cell-closest-to-pos");
+var _findTableClosestToPos = require("./find-table-closest-to-pos");
+// Returns the rectangle spanning a cell closest to a given `$pos`.
+var findCellRectClosestToPos = exports.findCellRectClosestToPos = function findCellRectClosestToPos($pos) {
+  var cell = (0, _findCellClosestToPos.findCellClosestToPos)($pos);
+  if (cell) {
+    var table = (0, _findTableClosestToPos.findTableClosestToPos)($pos);
+    if (table) {
+      var map = _tableMap.TableMap.get(table.node);
+      var cellPos = cell.pos - table.start;
+      return map.rectBetween(cellPos, cellPos);
+    }
+  }
+};

package/dist/cjs/utils/find-table-closest-to-pos.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findTableClosestToPos = void 0;
+var _utils = require("@atlaskit/editor-prosemirror/utils");
+// Iterates over parent nodes, returning a table node closest to a given `$pos`.
+var findTableClosestToPos = exports.findTableClosestToPos = function findTableClosestToPos($pos) {
+  var predicate = function predicate(node) {
+    return node.type.spec.tableRole && node.type.spec.tableRole === 'table';
+  };
+  return (0, _utils.findParentNodeClosestToPos)($pos, predicate);
+};

package/dist/cjs/utils/find-table.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findTable = void 0;
+var _utils = require("@atlaskit/editor-prosemirror/utils");
+// Iterates over parent nodes, returning the closest table node.
+var findTable = exports.findTable = function findTable(selection) {
+  return (0, _utils.findParentNode)(function (node) {
+    return node.type.spec.tableRole && node.type.spec.tableRole === 'table';
+  })(selection);
+};

package/dist/cjs/utils/find.js

@@ -3,45 +3,31 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.findTableClosestToPos = exports.findTable = exports.findCellRectClosestToPos = exports.findCellClosestToPos = void 0;
-var _utils = require("@atlaskit/editor-prosemirror/utils");
-var _tableMap = require("../table-map");
-// Ignored via go/ees005
-// eslint-disable-next-line require-unicode-regexp
-var CELL_ROLE_REGEX = /cell/i;
-
-// Iterates over parent nodes, returning the closest table node.
-var findTable = exports.findTable = function findTable(selection) {
-  return (0, _utils.findParentNode)(function (node) {
-    return node.type.spec.tableRole && node.type.spec.tableRole === 'table';
-  })(selection);
-};
-
-// Iterates over parent nodes, returning a table node closest to a given `$pos`.
-var findTableClosestToPos = exports.findTableClosestToPos = function findTableClosestToPos($pos) {
-  var predicate = function predicate(node) {
-    return node.type.spec.tableRole && node.type.spec.tableRole === 'table';
-  };
-  return (0, _utils.findParentNodeClosestToPos)($pos, predicate);
-};
-
-// Iterates over parent nodes, returning a table cell or a table header node closest to a given `$pos`.
-var findCellClosestToPos = exports.findCellClosestToPos = function findCellClosestToPos($pos) {
-  var predicate = function predicate(node) {
-    return node.type.spec.tableRole && CELL_ROLE_REGEX.test(node.type.spec.tableRole);
-  };
-  return (0, _utils.findParentNodeClosestToPos)($pos, predicate);
-};
-
-// Returns the rectangle spanning a cell closest to a given `$pos`.
-var findCellRectClosestToPos = exports.findCellRectClosestToPos = function findCellRectClosestToPos($pos) {
-  var cell = findCellClosestToPos($pos);
-  if (cell) {
-    var table = findTableClosestToPos($pos);
-    if (table) {
-      var map = _tableMap.TableMap.get(table.node);
-      var cellPos = cell.pos - table.start;
-      return map.rectBetween(cellPos, cellPos);
-    }
+Object.defineProperty(exports, "findCellClosestToPos", {
+  enumerable: true,
+  get: function get() {
+    return _findCellClosestToPos.findCellClosestToPos;
+  }
+});
+Object.defineProperty(exports, "findCellRectClosestToPos", {
+  enumerable: true,
+  get: function get() {
+    return _findCellRectClosestToPos.findCellRectClosestToPos;
   }
-};
+});
+Object.defineProperty(exports, "findTable", {
+  enumerable: true,
+  get: function get() {
+    return _findTable.findTable;
+  }
+});
+Object.defineProperty(exports, "findTableClosestToPos", {
+  enumerable: true,
+  get: function get() {
+    return _findTableClosestToPos.findTableClosestToPos;
+  }
+});
+var _findTable = require("./find-table");
+var _findTableClosestToPos = require("./find-table-closest-to-pos");
+var _findCellClosestToPos = require("./find-cell-closest-to-pos");
+var _findCellRectClosestToPos = require("./find-cell-rect-closest-to-pos");

package/dist/cjs/utils/fit-slice.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fitSlice = fitSlice;
+var _transform = require("@atlaskit/editor-prosemirror/transform");
+// 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.
+
+function fitSlice(nodeType, slice) {
+  var node = nodeType.createAndFill();
+  if (!node) {
+    throw new Error("fitSlice: unable to create node");
+  }
+  var tr = new _transform.Transform(node).replace(0, node.content.size, slice);
+  return tr.doc;
+}

package/dist/cjs/utils/fix-table.js

@@ -0,0 +1,112 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fixTable = fixTable;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _pluginKey = require("../pm-plugins/plugin-key");
+var _tableMap = require("../table-map");
+var _removeColSpan = require("./remove-col-span");
+var _tableNodeTypes = require("./table-node-types");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// : (EditorState, Node, number, ?Transaction) → ?Transaction
+// Fix the given table, if necessary. Will append to the transaction
+// it was given, if non-null, or create a new one if necessary.
+function fixTable(state, table, tablePos, transaction, reportFixedTable) {
+  var tr = transaction;
+  var map = _tableMap.TableMap.get(table);
+  if (!map.problems) {
+    return tr;
+  }
+  if (!tr) {
+    tr = state.tr;
+  }
+
+  // Track which rows we must add cells to, so that we can adjust that
+  // when fixing collisions.
+  var mustAdd = [];
+  for (var i = 0; i < map.height; i++) {
+    mustAdd.push(0);
+  }
+  for (var _i = 0; _i < map.problems.length; _i++) {
+    var prob = map.problems[_i];
+    if (reportFixedTable) {
+      reportFixedTable({
+        state: state,
+        tr: tr,
+        reason: prob.type || 'unknown'
+      });
+    }
+    if (prob.type === _tableMap.TableProblemTypes.COLLISION) {
+      var collision = prob;
+      var cell = table.nodeAt(prob.pos);
+      if (!cell) {
+        throw new Error("fixTable: unable to find cell at pos ".concat(prob.pos));
+      }
+      for (var j = 0; j < cell.attrs.rowspan; j++) {
+        mustAdd[collision.row + j] += collision.n;
+      }
+      tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + prob.pos), undefined, (0, _removeColSpan.removeColSpan)(cell.attrs, cell.attrs.colspan - collision.n, collision.n));
+    } else if (prob.type === _tableMap.TableProblemTypes.MISSING) {
+      var missing = prob;
+      mustAdd[missing.row] += missing.n;
+    } else if (prob.type === _tableMap.TableProblemTypes.OVERLONG_ROWSPAN) {
+      var overlong = prob;
+      var _cell = table.nodeAt(overlong.pos);
+      if (!_cell) {
+        throw new Error("fixTable: unable to find cell at pos ".concat(prob.pos));
+      }
+      tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + overlong.pos), undefined, _objectSpread(_objectSpread({}, _cell.attrs), {}, {
+        rowspan: _cell.attrs.rowspan - overlong.n
+      }));
+    } else if (prob.type === _tableMap.TableProblemTypes.COLWIDTH_MISMATCH) {
+      var _cell2 = table.nodeAt(prob.pos);
+      if (!_cell2) {
+        throw new Error("fixTable: unable to find cell at pos ".concat(prob.pos));
+      }
+      tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + prob.pos), undefined, _objectSpread(_objectSpread({}, _cell2.attrs), {}, {
+        colwidth: prob.colwidth
+      }));
+    }
+  }
+  var first;
+  var last;
+  for (var _i2 = 0; _i2 < mustAdd.length; _i2++) {
+    if (mustAdd[_i2]) {
+      if (first == null) {
+        first = _i2;
+      }
+      last = _i2;
+    }
+  }
+  // Add the necessary cells, using a heuristic for whether to add the
+  // cells at the start or end of the rows (if it looks like a 'bite'
+  // was taken out of the table, add cells at the start of the row
+  // after the bite. Otherwise add them at the end).
+  for (var _i3 = 0, pos = tablePos + 1; _i3 < map.height; _i3++) {
+    var row = table.child(_i3);
+    var end = pos + row.nodeSize;
+    var add = mustAdd[_i3];
+    if (add > 0) {
+      var tableNodeType = 'cell';
+      if (row.firstChild) {
+        tableNodeType = row.firstChild.type.spec.tableRole;
+      }
+      var nodes = [];
+      for (var _j = 0; _j < add; _j++) {
+        // Ignored via go/ees005
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        nodes.push((0, _tableNodeTypes.tableNodeTypes)(state.schema)[tableNodeType].createAndFill());
+      }
+      var side = (_i3 === 0 || first === _i3 - 1) && last === _i3 ? pos + 1 : end - 1;
+      tr.insert(tr.mapping.map(side), nodes);
+    }
+    pos = end;
+  }
+  return tr.setMeta(_pluginKey.fixTablesKey, {
+    fixTables: true
+  });
+}