@atlaskit/editor-tables 2.5.8 → 2.6.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @atlaskit/editor-tables
 
+## 2.6.0
+
+### Minor Changes
+
+- [#83612](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/pull-requests/83612) [`25b32cbfbb7e`](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/commits/25b32cbfbb7e) - [ux] Added new clone row/column behaviour to tables drag N drop. When the user holds the alt modifier during the operation the row/column will be duplicated rather then moved.
+
 ## 2.5.8
 
 ### Patch Changes

package/cell-bookmark/package.json

@@ -6,7 +6,7 @@
   "sideEffects": false,
   "types": "../dist/types/cell-bookmark.d.ts",
   "typesVersions": {
-    ">=4.5 <4.9": {
+    ">=4.5 <5.4": {
       "*": [
         "../dist/types-ts4.5/cell-bookmark.d.ts"
       ]

package/cell-selection/package.json

@@ -6,7 +6,7 @@
   "sideEffects": false,
   "types": "../dist/types/cell-selection.d.ts",
   "typesVersions": {
-    ">=4.5 <4.9": {
+    ">=4.5 <5.4": {
       "*": [
         "../dist/types-ts4.5/cell-selection.d.ts"
       ]

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

@@ -0,0 +1,143 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cloneColumn = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+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 _getSelectionRangeInColumn = require("./get-selection-range-in-column");
+var _reorderUtils = require("./reorder-utils");
+var _tableNodeTypes = require("./table-node-types");
+function normalizeDirection(targetDirection, options) {
+  var _options$direction;
+  var override = ((_options$direction = options === null || options === void 0 ? void 0 : options.direction) !== null && _options$direction !== void 0 ? _options$direction : 0) < 0 ? 'start' : 'end';
+  return options !== null && options !== void 0 && options.tryToFit && !!(options !== null && options !== void 0 && options.direction) ? override : targetDirection;
+}
+var cloneColumn = exports.cloneColumn = function cloneColumn(state, originColumnIndex, targetColumnIndex, targetDirection) {
+  var options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {
+    tryToFit: false,
+    direction: 0,
+    selectAfterClone: false
+  };
+  return function (tr) {
+    var _originalColumnRanges, _targetColumnRanges$i;
+    var table = (0, _find.findTable)(tr.selection);
+    if (!table) {
+      return tr;
+    }
+
+    // normalize the origin index to an array since this supports moving both a single & multiple cols in a single action.
+    if (!Array.isArray(originColumnIndex)) {
+      originColumnIndex = [originColumnIndex];
+    }
+    var tableMap = _tableMap.TableMap.get(table.node);
+    var originalColumnRanges = (0, _getSelectionRangeInColumn.getSelectionRangeInColumn)(Math.min.apply(Math, (0, _toConsumableArray2.default)(originColumnIndex)), Math.max.apply(Math, (0, _toConsumableArray2.default)(originColumnIndex)))(tr);
+    var targetColumnRanges = (0, _getSelectionRangeInColumn.getSelectionRangeInColumn)(targetColumnIndex)(tr);
+    var indexesOriginColumn = (_originalColumnRanges = originalColumnRanges === null || originalColumnRanges === void 0 ? void 0 : originalColumnRanges.indexes) !== null && _originalColumnRanges !== void 0 ? _originalColumnRanges : [];
+    var indexesTargetColumn = (_targetColumnRanges$i = targetColumnRanges === null || targetColumnRanges === void 0 ? void 0 : targetColumnRanges.indexes) !== null && _targetColumnRanges$i !== void 0 ? _targetColumnRanges$i : [];
+    var min = indexesOriginColumn[0];
+    var max = indexesOriginColumn[indexesOriginColumn.length - 1];
+    if (!options.tryToFit && indexesTargetColumn.length > 1) {
+      (0, _reorderUtils.isValidReorder)(originColumnIndex[0], targetColumnIndex, indexesTargetColumn, 'column');
+    }
+    var types = (0, _tableNodeTypes.tableNodeTypes)(state.schema);
+    var direction = normalizeDirection(targetDirection, options);
+    var actualTargetIndex = Math[direction === 'start' ? 'min' : 'max'].apply(Math, (0, _toConsumableArray2.default)(indexesTargetColumn));
+    var _determineTableHeader = (0, _analyseTable.determineTableHeaderStateFromTableNode)(table.node, tableMap, types),
+      rowHeaderEnabled = _determineTableHeader.rowHeaderEnabled,
+      columnHeaderEnabled = _determineTableHeader.columnHeaderEnabled;
+    var createContentNode = createContentNodeFactory(table);
+    var newTr = (0, _cloneTr.cloneTr)(tr);
+    var origins = [];
+    for (var y = 0; y < tableMap.height; y++) {
+      origins.push([]);
+      for (var x = min; x <= max; x++) {
+        if (tableMap.isCellMergedTopLeft(y, x)) {
+          continue;
+        }
+        var nodePos = tableMap.map[y * tableMap.width + x];
+        origins[y].push(createContentNode(nodePos));
+      }
+      if (columnHeaderEnabled && actualTargetIndex === 0 && direction === 'start') {
+        // This block is handling the situation where a col is moved in/out of the header position. If the header col option
+        // is enabled then;
+        // When a col is moved out, the col will be converted to a normal col and the col to the right will become the header.
+        // When a col is moved in, the old col header needs to be made normal, and the incoming col needs to be made a header.
+        // This section only manages what happens to the other col, not the one being moved.
+        var nearHeaderCol = min === 0 ? max + 1 : actualTargetIndex;
+        var _nodePos = tableMap.map[y * tableMap.width + nearHeaderCol];
+        var _createContentNode = createContentNode(_nodePos),
+          pos = _createContentNode.pos,
+          node = _createContentNode.node;
+        newTr.setNodeMarkup(pos, actualTargetIndex !== 0 || rowHeaderEnabled && y === 0 ? types.header_cell : types.cell, node.attrs);
+      }
+    }
+    origins.forEach(function (row, y) {
+      if (!row.length) {
+        // If the origin has no cells to be moved then we can skip moving for this row. This can occur when a cell above rowspans
+        // into the current row.
+        return;
+      }
+
+      // The actual target index needs to be translated per row, this is because row/col spans can affect the amount of
+      // cells each row contains.
+      var rowTargetPosition = translateTargetPosition(y, actualTargetIndex, tableMap);
+      var node = table.node.nodeAt(rowTargetPosition);
+      var pos = table.start + rowTargetPosition;
+      var insertPos = direction === 'end' ? newTr.mapping.map(pos + node.nodeSize, 1) : newTr.mapping.map(pos, -1);
+      return newTr.insert(insertPos, row.map(function (_ref, x) {
+        var node = _ref.node;
+        return normalizeCellNode(node, rowHeaderEnabled && y === 0, columnHeaderEnabled && actualTargetIndex === 0 && x === 0 && direction === 'start', types);
+      }));
+    });
+    if (options.selectAfterClone) {
+      var offset = direction === 'end' ? 1 : 0;
+      var selectionRange = (0, _getSelectionRangeInColumn.getSelectionRangeInColumn)(actualTargetIndex + offset, actualTargetIndex + offset + indexesOriginColumn.length - 1)(newTr);
+      if (selectionRange) {
+        newTr.setSelection(new _cellSelection.CellSelection(selectionRange.$anchor, selectionRange.$head));
+      }
+    }
+    return newTr;
+  };
+};
+function normalizeCellNode(cellNode, rowHeaderEnabled, columnHeaderEnabled, types) {
+  var newTargetType = rowHeaderEnabled || columnHeaderEnabled ? types.header_cell : types.cell;
+  return cellNode.type !== newTargetType ? newTargetType.create(cellNode.attrs, cellNode.content, cellNode.marks) : cellNode;
+}
+function createContentNodeFactory(table) {
+  return function (nodePos) {
+    var node = table.node.nodeAt(nodePos);
+    var pos = nodePos + table.start;
+    return {
+      pos: pos,
+      start: pos + 1,
+      node: node,
+      depth: table.depth + 2
+    };
+  };
+}
+function translateTargetPosition(row, startIndex, tableMap) {
+  if (tableMap.isCellMergedTopLeft(row, startIndex)) {
+    // find the closet unmerged position to the left of the target. We scan left first because merged cells will actually
+    // reduce the amount of cells in a row.
+    for (var x = startIndex - 1; x >= 0; x--) {
+      if (!tableMap.isCellMergedTopLeft(row, x)) {
+        return tableMap.map[row * tableMap.width + x];
+      }
+    }
+
+    // If no index found then we need to look to the right, this can occur when the first cell in the row is merged.
+    for (var _x = startIndex + 1; _x < tableMap.width; _x++) {
+      if (!tableMap.isCellMergedTopLeft(row, _x)) {
+        return tableMap.map[row * tableMap.width + _x];
+      }
+    }
+  }
+  return tableMap.map[row * tableMap.width + startIndex];
+}

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

@@ -0,0 +1,126 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cloneRow = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+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 _getSelectionRangeInRow = require("./get-selection-range-in-row");
+var _reorderUtils = require("./reorder-utils");
+var _tableNodeTypes = require("./table-node-types");
+function normalizeDirection(targetDirection, options) {
+  var _options$direction;
+  var override = ((_options$direction = options === null || options === void 0 ? void 0 : options.direction) !== null && _options$direction !== void 0 ? _options$direction : 0) < 0 ? 'start' : 'end';
+  return options !== null && options !== void 0 && options.tryToFit && !!(options !== null && options !== void 0 && options.direction) ? override : targetDirection;
+}
+var cloneRow = exports.cloneRow = function cloneRow(state, originRowIndex, targetRowIndex, targetDirection) {
+  var options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {
+    tryToFit: false,
+    direction: 0,
+    selectAfterClone: false
+  };
+  return function (tr) {
+    var table = (0, _find.findTable)(tr.selection);
+    if (!table) {
+      return tr;
+    }
+
+    // normalize the origin index to an array since move row support moving both a single & multiple rows in a single action.
+    if (!Array.isArray(originRowIndex)) {
+      originRowIndex = [originRowIndex];
+    }
+    var tableMap = _tableMap.TableMap.get(table.node);
+    var _originRowIndex$reduc = originRowIndex.reduce(function (_ref, cur) {
+        var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
+          min = _ref2[0],
+          max = _ref2[1];
+        return [Math.min(min, cur), Math.max(max, cur)];
+      }, [Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER]),
+      _originRowIndex$reduc2 = (0, _slicedToArray2.default)(_originRowIndex$reduc, 2),
+      originMin = _originRowIndex$reduc2[0],
+      originMax = _originRowIndex$reduc2[1];
+    var originalRowRanges = (0, _getSelectionRangeInRow.getSelectionRangeInRow)(originMin, originMax)(tr);
+    var targetRowRanges = (0, _getSelectionRangeInRow.getSelectionRangeInRow)(targetRowIndex)(tr);
+    var indexesOriginRow = (originalRowRanges === null || originalRowRanges === void 0 ? void 0 : originalRowRanges.indexes) || [];
+    var indexesTargetRow = (targetRowRanges === null || targetRowRanges === void 0 ? void 0 : targetRowRanges.indexes) || [];
+    if (originMin < 0 || originMin === Number.MAX_SAFE_INTEGER || originMax >= tableMap.height || originMax === Number.MIN_SAFE_INTEGER) {
+      return tr;
+    }
+    if (!options.tryToFit && indexesTargetRow.length > 1) {
+      (0, _reorderUtils.isValidReorder)(originMin, targetRowIndex, indexesTargetRow, 'row');
+    }
+    var types = (0, _tableNodeTypes.tableNodeTypes)(state.schema);
+    var direction = normalizeDirection(targetDirection, options);
+    var actualTargetIndex = Math[direction === 'start' ? 'min' : 'max'].apply(Math, (0, _toConsumableArray2.default)(indexesTargetRow));
+    var originPositions = indexesOriginRow.map(function (index) {
+      return tableMap.positionAt(index, 0, table.node) + table.pos;
+    });
+    var originNodes = originPositions.reduce(function (acc, pos) {
+      var node = tr.doc.nodeAt(tr.mapping.map(pos));
+      if (node) {
+        return [].concat((0, _toConsumableArray2.default)(acc), [{
+          pos: pos,
+          node: node
+        }]);
+      }
+      return acc;
+    }, []);
+    var targetPos = tableMap.positionAt(actualTargetIndex, 0, table.node) + table.pos;
+    var targetNode = tr.doc.nodeAt(tr.mapping.map(targetPos));
+    if (originNodes !== null && originNodes !== void 0 && originNodes.length && targetNode) {
+      var newTr = (0, _cloneTr.cloneTr)(tr);
+      var _determineTableHeader = (0, _analyseTable.determineTableHeaderStateFromTableNode)(table.node, tableMap, types),
+        rowHeaderEnabled = _determineTableHeader.rowHeaderEnabled,
+        columnHeaderEnabled = _determineTableHeader.columnHeaderEnabled;
+      if (rowHeaderEnabled && actualTargetIndex === 0 && direction === 'start') {
+        // This block is handling the situation where a row is moved in/out of the header position. If the header row option
+        // is enabled then;
+        // When a row is moved out, the row will be converted to a normal row and the row below it will become the header.
+        // When a row is moved in, the old row header needs to be made normal, and the incoming row needs to be made a header.
+        // This section only manages what happens to the other row, no the one being moved.
+        var nearHeaderPos = tableMap.positionAt(originMin === 0 ? originMax + 1 : actualTargetIndex, 0, table.node) + table.pos;
+        var nearHeaderNode = newTr.doc.nodeAt(newTr.mapping.map(nearHeaderPos));
+        if (nearHeaderNode) {
+          nearHeaderNode.forEach(function (node, offset, index) {
+            var start = newTr.mapping.map(nearHeaderPos + 1 + offset);
+            newTr.setNodeMarkup(start, actualTargetIndex !== 0 || columnHeaderEnabled && index === 0 ? types.header_cell : types.cell, node.attrs);
+          });
+        }
+      }
+      var insertPos = direction === 'end' ? newTr.mapping.map(targetPos + targetNode.nodeSize, 1) : newTr.mapping.map(targetPos, -1);
+      newTr.insert(insertPos, originNodes.map(function (_ref3, index) {
+        var node = _ref3.node;
+        return normalizeRowNode(node, rowHeaderEnabled && actualTargetIndex === 0 && index === 0 && direction === 'start', columnHeaderEnabled, types);
+      }));
+      if (options.selectAfterClone) {
+        var offset = direction === 'end' ? 1 : 0;
+        var selectionRange = (0, _getSelectionRangeInRow.getSelectionRangeInRow)(actualTargetIndex + offset, actualTargetIndex + offset + originNodes.length - 1)(newTr);
+        if (selectionRange) {
+          newTr.setSelection(new _cellSelection.CellSelection(selectionRange.$anchor, selectionRange.$head));
+        }
+      }
+      return newTr;
+    }
+    return tr;
+  };
+};
+
+/**
+ * This ensures the row node cell type correctly reflect what they should be.
+ * @returns A copy of the rowNode
+ */
+function normalizeRowNode(rowNode, rowHeaderEnabled, columnHeaderEnabled, types) {
+  var content = [];
+  rowNode.forEach(function (node, offset, index) {
+    var newTargetType = rowHeaderEnabled || columnHeaderEnabled && index === 0 ? types.header_cell : types.cell;
+    content.push(node.type !== newTargetType ? newTargetType.create(node.attrs, node.content, node.marks) : node);
+  });
+  return rowNode.type.create(rowNode.attrs, content, rowNode.marks);
+}

package/dist/cjs/utils.js

@@ -51,6 +51,18 @@ Object.defineProperty(exports, "cellWrapping", {
     return _splitCellWithType.cellWrapping;
   }
 });
+Object.defineProperty(exports, "cloneColumn", {
+  enumerable: true,
+  get: function get() {
+    return _cloneColumn.cloneColumn;
+  }
+});
+Object.defineProperty(exports, "cloneRow", {
+  enumerable: true,
+  get: function get() {
+    return _cloneRow.cloneRow;
+  }
+});
 Object.defineProperty(exports, "cloneTr", {
   enumerable: true,
   get: function get() {
@@ -430,6 +442,8 @@ var _isSelected = require("./utils/is-selected");
 var _isSelectionType = require("./utils/is-selection-type");
 var _moveColumn = require("./utils/move-column");
 var _moveRow = require("./utils/move-row");
+var _cloneColumn = require("./utils/clone-column");
+var _cloneRow = require("./utils/clone-row");
 var _normalizeSelection = require("./utils/normalize-selection");
 var _removeColumn = require("./utils/remove-column");
 var _removeRow = require("./utils/remove-row");

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

@@ -0,0 +1,133 @@
+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 { getSelectionRangeInColumn } from './get-selection-range-in-column';
+import { isValidReorder } from './reorder-utils';
+import { tableNodeTypes } from './table-node-types';
+function normalizeDirection(targetDirection, options) {
+  var _options$direction;
+  const override = ((_options$direction = options === null || options === void 0 ? void 0 : options.direction) !== null && _options$direction !== void 0 ? _options$direction : 0) < 0 ? 'start' : 'end';
+  return options !== null && options !== void 0 && options.tryToFit && !!(options !== null && options !== void 0 && options.direction) ? override : targetDirection;
+}
+export const cloneColumn = (state, originColumnIndex, targetColumnIndex, targetDirection, options = {
+  tryToFit: false,
+  direction: 0,
+  selectAfterClone: false
+}) => tr => {
+  var _originalColumnRanges, _targetColumnRanges$i;
+  const table = findTable(tr.selection);
+  if (!table) {
+    return tr;
+  }
+
+  // normalize the origin index to an array since this supports moving both a single & multiple cols in a single action.
+  if (!Array.isArray(originColumnIndex)) {
+    originColumnIndex = [originColumnIndex];
+  }
+  const tableMap = TableMap.get(table.node);
+  const originalColumnRanges = getSelectionRangeInColumn(Math.min(...originColumnIndex), Math.max(...originColumnIndex))(tr);
+  const targetColumnRanges = getSelectionRangeInColumn(targetColumnIndex)(tr);
+  const indexesOriginColumn = (_originalColumnRanges = originalColumnRanges === null || originalColumnRanges === void 0 ? void 0 : originalColumnRanges.indexes) !== null && _originalColumnRanges !== void 0 ? _originalColumnRanges : [];
+  const indexesTargetColumn = (_targetColumnRanges$i = targetColumnRanges === null || targetColumnRanges === void 0 ? void 0 : targetColumnRanges.indexes) !== null && _targetColumnRanges$i !== void 0 ? _targetColumnRanges$i : [];
+  const min = indexesOriginColumn[0];
+  const max = indexesOriginColumn[indexesOriginColumn.length - 1];
+  if (!options.tryToFit && indexesTargetColumn.length > 1) {
+    isValidReorder(originColumnIndex[0], targetColumnIndex, indexesTargetColumn, 'column');
+  }
+  const types = tableNodeTypes(state.schema);
+  const direction = normalizeDirection(targetDirection, options);
+  const actualTargetIndex = Math[direction === 'start' ? 'min' : 'max'](...indexesTargetColumn);
+  const {
+    rowHeaderEnabled,
+    columnHeaderEnabled
+  } = determineTableHeaderStateFromTableNode(table.node, tableMap, types);
+  const createContentNode = createContentNodeFactory(table);
+  const newTr = cloneTr(tr);
+  const origins = [];
+  for (let y = 0; y < tableMap.height; y++) {
+    origins.push([]);
+    for (let x = min; x <= max; x++) {
+      if (tableMap.isCellMergedTopLeft(y, x)) {
+        continue;
+      }
+      const nodePos = tableMap.map[y * tableMap.width + x];
+      origins[y].push(createContentNode(nodePos));
+    }
+    if (columnHeaderEnabled && actualTargetIndex === 0 && direction === 'start') {
+      // This block is handling the situation where a col is moved in/out of the header position. If the header col option
+      // is enabled then;
+      // When a col is moved out, the col will be converted to a normal col and the col to the right will become the header.
+      // When a col is moved in, the old col header needs to be made normal, and the incoming col needs to be made a header.
+      // This section only manages what happens to the other col, not the one being moved.
+      const nearHeaderCol = min === 0 ? max + 1 : actualTargetIndex;
+      const nodePos = tableMap.map[y * tableMap.width + nearHeaderCol];
+      const {
+        pos,
+        node
+      } = createContentNode(nodePos);
+      newTr.setNodeMarkup(pos, actualTargetIndex !== 0 || rowHeaderEnabled && y === 0 ? types.header_cell : types.cell, node.attrs);
+    }
+  }
+  origins.forEach((row, y) => {
+    if (!row.length) {
+      // If the origin has no cells to be moved then we can skip moving for this row. This can occur when a cell above rowspans
+      // into the current row.
+      return;
+    }
+
+    // The actual target index needs to be translated per row, this is because row/col spans can affect the amount of
+    // cells each row contains.
+    const rowTargetPosition = translateTargetPosition(y, actualTargetIndex, tableMap);
+    const node = table.node.nodeAt(rowTargetPosition);
+    const pos = table.start + rowTargetPosition;
+    const insertPos = direction === 'end' ? newTr.mapping.map(pos + node.nodeSize, 1) : newTr.mapping.map(pos, -1);
+    return newTr.insert(insertPos, row.map(({
+      node
+    }, x) => normalizeCellNode(node, rowHeaderEnabled && y === 0, columnHeaderEnabled && actualTargetIndex === 0 && x === 0 && direction === 'start', types)));
+  });
+  if (options.selectAfterClone) {
+    const offset = direction === 'end' ? 1 : 0;
+    const selectionRange = getSelectionRangeInColumn(actualTargetIndex + offset, actualTargetIndex + offset + indexesOriginColumn.length - 1)(newTr);
+    if (selectionRange) {
+      newTr.setSelection(new CellSelection(selectionRange.$anchor, selectionRange.$head));
+    }
+  }
+  return newTr;
+};
+function normalizeCellNode(cellNode, rowHeaderEnabled, columnHeaderEnabled, types) {
+  const newTargetType = rowHeaderEnabled || columnHeaderEnabled ? types.header_cell : types.cell;
+  return cellNode.type !== newTargetType ? newTargetType.create(cellNode.attrs, cellNode.content, cellNode.marks) : cellNode;
+}
+function createContentNodeFactory(table) {
+  return nodePos => {
+    const node = table.node.nodeAt(nodePos);
+    const pos = nodePos + table.start;
+    return {
+      pos,
+      start: pos + 1,
+      node,
+      depth: table.depth + 2
+    };
+  };
+}
+function translateTargetPosition(row, startIndex, tableMap) {
+  if (tableMap.isCellMergedTopLeft(row, startIndex)) {
+    // find the closet unmerged position to the left of the target. We scan left first because merged cells will actually
+    // reduce the amount of cells in a row.
+    for (let x = startIndex - 1; x >= 0; x--) {
+      if (!tableMap.isCellMergedTopLeft(row, x)) {
+        return tableMap.map[row * tableMap.width + x];
+      }
+    }
+
+    // If no index found then we need to look to the right, this can occur when the first cell in the row is merged.
+    for (let x = startIndex + 1; x < tableMap.width; x++) {
+      if (!tableMap.isCellMergedTopLeft(row, x)) {
+        return tableMap.map[row * tableMap.width + x];
+      }
+    }
+  }
+  return tableMap.map[row * tableMap.width + startIndex];
+}

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

@@ -0,0 +1,104 @@
+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 { getSelectionRangeInRow } from './get-selection-range-in-row';
+import { isValidReorder } from './reorder-utils';
+import { tableNodeTypes } from './table-node-types';
+function normalizeDirection(targetDirection, options) {
+  var _options$direction;
+  const override = ((_options$direction = options === null || options === void 0 ? void 0 : options.direction) !== null && _options$direction !== void 0 ? _options$direction : 0) < 0 ? 'start' : 'end';
+  return options !== null && options !== void 0 && options.tryToFit && !!(options !== null && options !== void 0 && options.direction) ? override : targetDirection;
+}
+export const cloneRow = (state, originRowIndex, targetRowIndex, targetDirection, options = {
+  tryToFit: false,
+  direction: 0,
+  selectAfterClone: false
+}) => tr => {
+  const table = findTable(tr.selection);
+  if (!table) {
+    return tr;
+  }
+
+  // normalize the origin index to an array since move row support moving both a single & multiple rows in a single action.
+  if (!Array.isArray(originRowIndex)) {
+    originRowIndex = [originRowIndex];
+  }
+  const tableMap = TableMap.get(table.node);
+  const [originMin, originMax] = originRowIndex.reduce(([min, max], cur) => [Math.min(min, cur), Math.max(max, cur)], [Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER]);
+  const originalRowRanges = getSelectionRangeInRow(originMin, originMax)(tr);
+  const targetRowRanges = getSelectionRangeInRow(targetRowIndex)(tr);
+  const indexesOriginRow = (originalRowRanges === null || originalRowRanges === void 0 ? void 0 : originalRowRanges.indexes) || [];
+  const indexesTargetRow = (targetRowRanges === null || targetRowRanges === void 0 ? void 0 : targetRowRanges.indexes) || [];
+  if (originMin < 0 || originMin === Number.MAX_SAFE_INTEGER || originMax >= tableMap.height || originMax === Number.MIN_SAFE_INTEGER) {
+    return tr;
+  }
+  if (!options.tryToFit && indexesTargetRow.length > 1) {
+    isValidReorder(originMin, targetRowIndex, indexesTargetRow, 'row');
+  }
+  const types = tableNodeTypes(state.schema);
+  const direction = normalizeDirection(targetDirection, options);
+  const actualTargetIndex = Math[direction === 'start' ? 'min' : 'max'](...indexesTargetRow);
+  const originPositions = indexesOriginRow.map(index => tableMap.positionAt(index, 0, table.node) + table.pos);
+  const originNodes = originPositions.reduce((acc, pos) => {
+    const node = tr.doc.nodeAt(tr.mapping.map(pos));
+    if (node) {
+      return [...acc, {
+        pos,
+        node
+      }];
+    }
+    return acc;
+  }, []);
+  const targetPos = tableMap.positionAt(actualTargetIndex, 0, table.node) + table.pos;
+  const targetNode = tr.doc.nodeAt(tr.mapping.map(targetPos));
+  if (originNodes !== null && originNodes !== void 0 && originNodes.length && targetNode) {
+    const newTr = cloneTr(tr);
+    const {
+      rowHeaderEnabled,
+      columnHeaderEnabled
+    } = determineTableHeaderStateFromTableNode(table.node, tableMap, types);
+    if (rowHeaderEnabled && actualTargetIndex === 0 && direction === 'start') {
+      // This block is handling the situation where a row is moved in/out of the header position. If the header row option
+      // is enabled then;
+      // When a row is moved out, the row will be converted to a normal row and the row below it will become the header.
+      // When a row is moved in, the old row header needs to be made normal, and the incoming row needs to be made a header.
+      // This section only manages what happens to the other row, no the one being moved.
+      const nearHeaderPos = tableMap.positionAt(originMin === 0 ? originMax + 1 : actualTargetIndex, 0, table.node) + table.pos;
+      const nearHeaderNode = newTr.doc.nodeAt(newTr.mapping.map(nearHeaderPos));
+      if (nearHeaderNode) {
+        nearHeaderNode.forEach((node, offset, index) => {
+          const start = newTr.mapping.map(nearHeaderPos + 1 + offset);
+          newTr.setNodeMarkup(start, actualTargetIndex !== 0 || columnHeaderEnabled && index === 0 ? types.header_cell : types.cell, node.attrs);
+        });
+      }
+    }
+    const insertPos = direction === 'end' ? newTr.mapping.map(targetPos + targetNode.nodeSize, 1) : newTr.mapping.map(targetPos, -1);
+    newTr.insert(insertPos, originNodes.map(({
+      node
+    }, index) => normalizeRowNode(node, rowHeaderEnabled && actualTargetIndex === 0 && index === 0 && direction === 'start', columnHeaderEnabled, types)));
+    if (options.selectAfterClone) {
+      const offset = direction === 'end' ? 1 : 0;
+      const selectionRange = getSelectionRangeInRow(actualTargetIndex + offset, actualTargetIndex + offset + originNodes.length - 1)(newTr);
+      if (selectionRange) {
+        newTr.setSelection(new CellSelection(selectionRange.$anchor, selectionRange.$head));
+      }
+    }
+    return newTr;
+  }
+  return tr;
+};
+
+/**
+ * This ensures the row node cell type correctly reflect what they should be.
+ * @returns A copy of the rowNode
+ */
+function normalizeRowNode(rowNode, rowHeaderEnabled, columnHeaderEnabled, types) {
+  let content = [];
+  rowNode.forEach((node, offset, index) => {
+    const newTargetType = rowHeaderEnabled || columnHeaderEnabled && index === 0 ? types.header_cell : types.cell;
+    content.push(node.type !== newTargetType ? newTargetType.create(node.attrs, node.content, node.marks) : node);
+  });
+  return rowNode.type.create(rowNode.attrs, content, rowNode.marks);
+}

package/dist/es2019/utils.js

@@ -23,6 +23,8 @@ export { isRectSelected, isColumnSelected, isRowSelected, isTableSelected } from
 export { isSelectionType } from './utils/is-selection-type';
 export { moveColumn } from './utils/move-column';
 export { moveRow } from './utils/move-row';
+export { cloneColumn } from './utils/clone-column';
+export { cloneRow } from './utils/clone-row';
 export { normalizeSelection } from './utils/normalize-selection';
 export { removeColumnAt, removeSelectedColumns, removeColumnClosestToPos } from './utils/remove-column';
 export { removeRowAt, removeSelectedRows, removeRowClosestToPos } from './utils/remove-row';

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

@@ -0,0 +1,136 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+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 { getSelectionRangeInColumn } from './get-selection-range-in-column';
+import { isValidReorder } from './reorder-utils';
+import { tableNodeTypes } from './table-node-types';
+function normalizeDirection(targetDirection, options) {
+  var _options$direction;
+  var override = ((_options$direction = options === null || options === void 0 ? void 0 : options.direction) !== null && _options$direction !== void 0 ? _options$direction : 0) < 0 ? 'start' : 'end';
+  return options !== null && options !== void 0 && options.tryToFit && !!(options !== null && options !== void 0 && options.direction) ? override : targetDirection;
+}
+export var cloneColumn = function cloneColumn(state, originColumnIndex, targetColumnIndex, targetDirection) {
+  var options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {
+    tryToFit: false,
+    direction: 0,
+    selectAfterClone: false
+  };
+  return function (tr) {
+    var _originalColumnRanges, _targetColumnRanges$i;
+    var table = findTable(tr.selection);
+    if (!table) {
+      return tr;
+    }
+
+    // normalize the origin index to an array since this supports moving both a single & multiple cols in a single action.
+    if (!Array.isArray(originColumnIndex)) {
+      originColumnIndex = [originColumnIndex];
+    }
+    var tableMap = TableMap.get(table.node);
+    var originalColumnRanges = getSelectionRangeInColumn(Math.min.apply(Math, _toConsumableArray(originColumnIndex)), Math.max.apply(Math, _toConsumableArray(originColumnIndex)))(tr);
+    var targetColumnRanges = getSelectionRangeInColumn(targetColumnIndex)(tr);
+    var indexesOriginColumn = (_originalColumnRanges = originalColumnRanges === null || originalColumnRanges === void 0 ? void 0 : originalColumnRanges.indexes) !== null && _originalColumnRanges !== void 0 ? _originalColumnRanges : [];
+    var indexesTargetColumn = (_targetColumnRanges$i = targetColumnRanges === null || targetColumnRanges === void 0 ? void 0 : targetColumnRanges.indexes) !== null && _targetColumnRanges$i !== void 0 ? _targetColumnRanges$i : [];
+    var min = indexesOriginColumn[0];
+    var max = indexesOriginColumn[indexesOriginColumn.length - 1];
+    if (!options.tryToFit && indexesTargetColumn.length > 1) {
+      isValidReorder(originColumnIndex[0], targetColumnIndex, indexesTargetColumn, 'column');
+    }
+    var types = tableNodeTypes(state.schema);
+    var direction = normalizeDirection(targetDirection, options);
+    var actualTargetIndex = Math[direction === 'start' ? 'min' : 'max'].apply(Math, _toConsumableArray(indexesTargetColumn));
+    var _determineTableHeader = determineTableHeaderStateFromTableNode(table.node, tableMap, types),
+      rowHeaderEnabled = _determineTableHeader.rowHeaderEnabled,
+      columnHeaderEnabled = _determineTableHeader.columnHeaderEnabled;
+    var createContentNode = createContentNodeFactory(table);
+    var newTr = cloneTr(tr);
+    var origins = [];
+    for (var y = 0; y < tableMap.height; y++) {
+      origins.push([]);
+      for (var x = min; x <= max; x++) {
+        if (tableMap.isCellMergedTopLeft(y, x)) {
+          continue;
+        }
+        var nodePos = tableMap.map[y * tableMap.width + x];
+        origins[y].push(createContentNode(nodePos));
+      }
+      if (columnHeaderEnabled && actualTargetIndex === 0 && direction === 'start') {
+        // This block is handling the situation where a col is moved in/out of the header position. If the header col option
+        // is enabled then;
+        // When a col is moved out, the col will be converted to a normal col and the col to the right will become the header.
+        // When a col is moved in, the old col header needs to be made normal, and the incoming col needs to be made a header.
+        // This section only manages what happens to the other col, not the one being moved.
+        var nearHeaderCol = min === 0 ? max + 1 : actualTargetIndex;
+        var _nodePos = tableMap.map[y * tableMap.width + nearHeaderCol];
+        var _createContentNode = createContentNode(_nodePos),
+          pos = _createContentNode.pos,
+          node = _createContentNode.node;
+        newTr.setNodeMarkup(pos, actualTargetIndex !== 0 || rowHeaderEnabled && y === 0 ? types.header_cell : types.cell, node.attrs);
+      }
+    }
+    origins.forEach(function (row, y) {
+      if (!row.length) {
+        // If the origin has no cells to be moved then we can skip moving for this row. This can occur when a cell above rowspans
+        // into the current row.
+        return;
+      }
+
+      // The actual target index needs to be translated per row, this is because row/col spans can affect the amount of
+      // cells each row contains.
+      var rowTargetPosition = translateTargetPosition(y, actualTargetIndex, tableMap);
+      var node = table.node.nodeAt(rowTargetPosition);
+      var pos = table.start + rowTargetPosition;
+      var insertPos = direction === 'end' ? newTr.mapping.map(pos + node.nodeSize, 1) : newTr.mapping.map(pos, -1);
+      return newTr.insert(insertPos, row.map(function (_ref, x) {
+        var node = _ref.node;
+        return normalizeCellNode(node, rowHeaderEnabled && y === 0, columnHeaderEnabled && actualTargetIndex === 0 && x === 0 && direction === 'start', types);
+      }));
+    });
+    if (options.selectAfterClone) {
+      var offset = direction === 'end' ? 1 : 0;
+      var selectionRange = getSelectionRangeInColumn(actualTargetIndex + offset, actualTargetIndex + offset + indexesOriginColumn.length - 1)(newTr);
+      if (selectionRange) {
+        newTr.setSelection(new CellSelection(selectionRange.$anchor, selectionRange.$head));
+      }
+    }
+    return newTr;
+  };
+};
+function normalizeCellNode(cellNode, rowHeaderEnabled, columnHeaderEnabled, types) {
+  var newTargetType = rowHeaderEnabled || columnHeaderEnabled ? types.header_cell : types.cell;
+  return cellNode.type !== newTargetType ? newTargetType.create(cellNode.attrs, cellNode.content, cellNode.marks) : cellNode;
+}
+function createContentNodeFactory(table) {
+  return function (nodePos) {
+    var node = table.node.nodeAt(nodePos);
+    var pos = nodePos + table.start;
+    return {
+      pos: pos,
+      start: pos + 1,
+      node: node,
+      depth: table.depth + 2
+    };
+  };
+}
+function translateTargetPosition(row, startIndex, tableMap) {
+  if (tableMap.isCellMergedTopLeft(row, startIndex)) {
+    // find the closet unmerged position to the left of the target. We scan left first because merged cells will actually
+    // reduce the amount of cells in a row.
+    for (var x = startIndex - 1; x >= 0; x--) {
+      if (!tableMap.isCellMergedTopLeft(row, x)) {
+        return tableMap.map[row * tableMap.width + x];
+      }
+    }
+
+    // If no index found then we need to look to the right, this can occur when the first cell in the row is merged.
+    for (var _x = startIndex + 1; _x < tableMap.width; _x++) {
+      if (!tableMap.isCellMergedTopLeft(row, _x)) {
+        return tableMap.map[row * tableMap.width + _x];
+      }
+    }
+  }
+  return tableMap.map[row * tableMap.width + startIndex];
+}

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

@@ -0,0 +1,119 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+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 { getSelectionRangeInRow } from './get-selection-range-in-row';
+import { isValidReorder } from './reorder-utils';
+import { tableNodeTypes } from './table-node-types';
+function normalizeDirection(targetDirection, options) {
+  var _options$direction;
+  var override = ((_options$direction = options === null || options === void 0 ? void 0 : options.direction) !== null && _options$direction !== void 0 ? _options$direction : 0) < 0 ? 'start' : 'end';
+  return options !== null && options !== void 0 && options.tryToFit && !!(options !== null && options !== void 0 && options.direction) ? override : targetDirection;
+}
+export var cloneRow = function cloneRow(state, originRowIndex, targetRowIndex, targetDirection) {
+  var options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {
+    tryToFit: false,
+    direction: 0,
+    selectAfterClone: false
+  };
+  return function (tr) {
+    var table = findTable(tr.selection);
+    if (!table) {
+      return tr;
+    }
+
+    // normalize the origin index to an array since move row support moving both a single & multiple rows in a single action.
+    if (!Array.isArray(originRowIndex)) {
+      originRowIndex = [originRowIndex];
+    }
+    var tableMap = TableMap.get(table.node);
+    var _originRowIndex$reduc = originRowIndex.reduce(function (_ref, cur) {
+        var _ref2 = _slicedToArray(_ref, 2),
+          min = _ref2[0],
+          max = _ref2[1];
+        return [Math.min(min, cur), Math.max(max, cur)];
+      }, [Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER]),
+      _originRowIndex$reduc2 = _slicedToArray(_originRowIndex$reduc, 2),
+      originMin = _originRowIndex$reduc2[0],
+      originMax = _originRowIndex$reduc2[1];
+    var originalRowRanges = getSelectionRangeInRow(originMin, originMax)(tr);
+    var targetRowRanges = getSelectionRangeInRow(targetRowIndex)(tr);
+    var indexesOriginRow = (originalRowRanges === null || originalRowRanges === void 0 ? void 0 : originalRowRanges.indexes) || [];
+    var indexesTargetRow = (targetRowRanges === null || targetRowRanges === void 0 ? void 0 : targetRowRanges.indexes) || [];
+    if (originMin < 0 || originMin === Number.MAX_SAFE_INTEGER || originMax >= tableMap.height || originMax === Number.MIN_SAFE_INTEGER) {
+      return tr;
+    }
+    if (!options.tryToFit && indexesTargetRow.length > 1) {
+      isValidReorder(originMin, targetRowIndex, indexesTargetRow, 'row');
+    }
+    var types = tableNodeTypes(state.schema);
+    var direction = normalizeDirection(targetDirection, options);
+    var actualTargetIndex = Math[direction === 'start' ? 'min' : 'max'].apply(Math, _toConsumableArray(indexesTargetRow));
+    var originPositions = indexesOriginRow.map(function (index) {
+      return tableMap.positionAt(index, 0, table.node) + table.pos;
+    });
+    var originNodes = originPositions.reduce(function (acc, pos) {
+      var node = tr.doc.nodeAt(tr.mapping.map(pos));
+      if (node) {
+        return [].concat(_toConsumableArray(acc), [{
+          pos: pos,
+          node: node
+        }]);
+      }
+      return acc;
+    }, []);
+    var targetPos = tableMap.positionAt(actualTargetIndex, 0, table.node) + table.pos;
+    var targetNode = tr.doc.nodeAt(tr.mapping.map(targetPos));
+    if (originNodes !== null && originNodes !== void 0 && originNodes.length && targetNode) {
+      var newTr = cloneTr(tr);
+      var _determineTableHeader = determineTableHeaderStateFromTableNode(table.node, tableMap, types),
+        rowHeaderEnabled = _determineTableHeader.rowHeaderEnabled,
+        columnHeaderEnabled = _determineTableHeader.columnHeaderEnabled;
+      if (rowHeaderEnabled && actualTargetIndex === 0 && direction === 'start') {
+        // This block is handling the situation where a row is moved in/out of the header position. If the header row option
+        // is enabled then;
+        // When a row is moved out, the row will be converted to a normal row and the row below it will become the header.
+        // When a row is moved in, the old row header needs to be made normal, and the incoming row needs to be made a header.
+        // This section only manages what happens to the other row, no the one being moved.
+        var nearHeaderPos = tableMap.positionAt(originMin === 0 ? originMax + 1 : actualTargetIndex, 0, table.node) + table.pos;
+        var nearHeaderNode = newTr.doc.nodeAt(newTr.mapping.map(nearHeaderPos));
+        if (nearHeaderNode) {
+          nearHeaderNode.forEach(function (node, offset, index) {
+            var start = newTr.mapping.map(nearHeaderPos + 1 + offset);
+            newTr.setNodeMarkup(start, actualTargetIndex !== 0 || columnHeaderEnabled && index === 0 ? types.header_cell : types.cell, node.attrs);
+          });
+        }
+      }
+      var insertPos = direction === 'end' ? newTr.mapping.map(targetPos + targetNode.nodeSize, 1) : newTr.mapping.map(targetPos, -1);
+      newTr.insert(insertPos, originNodes.map(function (_ref3, index) {
+        var node = _ref3.node;
+        return normalizeRowNode(node, rowHeaderEnabled && actualTargetIndex === 0 && index === 0 && direction === 'start', columnHeaderEnabled, types);
+      }));
+      if (options.selectAfterClone) {
+        var offset = direction === 'end' ? 1 : 0;
+        var selectionRange = getSelectionRangeInRow(actualTargetIndex + offset, actualTargetIndex + offset + originNodes.length - 1)(newTr);
+        if (selectionRange) {
+          newTr.setSelection(new CellSelection(selectionRange.$anchor, selectionRange.$head));
+        }
+      }
+      return newTr;
+    }
+    return tr;
+  };
+};
+
+/**
+ * This ensures the row node cell type correctly reflect what they should be.
+ * @returns A copy of the rowNode
+ */
+function normalizeRowNode(rowNode, rowHeaderEnabled, columnHeaderEnabled, types) {
+  var content = [];
+  rowNode.forEach(function (node, offset, index) {
+    var newTargetType = rowHeaderEnabled || columnHeaderEnabled && index === 0 ? types.header_cell : types.cell;
+    content.push(node.type !== newTargetType ? newTargetType.create(node.attrs, node.content, node.marks) : node);
+  });
+  return rowNode.type.create(rowNode.attrs, content, rowNode.marks);
+}

package/dist/esm/utils.js

@@ -23,6 +23,8 @@ export { isRectSelected, isColumnSelected, isRowSelected, isTableSelected } from
 export { isSelectionType } from './utils/is-selection-type';
 export { moveColumn } from './utils/move-column';
 export { moveRow } from './utils/move-row';
+export { cloneColumn } from './utils/clone-column';
+export { cloneRow } from './utils/clone-row';
 export { normalizeSelection } from './utils/normalize-selection';
 export { removeColumnAt, removeSelectedColumns, removeColumnClosestToPos } from './utils/remove-column';
 export { removeRowAt, removeSelectedRows, removeRowClosestToPos } from './utils/remove-row';

package/dist/types/types.d.ts

@@ -42,3 +42,8 @@ export interface MoveOptions {
     direction?: number;
     selectAfterMove?: boolean;
 }
+export interface CloneOptions {
+    tryToFit?: boolean;
+    direction?: number;
+    selectAfterClone?: boolean;
+}

package/dist/types/utils/clone-column.d.ts

@@ -0,0 +1,3 @@
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { CloneOptions } from '../types';
+export declare const cloneColumn: (state: EditorState, originColumnIndex: number | number[], targetColumnIndex: number, targetDirection: 'start' | 'end', options?: CloneOptions) => (tr: Transaction) => Transaction;

package/dist/types/utils/clone-row.d.ts

@@ -0,0 +1,3 @@
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { CloneOptions } from '../types';
+export declare const cloneRow: (state: EditorState, originRowIndex: number | number[], targetRowIndex: number, targetDirection: 'start' | 'end', options?: CloneOptions) => (tr: Transaction) => Transaction;

package/dist/types/utils.d.ts

@@ -23,6 +23,8 @@ export { isRectSelected, isColumnSelected, isRowSelected, isTableSelected, } fro
 export { isSelectionType } from './utils/is-selection-type';
 export { moveColumn } from './utils/move-column';
 export { moveRow } from './utils/move-row';
+export { cloneColumn } from './utils/clone-column';
+export { cloneRow } from './utils/clone-row';
 export { normalizeSelection } from './utils/normalize-selection';
 export { removeColumnAt, removeSelectedColumns, removeColumnClosestToPos, } from './utils/remove-column';
 export { removeRowAt, removeSelectedRows, removeRowClosestToPos, } from './utils/remove-row';

package/dist/types-ts4.5/types.d.ts

@@ -42,3 +42,8 @@ export interface MoveOptions {
     direction?: number;
     selectAfterMove?: boolean;
 }
+export interface CloneOptions {
+    tryToFit?: boolean;
+    direction?: number;
+    selectAfterClone?: boolean;
+}

package/dist/types-ts4.5/utils/clone-column.d.ts

@@ -0,0 +1,3 @@
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { CloneOptions } from '../types';
+export declare const cloneColumn: (state: EditorState, originColumnIndex: number | number[], targetColumnIndex: number, targetDirection: 'start' | 'end', options?: CloneOptions) => (tr: Transaction) => Transaction;

package/dist/types-ts4.5/utils/clone-row.d.ts

@@ -0,0 +1,3 @@
+import type { EditorState, Transaction } from '@atlaskit/editor-prosemirror/state';
+import type { CloneOptions } from '../types';
+export declare const cloneRow: (state: EditorState, originRowIndex: number | number[], targetRowIndex: number, targetDirection: 'start' | 'end', options?: CloneOptions) => (tr: Transaction) => Transaction;

package/dist/types-ts4.5/utils.d.ts

@@ -23,6 +23,8 @@ export { isRectSelected, isColumnSelected, isRowSelected, isTableSelected, } fro
 export { isSelectionType } from './utils/is-selection-type';
 export { moveColumn } from './utils/move-column';
 export { moveRow } from './utils/move-row';
+export { cloneColumn } from './utils/clone-column';
+export { cloneRow } from './utils/clone-row';
 export { normalizeSelection } from './utils/normalize-selection';
 export { removeColumnAt, removeSelectedColumns, removeColumnClosestToPos, } from './utils/remove-column';
 export { removeRowAt, removeSelectedRows, removeRowClosestToPos, } from './utils/remove-row';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/editor-tables",
-  "version": "2.5.8",
+  "version": "2.6.0",
   "description": "A package that contains common classes and utility functions for editor tables",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
@@ -71,4 +71,4 @@
     "./types": "./src/types.ts",
     "./utils": "./src/utils.ts"
   }
-}
+}

package/pm-plugins/package.json

@@ -6,7 +6,7 @@
   "sideEffects": false,
   "types": "../dist/types/pm-plugins.d.ts",
   "typesVersions": {
-    ">=4.5 <4.9": {
+    ">=4.5 <5.4": {
       "*": [
         "../dist/types-ts4.5/pm-plugins.d.ts"
       ]

package/table-map/package.json

@@ -6,7 +6,7 @@
   "sideEffects": false,
   "types": "../dist/types/table-map.d.ts",
   "typesVersions": {
-    ">=4.5 <4.9": {
+    ">=4.5 <5.4": {
       "*": [
         "../dist/types-ts4.5/table-map.d.ts"
       ]

package/types/package.json

@@ -6,7 +6,7 @@
   "sideEffects": false,
   "types": "../dist/types/types.d.ts",
   "typesVersions": {
-    ">=4.5 <4.9": {
+    ">=4.5 <5.4": {
       "*": [
         "../dist/types-ts4.5/types.d.ts"
       ]

package/utils/package.json

@@ -6,7 +6,7 @@
   "sideEffects": false,
   "types": "../dist/types/utils.d.ts",
   "typesVersions": {
-    ">=4.5 <4.9": {
+    ">=4.5 <5.4": {
       "*": [
         "../dist/types-ts4.5/utils.d.ts"
       ]