@atlaskit/editor-tables 3.1.14 → 3.2.0

package/dist/esm/utils/changed-descendants.js

@@ -0,0 +1,27 @@
+// Helper for iterating through the nodes in a document that changed
+// compared to the given previous document. Useful for avoiding
+// duplicate work on each transaction.
+export function changedDescendants(old, cur, offsetStart, f) {
+  var offset = offsetStart;
+  var oldSize = old.childCount;
+  var curSize = cur.childCount;
+  // eslint-disable-next-line no-labels
+  outer: for (var i = 0, j = 0; i < curSize; i++) {
+    var child = cur.child(i);
+    for (var scan = j, e = Math.min(oldSize, i + 3); scan < e; scan++) {
+      if (old.child(scan) === child) {
+        j = scan + 1;
+        offset += child.nodeSize;
+        // eslint-disable-next-line no-continue, no-labels
+        continue outer;
+      }
+    }
+    f(child, offset);
+    if (j < oldSize && old.child(j).sameMarkup(child)) {
+      changedDescendants(old.child(j), child, offset + 1, f);
+    } else {
+      child.nodesBetween(0, child.content.size, f, offset + 1);
+    }
+    offset += child.nodeSize;
+  }
+}

package/dist/esm/utils/clip-cells.js

@@ -0,0 +1,76 @@
+import _defineProperty from "@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) { _defineProperty(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; }
+// 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 } from '@atlaskit/editor-prosemirror/model';
+import { removeColSpan } from './remove-col-span';
+
+// : ({width: number, height: number, rows: [Fragment]}, number, number) → {width: number, height: number, rows: [Fragment]}
+// Clip or extend (repeat) the given set of cells to cover the given
+// width and height. Will clip rowspan/colspan cells at the edges when
+// they stick out.
+export function clipCells(_ref, newWidth, newHeight) {
+  var currentWidth = _ref.width,
+    currentHeight = _ref.height,
+    currentRows = _ref.rows;
+  var rows = currentRows;
+  var width = currentWidth;
+  var height = currentHeight;
+  if (width !== newWidth) {
+    var added = [];
+    var newRows = [];
+    for (var row = 0; row < rows.length; row++) {
+      var frag = rows[row];
+      var cells = [];
+      for (var col = added[row] || 0, i = 0; col < newWidth; i++) {
+        var cell = frag.child(i % frag.childCount);
+        if (col + cell.attrs.colspan > newWidth) {
+          cell = cell.type.create(removeColSpan(cell.attrs, cell.attrs.colspan, col + cell.attrs.colspan - newWidth), cell.content);
+        }
+        cells.push(cell);
+        col += cell.attrs.colspan;
+        for (var j = 1; j < cell.attrs.rowspan; j++) {
+          added[row + j] = (added[row + j] || 0) + cell.attrs.colspan;
+        }
+      }
+      newRows.push(Fragment.from(cells));
+    }
+    rows = newRows;
+    width = newWidth;
+  }
+  if (height !== newHeight) {
+    var _newRows = [];
+    for (var _row = 0, _i = 0; _row < newHeight; _row++, _i++) {
+      var _cells = [];
+      var source = rows[_i % height];
+      for (var _j = 0; _j < source.childCount; _j++) {
+        var _cell = source.child(_j);
+        if (_row + _cell.attrs.rowspan > newHeight) {
+          _cell = _cell.type.create(_objectSpread(_objectSpread({}, _cell.attrs), {}, {
+            rowspan: Math.max(1, newHeight - _cell.attrs.rowspan)
+          }), _cell.content);
+        }
+        _cells.push(_cell);
+      }
+      _newRows.push(Fragment.from(_cells));
+    }
+    rows = _newRows;
+    height = newHeight;
+  }
+  return {
+    width: width,
+    height: height,
+    rows: rows
+  };
+}

package/dist/esm/utils/clone-column.js

@@ -3,9 +3,9 @@ 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 './reorder-utils';
+import { isValidReorder } from './is-valid-reorder';
 import { tableNodeTypes } from './table-node-types';
 function normalizeDirection(targetDirection, options) {
   var _options$direction;

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

@@ -0,0 +1,79 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { safeInsert } from '@atlaskit/editor-prosemirror/utils';
+import { TableMap } from '../table-map';
+import { findTable } from './find-table';
+import { getCellsInRow } from './get-cells-in-row';
+import { setCellAttrs } from './set-cell-attrs';
+import { tableNodeTypes } from './table-node-types';
+var filterCellsInRow = function filterCellsInRow(rowIndex, predicate) {
+  return function (tr) {
+    var foundCells = [];
+    var cells = 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`.
+export var cloneRowAt = function cloneRowAt(rowIndex) {
+  return function (tr) {
+    var table = findTable(tr.selection);
+    if (table) {
+      var map = TableMap.get(table.node);
+      if (rowIndex >= 0 && rowIndex <= map.height) {
+        var tableNode = table.node;
+        var tableNodes = 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, _toConsumableArray(foundCells));
+          };
+          for (var _i = rowIndex; _i >= 0; _i--) {
+            _loop(_i);
+          }
+          if (rowSpanCells.length) {
+            rowSpanCells.forEach(function (cell) {
+              tr = setCellAttrs(cell, {
+                rowspan: cell.node.attrs.rowspan + 1
+              })(tr);
+            });
+          }
+        }
+        return safeInsert(tableNodes.row.create(cloneRow.attrs, cells), rowPos)(tr);
+      }
+    }
+    return tr;
+  };
+};

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

@@ -4,9 +4,9 @@ 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 './reorder-utils';
+import { isValidReorder } from './is-valid-reorder';
 import { tableNodeTypes } from './table-node-types';
 function normalizeDirection(targetDirection, options) {
   var _options$direction;

package/dist/esm/utils/colspan.js

@@ -1,46 +1,17 @@
-import _defineProperty from "@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) { _defineProperty(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; }
-export 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');
-  }
-  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;
-}
-export 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));
-  }
-}
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
 
-// TODO: ED-26961 - replace "addColSpan" from table plugin with this function
-export 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);
-    }
-  }
-  return result;
-}
+/**
+ * @deprecated Use `import { removeColSpan } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { removeColSpan } from './remove-col-span';
+/**
+ * @deprecated Use `import { assertColspan } from '@atlaskit/editor-tables/utils/colspan'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { assertColspan } from './assert-colspan';
+/**
+ * @deprecated Use `import { addColSpan } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { addColSpan } from './add-col-span';

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

@@ -0,0 +1,11 @@
+import { tableNodeTypes } from './table-node-types';
+export function columnIsHeader(map, table, col) {
+  var headerCell = 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/esm/utils/convert-array-of-rows-to-table-node.js

@@ -0,0 +1,51 @@
+import { TableMap } from '../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  |      |
+// |______|______|______|______|
+// ```
+//
+export var convertArrayOfRowsToTableNode = function convertArrayOfRowsToTableNode(tableNode, arrayOfNodes) {
+  var rowsPM = [];
+  var map = 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/esm/utils/convert-table-node-to-array-of-rows.js

@@ -0,0 +1,48 @@
+import { TableMap } from '../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],
+// ]
+// ```
+export var convertTableNodeToArrayOfRows = function convertTableNodeToArrayOfRows(tableNode) {
+  var map = 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/esm/utils/find-cell-closest-to-pos.js

@@ -0,0 +1,12 @@
+import { findParentNodeClosestToPos } from '@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`.
+export var findCellClosestToPos = function findCellClosestToPos($pos) {
+  var predicate = function predicate(node) {
+    return node.type.spec.tableRole && CELL_ROLE_REGEX.test(node.type.spec.tableRole);
+  };
+  return findParentNodeClosestToPos($pos, predicate);
+};

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

@@ -0,0 +1,16 @@
+import { TableMap } from '../table-map';
+import { findCellClosestToPos } from './find-cell-closest-to-pos';
+import { findTableClosestToPos } from './find-table-closest-to-pos';
+
+// Returns the rectangle spanning a cell closest to a given `$pos`.
+export var findCellRectClosestToPos = function findCellRectClosestToPos($pos) {
+  var cell = findCellClosestToPos($pos);
+  if (cell) {
+    var table = findTableClosestToPos($pos);
+    if (table) {
+      var map = TableMap.get(table.node);
+      var cellPos = cell.pos - table.start;
+      return map.rectBetween(cellPos, cellPos);
+    }
+  }
+};

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

@@ -0,0 +1,8 @@
+import { findParentNodeClosestToPos } from '@atlaskit/editor-prosemirror/utils';
+// Iterates over parent nodes, returning a table node closest to a given `$pos`.
+export var findTableClosestToPos = function findTableClosestToPos($pos) {
+  var predicate = function predicate(node) {
+    return node.type.spec.tableRole && node.type.spec.tableRole === 'table';
+  };
+  return findParentNodeClosestToPos($pos, predicate);
+};

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

@@ -0,0 +1,7 @@
+import { findParentNode } from '@atlaskit/editor-prosemirror/utils';
+// Iterates over parent nodes, returning the closest table node.
+export var findTable = function findTable(selection) {
+  return findParentNode(function (node) {
+    return node.type.spec.tableRole && node.type.spec.tableRole === 'table';
+  })(selection);
+};

package/dist/esm/utils/find.js

@@ -1,41 +1,22 @@
-import { findParentNode, findParentNodeClosestToPos } from '@atlaskit/editor-prosemirror/utils';
-import { TableMap } from '../table-map';
-// Ignored via go/ees005
-// eslint-disable-next-line require-unicode-regexp
-var CELL_ROLE_REGEX = /cell/i;
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
 
-// Iterates over parent nodes, returning the closest table node.
-export var findTable = function findTable(selection) {
-  return 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`.
-export var findTableClosestToPos = function findTableClosestToPos($pos) {
-  var predicate = function predicate(node) {
-    return node.type.spec.tableRole && node.type.spec.tableRole === 'table';
-  };
-  return findParentNodeClosestToPos($pos, predicate);
-};
-
-// Iterates over parent nodes, returning a table cell or a table header node closest to a given `$pos`.
-export var findCellClosestToPos = function findCellClosestToPos($pos) {
-  var predicate = function predicate(node) {
-    return node.type.spec.tableRole && CELL_ROLE_REGEX.test(node.type.spec.tableRole);
-  };
-  return findParentNodeClosestToPos($pos, predicate);
-};
-
-// Returns the rectangle spanning a cell closest to a given `$pos`.
-export var findCellRectClosestToPos = function findCellRectClosestToPos($pos) {
-  var cell = findCellClosestToPos($pos);
-  if (cell) {
-    var table = findTableClosestToPos($pos);
-    if (table) {
-      var map = TableMap.get(table.node);
-      var cellPos = cell.pos - table.start;
-      return map.rectBetween(cellPos, cellPos);
-    }
-  }
-};
+/**
+ * @deprecated Use `import { findTable } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { findTable } from './find-table';
+/**
+ * @deprecated Use `import { findTableClosestToPos } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { findTableClosestToPos } from './find-table-closest-to-pos';
+/**
+ * @deprecated Use `import { findCellClosestToPos } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { findCellClosestToPos } from './find-cell-closest-to-pos';
+/**
+ * @deprecated Use `import { findCellRectClosestToPos } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { findCellRectClosestToPos } from './find-cell-rect-closest-to-pos';

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

@@ -0,0 +1,21 @@
+// 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 { Transform } from '@atlaskit/editor-prosemirror/transform';
+export function fitSlice(nodeType, slice) {
+  var node = nodeType.createAndFill();
+  if (!node) {
+    throw new Error("fitSlice: unable to create node");
+  }
+  var tr = new Transform(node).replace(0, node.content.size, slice);
+  return tr.doc;
+}

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

@@ -0,0 +1,106 @@
+import _defineProperty from "@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) { _defineProperty(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; }
+import { fixTablesKey } from '../pm-plugins/plugin-key';
+import { TableMap, TableProblemTypes } from '../table-map';
+import { removeColSpan } from './remove-col-span';
+import { tableNodeTypes } from './table-node-types';
+
+// : (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.
+export function fixTable(state, table, tablePos, transaction, reportFixedTable) {
+  var tr = transaction;
+  var map = 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 === 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, removeColSpan(cell.attrs, cell.attrs.colspan - collision.n, collision.n));
+    } else if (prob.type === TableProblemTypes.MISSING) {
+      var missing = prob;
+      mustAdd[missing.row] += missing.n;
+    } else if (prob.type === 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 === 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(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(fixTablesKey, {
+    fixTables: true
+  });
+}