@atlaskit/editor-tables 2.5.7 → 2.6.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @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
+
+- [#80612](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/pull-requests/80612) [`b3a6ffbe9e15`](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/commits/b3a6ffbe9e15) - [ux] Fix Firefox table drag handle shift click selection
+
 ## 2.5.7
 
 ### 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/cell-selection.js

@@ -22,7 +22,7 @@ var _tables = require("./utils/tables");
 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 _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } // Was copied from https://github.com/ProseMirror/prosemirror-tables/blob/master/src/cellselection.js
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); } // Was copied from https://github.com/ProseMirror/prosemirror-tables/blob/master/src/cellselection.js
 // This file defines a ProseMirror selection subclass that models
 // table cell selections. The table plugin needs to be active to wire
 // in the user interaction part of table selections (so that you

package/dist/cjs/pm-plugins/input.js

@@ -140,9 +140,10 @@ function handleMouseDown(view, event, dragAndDropEnabled) {
   }
   var startDOMCell = domInCell(view, startEvent.target);
   var $anchor = (0, _cells.cellAround)(view.state.selection.$anchor);
-  var targetElement = event.target instanceof HTMLElement && event.target;
-  var isDragHandleElement = targetElement && targetElement.matches('button.pm-table-drag-handle-button-container');
   if (startEvent.shiftKey && view.state.selection instanceof _cellSelection.CellSelection) {
+    var isDragHandleElement;
+    var targetElement = event.target instanceof HTMLElement || event.target instanceof SVGElement ? event.target : null;
+    isDragHandleElement = !!targetElement && !!targetElement.closest('button.pm-table-drag-handle-button-container');
     // Adding to an existing cell selection
     if (dragAndDropEnabled && isDragHandleElement) {
       return false;

package/dist/cjs/table-map.js

@@ -18,6 +18,7 @@ var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/cl
 // document-relative positions. So code that uses them will typically
 // compute the start position of the table and offset positions passed
 // to or gotten from this structure by that amount.
+
 var readFromCache, addToCache;
 // Prefer using a weak map to cache table maps. Fall back on a
 // fixed-size cache if that's not supported.

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/copy-paste.js

@@ -30,6 +30,7 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 // clipped to the selection's rectangle, optionally repeating the
 // pasted cells when they are smaller than the selection.
 // Utilities to help with copying and pasting table cells
+
 /**
  * Replace any header cells with table cells.
  *

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

@@ -17,6 +17,7 @@ var createCell = function createCell(cellType, cellContent) {
 // Returns a table node of a given size.
 // `withHeaderRow` defines whether the first row of the table will be a header row.
 // `cellContent` defines the content of each cell.
+
 var createTable = exports.createTable = function createTable(_ref) {
   var schema = _ref.schema,
     _ref$rowsCount = _ref.rowsCount,

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/pm-plugins/input.js

@@ -139,9 +139,10 @@ export function handleMouseDown(view, event, dragAndDropEnabled) {
   }
   const startDOMCell = domInCell(view, startEvent.target);
   const $anchor = cellAround(view.state.selection.$anchor);
-  const targetElement = event.target instanceof HTMLElement && event.target;
-  const isDragHandleElement = targetElement && targetElement.matches('button.pm-table-drag-handle-button-container');
   if (startEvent.shiftKey && view.state.selection instanceof CellSelection) {
+    let isDragHandleElement;
+    const targetElement = event.target instanceof HTMLElement || event.target instanceof SVGElement ? event.target : null;
+    isDragHandleElement = !!targetElement && !!targetElement.closest('button.pm-table-drag-handle-button-container');
     // Adding to an existing cell selection
     if (dragAndDropEnabled && isDragHandleElement) {
       return false;

package/dist/es2019/pm-plugins/table-editing.js

@@ -18,6 +18,7 @@ import { tableEditingKey } from './plugin-key';
 // rather broadly, and other plugins, like the gap cursor or the
 // column-width dragging plugin, might want to get a turn first to
 // perform more specific behavior.
+
 export function tableEditing({
   allowTableNodeSelection = false,
   dragAndDropEnabled = false,

package/dist/es2019/table-map.js

@@ -9,6 +9,7 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
 // document-relative positions. So code that uses them will typically
 // compute the start position of the table and offset positions passed
 // to or gotten from this structure by that amount.
+
 let readFromCache, addToCache;
 // Prefer using a weak map to cache table maps. Fall back on a
 // fixed-size cache if that's not supported.

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/create-table.js

@@ -11,6 +11,7 @@ const createCell = (cellType, cellContent) => {
 // Returns a table node of a given size.
 // `withHeaderRow` defines whether the first row of the table will be a header row.
 // `cellContent` defines the content of each cell.
+
 export const createTable = ({
   schema,
   rowsCount = 3,

package/dist/es2019/utils/reorder-utils.js

@@ -5,6 +5,7 @@ import { TableMap } from '../table-map';
 //   [A2, B2, null, D1],
 //   [A3. B3, C2, null],
 // ]
+
 // This function transposes an array of array flipping the columns for rows,
 // transposition is a familiar algebra concept;
 // you can get more details here:

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/cell-selection.js

@@ -7,7 +7,7 @@ import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
 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; }
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
 // Was copied from https://github.com/ProseMirror/prosemirror-tables/blob/master/src/cellselection.js
 
 // This file defines a ProseMirror selection subclass that models

package/dist/esm/pm-plugins/input.js

@@ -132,9 +132,10 @@ export function handleMouseDown(view, event, dragAndDropEnabled) {
   }
   var startDOMCell = domInCell(view, startEvent.target);
   var $anchor = cellAround(view.state.selection.$anchor);
-  var targetElement = event.target instanceof HTMLElement && event.target;
-  var isDragHandleElement = targetElement && targetElement.matches('button.pm-table-drag-handle-button-container');
   if (startEvent.shiftKey && view.state.selection instanceof CellSelection) {
+    var isDragHandleElement;
+    var targetElement = event.target instanceof HTMLElement || event.target instanceof SVGElement ? event.target : null;
+    isDragHandleElement = !!targetElement && !!targetElement.closest('button.pm-table-drag-handle-button-container');
     // Adding to an existing cell selection
     if (dragAndDropEnabled && isDragHandleElement) {
       return false;

package/dist/esm/pm-plugins/table-editing.js

@@ -18,6 +18,7 @@ import { tableEditingKey } from './plugin-key';
 // rather broadly, and other plugins, like the gap cursor or the
 // column-width dragging plugin, might want to get a turn first to
 // perform more specific behavior.
+
 export function tableEditing() {
   var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
     _ref$allowTableNodeSe = _ref.allowTableNodeSelection,

package/dist/esm/table-map.js

@@ -11,6 +11,7 @@ import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 // document-relative positions. So code that uses them will typically
 // compute the start position of the table and offset positions passed
 // to or gotten from this structure by that amount.
+
 var readFromCache, addToCache;
 // Prefer using a weak map to cache table maps. Fall back on a
 // fixed-size cache if that's not supported.

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/create-table.js

@@ -11,6 +11,7 @@ var createCell = function createCell(cellType, cellContent) {
 // Returns a table node of a given size.
 // `withHeaderRow` defines whether the first row of the table will be a header row.
 // `cellContent` defines the content of each cell.
+
 export var createTable = function createTable(_ref) {
   var schema = _ref.schema,
     _ref$rowsCount = _ref.rowsCount,

package/dist/esm/utils/reorder-utils.js

@@ -5,6 +5,7 @@ import { TableMap } from '../table-map';
 //   [A2, B2, null, D1],
 //   [A3. B3, C2, null],
 // ]
+
 // This function transposes an array of array flipping the columns for rows,
 // transposition is a familiar algebra concept;
 // you can get more details here:

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.7",
+  "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"
       ]