@atlaskit/editor-tables 2.5.8 → 2.6.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @atlaskit/editor-tables
 
+## 2.6.1
+
+### Patch Changes
+
+- [#86621](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/pull-requests/86621) [`819e262c9b0b`](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/commits/819e262c9b0b) - remove table-shift-click-selection-backward feature flag
+
+## 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/pm-plugins/input.js

@@ -143,8 +143,7 @@ function handleMouseDown(view, event, dragAndDropEnabled) {
   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
+    isDragHandleElement = !!targetElement && !!targetElement.closest('button.pm-table-drag-handle-button-container, button.pm-table-drag-handle-button-clickable-zone');
     if (dragAndDropEnabled && isDragHandleElement) {
       return false;
     }

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/select-nodes.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.selectTableClosestToPos = exports.selectTable = exports.selectRows = exports.selectRow = exports.selectColumns = exports.selectColumn = void 0;
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
 var _cellSelection = require("../cell-selection");
 var _tableMap = require("../table-map");
 var _cloneTr = require("./clone-tr");
@@ -37,52 +36,48 @@ var select = function select(type) {
             if (isRowSelection) {
               top = Math.min(top, selRect.top);
               bottom = Math.max(bottom, selRect.bottom);
-              if ((0, _platformFeatureFlags.getBooleanFF)('platform.editor.table-shift-click-selection-backward')) {
-                cellsInFirstRow = map.cellsInRect({
-                  left: left,
-                  top: top,
-                  right: right,
-                  bottom: top + 1
-                });
-                var targetRowCells = map.cellsInRect({
-                  left: left,
-                  top: index,
-                  right: right,
-                  bottom: index + 1
-                });
-                var isBackwardSelection = targetRowCells[0] < prevSelection.$head.pos - table.start;
-                if (isBackwardSelection && isPrevRowSelection) {
-                  var _head = table.start + cellsInFirstRow[0];
-                  var _anchor = prevSelection.$anchorCell.pos;
-                  var _$head = tr.doc.resolve(_head);
-                  var _$anchor = tr.doc.resolve(_anchor);
-                  return (0, _cloneTr.cloneTr)(tr.setSelection(new _cellSelection.CellSelection(_$anchor, _$head)));
-                }
+              cellsInFirstRow = map.cellsInRect({
+                left: left,
+                top: top,
+                right: right,
+                bottom: top + 1
+              });
+              var targetRowCells = map.cellsInRect({
+                left: left,
+                top: index,
+                right: right,
+                bottom: index + 1
+              });
+              var isBackwardSelection = targetRowCells[0] < prevSelection.$head.pos - table.start;
+              if (isBackwardSelection && isPrevRowSelection) {
+                var _head = table.start + cellsInFirstRow[0];
+                var _anchor = prevSelection.$anchorCell.pos;
+                var _$head = tr.doc.resolve(_head);
+                var _$anchor = tr.doc.resolve(_anchor);
+                return (0, _cloneTr.cloneTr)(tr.setSelection(new _cellSelection.CellSelection(_$anchor, _$head)));
               }
             } else {
               left = Math.min(left, selRect.left);
               right = Math.max(right, selRect.right);
-              if ((0, _platformFeatureFlags.getBooleanFF)('platform.editor.table-shift-click-selection-backward')) {
-                cellsInFirstRow = map.cellsInRect({
-                  left: left,
-                  top: top,
-                  right: left + 1,
-                  bottom: bottom
-                });
-                var _targetRowCells = map.cellsInRect({
-                  left: index,
-                  top: top,
-                  right: index + 1,
-                  bottom: bottom
-                });
-                var _isBackwardSelection = _targetRowCells[0] < prevSelection.$head.pos - table.start;
-                if (_isBackwardSelection && isPrevRowSelection) {
-                  var _head2 = table.start + cellsInFirstRow[0];
-                  var _anchor2 = prevSelection.$anchorCell.pos;
-                  var _$head2 = tr.doc.resolve(_head2);
-                  var _$anchor2 = tr.doc.resolve(_anchor2);
-                  return (0, _cloneTr.cloneTr)(tr.setSelection(new _cellSelection.CellSelection(_$anchor2, _$head2)));
-                }
+              cellsInFirstRow = map.cellsInRect({
+                left: left,
+                top: top,
+                right: left + 1,
+                bottom: bottom
+              });
+              var _targetRowCells = map.cellsInRect({
+                left: index,
+                top: top,
+                right: index + 1,
+                bottom: bottom
+              });
+              var _isBackwardSelection = _targetRowCells[0] < prevSelection.$head.pos - table.start;
+              if (_isBackwardSelection && isPrevRowSelection) {
+                var _head2 = table.start + cellsInFirstRow[0];
+                var _anchor2 = prevSelection.$anchorCell.pos;
+                var _$head2 = tr.doc.resolve(_head2);
+                var _$anchor2 = tr.doc.resolve(_anchor2);
+                return (0, _cloneTr.cloneTr)(tr.setSelection(new _cellSelection.CellSelection(_$anchor2, _$head2)));
               }
             }
           }

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

@@ -142,8 +142,7 @@ export function handleMouseDown(view, event, dragAndDropEnabled) {
   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
+    isDragHandleElement = !!targetElement && !!targetElement.closest('button.pm-table-drag-handle-button-container, button.pm-table-drag-handle-button-clickable-zone');
     if (dragAndDropEnabled && isDragHandleElement) {
       return false;
     }

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];
+}