@atlaskit/editor-tables 2.3.18 → 2.5.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @atlaskit/editor-tables
 
+## 2.5.0
+
+### Minor Changes
+
+- [#69232](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/pull-requests/69232) [`93c8f231aa82`](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/commits/93c8f231aa82) - Optimized the table move column logic to perform individual insert/deletes per row
+
+## 2.4.0
+
+### Minor Changes
+
+- [#67400](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/pull-requests/67400) [`191436e36f93`](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/commits/191436e36f93) - Optimised the table move row logic to perform insert/delete steps rather than an entire table replacement
+
 ## 2.3.18
 
 ### Patch Changes

package/dist/cjs/table-map.js

@@ -143,9 +143,34 @@ var TableMap = exports.TableMap = /*#__PURE__*/function () {
   }, {
     key: "isPosMerged",
     value: function isPosMerged(pos) {
-      return this.map.filter(function (cellPos) {
-        return cellPos === pos;
-      }).length > 1;
+      return this.map.includes(pos, this.map.indexOf(pos) + 1);
+    }
+  }, {
+    key: "isCellMerged",
+    value: function isCellMerged(row, col) {
+      return this.isCellMergedTopLeft(row, col) || this.isCellMergedBottomRight(row, col);
+    }
+  }, {
+    key: "isCellMergedTopLeft",
+    value: function isCellMergedTopLeft(row, col) {
+      var pos = this.map[row * this.width + col];
+      return (
+        // top
+        row > 0 && pos === this.map[(row - 1) * this.width + col] ||
+        // left
+        col > 0 && pos === this.map[row * this.width + (col - 1)]
+      );
+    }
+  }, {
+    key: "isCellMergedBottomRight",
+    value: function isCellMergedBottomRight(row, col) {
+      var pos = this.map[row * this.width + col];
+      return (
+        // bottom
+        row < this.height - 1 && pos === this.map[(row + 1) * this.width + col] ||
+        // right
+        col < this.width - 1 && pos === this.map[row * this.width + (col + 1)]
+      );
     }
 
     // :: (number, string, number) → ?number

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

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.determineTableHeaderStateFromTableNode = determineTableHeaderStateFromTableNode;
+function determineTableHeaderStateFromTableNode(table, tableMap, types) {
+  // We only really need to check the 2nd cell in the row/col if it's a header, since we only support a single full row/col header on the top & left
+  // of a table. We can assume that if the 2nd cell is a header then the entire row/col is a header.
+  // Be carefull though! when checking the 1st cell as it shares its header state with both row/cols.
+  // This means we wont be able to reliably identify header state on tables smaller the 2x2, however we can do best guess.
+
+  // This is a 3 bit mask;
+  // bit: 0 = Identifies if the cell at (0, 0) (row, col - 0-based) is a header cell or not
+  // bit: 1 = Identifies if the cell at (0, 1) is a header cell or not
+  // bit: 2 = Identifies if the cell at (1, 0) is a header cell or not
+  var mask = 0;
+
+  // At minimum we should have 1 cell in the table.
+  var topLeftCell = table.nodeAt(tableMap.map[0]);
+  // If this cell is a header that could indicate
+  mask |= topLeftCell && topLeftCell.type === types.header_cell ? 1 : 0;
+  if (tableMap.width > 1) {
+    var cell = table.nodeAt(tableMap.map[1]);
+    // If the cell at (0, 1) is a header then we set the bit flag to indicate row headers are enabled, otherwise if it's
+    // not then we will set the col headers enabled flag (and vice versa in the branch below) only if the cell at (0,0)
+    // was a header cell.
+    mask |= cell && cell.type === types.header_cell ? 2 : 4 * (mask & 1);
+  }
+  if (tableMap.height > 1) {
+    var _cell = table.nodeAt(tableMap.map[tableMap.width]);
+    mask |= _cell && _cell.type === types.header_cell ? 4 : 2 * (mask & 1);
+  }
+  return {
+    rowHeaderEnabled: mask === 7 || mask === 3,
+    columnHeaderEnabled: mask === 7 || mask === 5
+  };
+}

package/dist/cjs/utils/get-selection-range-in-column.js

@@ -7,10 +7,11 @@ exports.getSelectionRangeInColumn = void 0;
 var _getCellsInColumn = require("./get-cells-in-column");
 var _getCellsInRow = require("./get-cells-in-row");
 // Returns a range of rectangular selection spanning all merged cells around a column at index `columnIndex`.
-var getSelectionRangeInColumn = exports.getSelectionRangeInColumn = function getSelectionRangeInColumn(columnIndex) {
+var getSelectionRangeInColumn = exports.getSelectionRangeInColumn = function getSelectionRangeInColumn(startColIndex) {
+  var endColIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : startColIndex;
   return function (tr) {
-    var startIndex = columnIndex;
-    var endIndex = columnIndex;
+    var startIndex = startColIndex;
+    var endIndex = endColIndex;
 
     // looking for selection start column (startIndex)
     var _loop = function _loop(i) {
@@ -27,7 +28,7 @@ var getSelectionRangeInColumn = exports.getSelectionRangeInColumn = function get
         });
       }
     };
-    for (var i = columnIndex; i >= 0; i--) {
+    for (var i = startColIndex; i >= 0; i--) {
       _loop(i);
     }
     // looking for selection end column (endIndex)
@@ -42,7 +43,7 @@ var getSelectionRangeInColumn = exports.getSelectionRangeInColumn = function get
         });
       }
     };
-    for (var _i = columnIndex; _i <= endIndex; _i++) {
+    for (var _i = startColIndex; _i <= endIndex; _i++) {
       _loop2(_i);
     }
 

package/dist/cjs/utils/get-selection-range-in-row.js

@@ -7,10 +7,11 @@ exports.getSelectionRangeInRow = void 0;
 var _getCellsInColumn = require("./get-cells-in-column");
 var _getCellsInRow = require("./get-cells-in-row");
 // Returns a range of rectangular selection spanning all merged cells around a row at index `rowIndex`.
-var getSelectionRangeInRow = exports.getSelectionRangeInRow = function getSelectionRangeInRow(rowIndex) {
+var getSelectionRangeInRow = exports.getSelectionRangeInRow = function getSelectionRangeInRow(startRowIndex) {
+  var endRowIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : startRowIndex;
   return function (tr) {
-    var startIndex = rowIndex;
-    var endIndex = rowIndex;
+    var startIndex = startRowIndex;
+    var endIndex = endRowIndex;
 
     // looking for selection start row (startIndex)
     var _loop = function _loop(i) {
@@ -27,7 +28,7 @@ var getSelectionRangeInRow = exports.getSelectionRangeInRow = function getSelect
         });
       }
     };
-    for (var i = rowIndex; i >= 0; i--) {
+    for (var i = startRowIndex; i >= 0; i--) {
       _loop(i);
     }
     // looking for selection end row (endIndex)
@@ -42,7 +43,7 @@ var getSelectionRangeInRow = exports.getSelectionRangeInRow = function getSelect
         });
       }
     };
-    for (var _i = rowIndex; _i <= endIndex; _i++) {
+    for (var _i = startRowIndex; _i <= endIndex; _i++) {
       _loop2(_i);
     }
 

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

@@ -1,13 +1,19 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.moveColumn = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+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 _normalizeDirection = require("./normalize-direction");
 var _reorderUtils = require("./reorder-utils");
+var _tableNodeTypes = require("./table-node-types");
 // :: (originColumnIndex: number, targetColumnIndex: targetColumnIndex, options?: MovementOptions) → (tr: Transaction) → Transaction
 // Returns a new transaction that moves the origin column to the target index;
 //
@@ -136,8 +142,8 @@ var _reorderUtils = require("./reorder-utils");
 //   moveColumn(x, y, options)(state.tr)
 // );
 // ```
-var moveColumn = exports.moveColumn = function moveColumn(originColumnIndex, targetColumnIndex) {
-  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+var moveColumn = exports.moveColumn = function moveColumn(state, originColumnIndex, targetColumnIndex) {
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {
     tryToFit: false,
     direction: 0
   };
@@ -147,18 +153,115 @@ var moveColumn = exports.moveColumn = function moveColumn(originColumnIndex, tar
     if (!table) {
       return tr;
     }
-    var originalColumnRanges = (0, _getSelectionRangeInColumn.getSelectionRangeInColumn)(originColumnIndex)(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 (indexesOriginColumn.includes(targetColumnIndex)) {
       return tr;
     }
     if (!options.tryToFit && indexesTargetColumn.length > 1) {
-      (0, _reorderUtils.isValidReorder)(originColumnIndex, targetColumnIndex, indexesTargetColumn, 'column');
+      (0, _reorderUtils.isValidReorder)(originColumnIndex[0], targetColumnIndex, indexesTargetColumn, 'column');
+    }
+    var types = (0, _tableNodeTypes.tableNodeTypes)(state.schema);
+    var direction = (0, _normalizeDirection.normalizeDirection)(min, targetColumnIndex, 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 && (min === 0 || actualTargetIndex === 0)) {
+        // 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);
+      }
     }
-    var newTable = (0, _reorderUtils.moveTableColumn)(table, indexesOriginColumn, indexesTargetColumn, options.direction);
-    var newTr = (0, _cloneTr.cloneTr)(tr).replaceWith(table.pos, table.pos + table.node.nodeSize, newTable);
+    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);
+      newTr.insert(insertPos, row.map(function (_ref, x) {
+        var node = _ref.node;
+        return normalizeCellNode(node, rowHeaderEnabled && y === 0, columnHeaderEnabled && actualTargetIndex === 0 && x === 0, types);
+      }));
+
+      // NOTE: only consecutive cells can be moved, this means we can simplify the delete op into a single step which
+      // deletes the range of cells.
+      var first = row[0];
+      var last = row[row.length - 1];
+      return newTr.delete(newTr.mapping.map(first.pos, 1), newTr.mapping.map(last.pos + last.node.nodeSize, -1));
+    });
     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/move-row.js

@@ -1,13 +1,20 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.moveRow = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+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 _normalizeDirection = require("./normalize-direction");
 var _reorderUtils = require("./reorder-utils");
+var _tableNodeTypes = require("./table-node-types");
 // :: (originRowIndex: number, targetRowIndex: targetColumnIndex, options?: MovementOptions) → (tr: Transaction) → Transaction
 // Returns a new transaction that moves the origin row to the target index;
 //
@@ -151,8 +158,8 @@ var _reorderUtils = require("./reorder-utils");
 //   moveRow(x, y, options)(state.tr)
 // );
 // ```
-var moveRow = exports.moveRow = function moveRow(originRowIndex, targetRowIndex) {
-  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+var moveRow = exports.moveRow = function moveRow(state, originRowIndex, targetRowIndex) {
+  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {
     tryToFit: false,
     direction: 0
   };
@@ -161,18 +168,99 @@ var moveRow = exports.moveRow = function moveRow(originRowIndex, targetRowIndex)
     if (!table) {
       return tr;
     }
-    var originalRowRanges = (0, _getSelectionRangeInRow.getSelectionRangeInRow)(originRowIndex)(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];
+    }
+    if (originRowIndex.includes(targetRowIndex)) {
+      return tr;
+    }
+    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 (indexesOriginRow.includes(targetRowIndex)) {
+    if (originMin < 0 || originMin === Number.MAX_SAFE_INTEGER || originMax >= tableMap.height || originMax === Number.MIN_SAFE_INTEGER ||
+    // The target index cannot be within the origin bounds
+    targetRowIndex >= originMin && targetRowIndex <= originMax) {
       return tr;
     }
     if (!options.tryToFit && indexesTargetRow.length > 1) {
-      (0, _reorderUtils.isValidReorder)(originRowIndex, targetRowIndex, indexesTargetRow, 'row');
+      (0, _reorderUtils.isValidReorder)(originMin, targetRowIndex, indexesTargetRow, 'row');
+    }
+    var types = (0, _tableNodeTypes.tableNodeTypes)(state.schema);
+    var direction = (0, _normalizeDirection.normalizeDirection)(originMin, targetRowIndex, 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 && (originMin === 0 || actualTargetIndex === 0)) {
+        // 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, columnHeaderEnabled, types);
+      }));
+      originNodes.forEach(function (_ref4) {
+        var pos = _ref4.pos,
+          node = _ref4.node;
+        newTr.delete(newTr.mapping.map(pos, 1), newTr.mapping.map(pos + node.nodeSize, -1));
+      });
+      return newTr;
     }
-    var newTable = (0, _reorderUtils.moveTableRow)(table, indexesOriginRow, indexesTargetRow, options.direction);
-    var newTr = (0, _cloneTr.cloneTr)(tr).replaceWith(table.pos, table.pos + table.node.nodeSize, newTable);
-    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/normalize-direction.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeDirection = normalizeDirection;
+function normalizeDirection(origin, target) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+    tryToFit: false,
+    direction: 0
+  };
+  var dir = origin < target ? 'end' : 'start';
+  var override = options.direction < 0 ? 'start' : 'end';
+  return options.tryToFit && !!options.direction ? override : dir;
+}

package/dist/es2019/table-map.js

@@ -124,7 +124,28 @@ export class TableMap {
     throw new RangeError('No cell with offset ' + pos + ' found');
   }
   isPosMerged(pos) {
-    return this.map.filter(cellPos => cellPos === pos).length > 1;
+    return this.map.includes(pos, this.map.indexOf(pos) + 1);
+  }
+  isCellMerged(row, col) {
+    return this.isCellMergedTopLeft(row, col) || this.isCellMergedBottomRight(row, col);
+  }
+  isCellMergedTopLeft(row, col) {
+    const pos = this.map[row * this.width + col];
+    return (
+      // top
+      row > 0 && pos === this.map[(row - 1) * this.width + col] ||
+      // left
+      col > 0 && pos === this.map[row * this.width + (col - 1)]
+    );
+  }
+  isCellMergedBottomRight(row, col) {
+    const pos = this.map[row * this.width + col];
+    return (
+      // bottom
+      row < this.height - 1 && pos === this.map[(row + 1) * this.width + col] ||
+      // right
+      col < this.width - 1 && pos === this.map[row * this.width + (col + 1)]
+    );
   }
 
   // :: (number, string, number) → ?number

package/dist/es2019/utils/analyse-table.js

@@ -0,0 +1,32 @@
+export function determineTableHeaderStateFromTableNode(table, tableMap, types) {
+  // We only really need to check the 2nd cell in the row/col if it's a header, since we only support a single full row/col header on the top & left
+  // of a table. We can assume that if the 2nd cell is a header then the entire row/col is a header.
+  // Be carefull though! when checking the 1st cell as it shares its header state with both row/cols.
+  // This means we wont be able to reliably identify header state on tables smaller the 2x2, however we can do best guess.
+
+  // This is a 3 bit mask;
+  // bit: 0 = Identifies if the cell at (0, 0) (row, col - 0-based) is a header cell or not
+  // bit: 1 = Identifies if the cell at (0, 1) is a header cell or not
+  // bit: 2 = Identifies if the cell at (1, 0) is a header cell or not
+  let mask = 0;
+
+  // At minimum we should have 1 cell in the table.
+  const topLeftCell = table.nodeAt(tableMap.map[0]);
+  // If this cell is a header that could indicate
+  mask |= topLeftCell && topLeftCell.type === types.header_cell ? 1 : 0;
+  if (tableMap.width > 1) {
+    const cell = table.nodeAt(tableMap.map[1]);
+    // If the cell at (0, 1) is a header then we set the bit flag to indicate row headers are enabled, otherwise if it's
+    // not then we will set the col headers enabled flag (and vice versa in the branch below) only if the cell at (0,0)
+    // was a header cell.
+    mask |= cell && cell.type === types.header_cell ? 2 : 4 * (mask & 1);
+  }
+  if (tableMap.height > 1) {
+    const cell = table.nodeAt(tableMap.map[tableMap.width]);
+    mask |= cell && cell.type === types.header_cell ? 4 : 2 * (mask & 1);
+  }
+  return {
+    rowHeaderEnabled: mask === 7 || mask === 3,
+    columnHeaderEnabled: mask === 7 || mask === 5
+  };
+}

package/dist/es2019/utils/get-selection-range-in-column.js

@@ -2,12 +2,12 @@ import { getCellsInColumn } from './get-cells-in-column';
 import { getCellsInRow } from './get-cells-in-row';
 
 // Returns a range of rectangular selection spanning all merged cells around a column at index `columnIndex`.
-export const getSelectionRangeInColumn = columnIndex => tr => {
-  let startIndex = columnIndex;
-  let endIndex = columnIndex;
+export const getSelectionRangeInColumn = (startColIndex, endColIndex = startColIndex) => tr => {
+  let startIndex = startColIndex;
+  let endIndex = endColIndex;
 
   // looking for selection start column (startIndex)
-  for (let i = columnIndex; i >= 0; i--) {
+  for (let i = startColIndex; i >= 0; i--) {
     const cells = getCellsInColumn(i)(tr.selection);
     if (cells) {
       cells.forEach(cell => {
@@ -22,7 +22,7 @@ export const getSelectionRangeInColumn = columnIndex => tr => {
     }
   }
   // looking for selection end column (endIndex)
-  for (let i = columnIndex; i <= endIndex; i++) {
+  for (let i = startColIndex; i <= endIndex; i++) {
     const cells = getCellsInColumn(i)(tr.selection);
     if (cells) {
       cells.forEach(cell => {

package/dist/es2019/utils/get-selection-range-in-row.js

@@ -2,12 +2,12 @@ import { getCellsInColumn } from './get-cells-in-column';
 import { getCellsInRow } from './get-cells-in-row';
 
 // Returns a range of rectangular selection spanning all merged cells around a row at index `rowIndex`.
-export const getSelectionRangeInRow = rowIndex => tr => {
-  let startIndex = rowIndex;
-  let endIndex = rowIndex;
+export const getSelectionRangeInRow = (startRowIndex, endRowIndex = startRowIndex) => tr => {
+  let startIndex = startRowIndex;
+  let endIndex = endRowIndex;
 
   // looking for selection start row (startIndex)
-  for (let i = rowIndex; i >= 0; i--) {
+  for (let i = startRowIndex; i >= 0; i--) {
     const cells = getCellsInRow(i)(tr.selection);
     if (cells) {
       cells.forEach(cell => {
@@ -22,7 +22,7 @@ export const getSelectionRangeInRow = rowIndex => tr => {
     }
   }
   // looking for selection end row (endIndex)
-  for (let i = rowIndex; i <= endIndex; i++) {
+  for (let i = startRowIndex; i <= endIndex; i++) {
     const cells = getCellsInRow(i)(tr.selection);
     if (cells) {
       cells.forEach(cell => {