@atlaskit/editor-tables 3.1.14 → 3.2.0

package/dist/esm/utils/remove-selected-columns.js

@@ -0,0 +1,43 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { TableMap } from '../table-map';
+import { cloneTr } from './clone-tr';
+import { findTable } from './find-table';
+import { isSelectionType } from './is-selection-type';
+import { isTableSelected } from './is-table-selected';
+import { removeColumn } from './remove-column';
+import { removeTable } from './remove-table';
+
+// Returns a new transaction that removes selected columns.
+export var removeSelectedColumns = function removeSelectedColumns(tr) {
+  var selection = tr.selection;
+  if (isTableSelected(selection)) {
+    return removeTable(tr);
+  }
+  if (isSelectionType(selection, 'cell')) {
+    var table = findTable(selection);
+    if (table) {
+      var map = TableMap.get(table.node);
+      var rect = map.rectBetween(selection.$anchorCell.pos - table.start, selection.$headCell.pos - table.start);
+      if (rect.left === 0 && rect.right === map.width) {
+        return tr;
+      }
+      var pmTableRect = _objectSpread(_objectSpread({}, rect), {}, {
+        map: map,
+        table: table.node,
+        tableStart: table.start
+      });
+      for (var i = pmTableRect.right - 1;; i--) {
+        removeColumn(tr, pmTableRect, i);
+        if (i === pmTableRect.left) {
+          break;
+        }
+        pmTableRect.table = pmTableRect.tableStart ? tr.doc.nodeAt(pmTableRect.tableStart - 1) : tr.doc;
+        pmTableRect.map = TableMap.get(pmTableRect.table);
+      }
+      return cloneTr(tr);
+    }
+  }
+  return tr;
+};

package/dist/esm/utils/remove-selected-rows.js

@@ -0,0 +1,43 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { TableMap } from '../table-map';
+import { cloneTr } from './clone-tr';
+import { findTable } from './find-table';
+import { isSelectionType } from './is-selection-type';
+import { isTableSelected } from './is-table-selected';
+import { removeRow } from './remove-row';
+import { removeTable } from './remove-table';
+
+// Returns a new transaction that removes selected rows.
+export var removeSelectedRows = function removeSelectedRows(tr) {
+  var selection = tr.selection;
+  if (isTableSelected(selection)) {
+    return removeTable(tr);
+  }
+  if (isSelectionType(selection, 'cell')) {
+    var table = findTable(selection);
+    if (table) {
+      var map = TableMap.get(table.node);
+      var rect = map.rectBetween(selection.$anchorCell.pos - table.start, selection.$headCell.pos - table.start);
+      if (rect.top === 0 && rect.bottom === map.height) {
+        return tr;
+      }
+      var pmTableRect = _objectSpread(_objectSpread({}, rect), {}, {
+        map: map,
+        table: table.node,
+        tableStart: table.start
+      });
+      for (var i = pmTableRect.bottom - 1;; i--) {
+        removeRow(tr, pmTableRect, i);
+        if (i === pmTableRect.top) {
+          break;
+        }
+        pmTableRect.table = pmTableRect.tableStart ? tr.doc.nodeAt(pmTableRect.tableStart - 1) : tr.doc;
+        pmTableRect.map = TableMap.get(pmTableRect.table);
+      }
+      return cloneTr(tr);
+    }
+  }
+  return tr;
+};

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

@@ -1,182 +1,42 @@
-import { TableMap } from '../table-map';
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
 
-// array = [
-//   [A1, B1, C1, null],
-//   [A2, B2, null, D1],
-//   [A3. B3, C2, null],
-// ]
+/**
+ * @deprecated Use `import { transpose } from '@atlaskit/editor-tables/utils/reorder-utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { transpose } from './transpose';
+/**
+ * @deprecated Use `import { convertArrayOfRowsToTableNode } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { convertArrayOfRowsToTableNode } from './convert-array-of-rows-to-table-node';
+/**
+ * @deprecated Use `import { convertTableNodeToArrayOfRows } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { convertTableNodeToArrayOfRows } from './convert-table-node-to-array-of-rows';
+/**
+ * @deprecated Use `import { moveTableRow } from '@atlaskit/editor-tables/utils/reorder-utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { moveTableRow } from './move-table-row';
+/**
+ * @deprecated Use `import { moveTableColumn } from '@atlaskit/editor-tables/utils/reorder-utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { moveTableColumn } from './move-table-column';
+/**
+ * @deprecated Use `import { isValidReorder } from '@atlaskit/editor-tables/utils/reorder-utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { isValidReorder } from './is-valid-reorder';
+/**
+ * @deprecated Use `import type { ArrayOfRows } from '@atlaskit/editor-tables/utils/reorder-utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
 
-// This function transposes an array of array flipping the columns for rows,
-// transposition is a familiar algebra concept;
-// you can get more details here:
-// https://en.wikipedia.org/wiki/Transpose
-//
-// ```javascript
-//
-//  const arr = [
-//    ['a1', 'a2', 'a3'],
-//    ['b1', 'b2', 'b3'],
-//    ['c1', 'c2', 'c3'],
-//    ['d1', 'd2', 'd3'],
-//  ];
-//
-//  const result = transpose(arr);
-//
-//  result === [
-//    ['a1', 'b1', 'c1', 'd1'],
-//    ['a2', 'b2', 'c2', 'd2'],
-//    ['a3', 'b3', 'c3', 'd3'],
-//  ]
-// ```
-// Ignored via go/ees005
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export var transpose = function transpose(array) {
-  // Ignored via go/ees005
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  return array[0].map(function (_, i) {
-    return array.map(function (column) {
-      return column[i];
-    });
-  });
-};
-
-// :: (tableNode: Node, tableArray: Array<Node>) -> Node
-// This function will transform a matrix of nodes
-// into table node respecting merged cells and rows configurations,
-// for example this array will be convert to the table below:
-//
-// ```javascript
-// array = [
-//   [A1, B1, C1, null],
-//   [A2, B2, null, D1],
-//   [A3. B3, C2, null],
-// ]
-// ```
-//
-// ```
-//  ____________________________
-// |      |      |             |
-// |  A1  |  B1  |     C1      |
-// |______|______|______ ______|
-// |      |             |      |
-// |  A2  |     B2      |      |
-// |______|______ ______|      |
-// |      |      |      |  D1  |
-// |  A3  |  B3  |  C2  |      |
-// |______|______|______|______|
-// ```
-//
-export var convertArrayOfRowsToTableNode = function convertArrayOfRowsToTableNode(tableNode, arrayOfNodes) {
-  var rowsPM = [];
-  var map = TableMap.get(tableNode);
-  for (var rowIndex = 0; rowIndex < map.height; rowIndex++) {
-    var row = tableNode.child(rowIndex);
-    var rowCells = [];
-    for (var colIndex = 0; colIndex < map.width; colIndex++) {
-      if (!arrayOfNodes[rowIndex][colIndex]) {
-        continue;
-      }
-      var cellPos = map.map[rowIndex * map.width + colIndex];
-      var cell = arrayOfNodes[rowIndex][colIndex];
-      var oldCell = tableNode.nodeAt(cellPos);
-      if (!cell || !oldCell) {
-        continue;
-      }
-      var newCell = oldCell.type.createChecked(Object.assign({}, cell.attrs), cell.content, cell.marks);
-      rowCells.push(newCell);
-    }
-    rowsPM.push(row.type.createChecked(row.attrs, rowCells, row.marks));
-  }
-  var newTable = tableNode.type.createChecked(tableNode.attrs, rowsPM, tableNode.marks);
-  return newTable;
-};
-var moveRowInArrayOfRows = function moveRowInArrayOfRows(arrayOfNodes, indexesOrigin, indexesTarget, directionOverride) {
-  var direction = indexesOrigin[0] > indexesTarget[0] ? -1 : 1;
-  var rowsExtracted = arrayOfNodes.splice(indexesOrigin[0], indexesOrigin.length);
-  var positionOffset = rowsExtracted.length % 2 === 0 ? 1 : 0;
-  var target;
-  if (directionOverride === -1 && direction === 1) {
-    target = indexesTarget[0] - 1;
-  } else if (directionOverride === 1 && direction === -1) {
-    target = indexesTarget[indexesTarget.length - 1] - positionOffset + 1;
-  } else {
-    target = direction === -1 ? indexesTarget[0] : indexesTarget[indexesTarget.length - 1] - positionOffset;
-  }
-
-  // @ts-ignore no idea what this line does
-  arrayOfNodes.splice.apply(arrayOfNodes, [target, 0].concat(rowsExtracted));
-  return arrayOfNodes;
-};
-
-// :: (tableNode: Node) -> Array<Node>
-// This function will transform the table node
-// into a matrix of rows and columns respecting merged cells,
-// for example this table will be convert to the below:
-//
-// ```
-//  ____________________________
-// |      |      |             |
-// |  A1  |  B1  |     C1      |
-// |______|______|______ ______|
-// |      |             |      |
-// |  A2  |     B2      |      |
-// |______|______ ______|      |
-// |      |      |      |  D1  |
-// |  A3  |  B3  |  C2  |      |
-// |______|______|______|______|
-// ```
-//
-//
-// ```javascript
-// array = [
-//   [A1, B1, C1, null],
-//   [A2, B2, null, D1],
-//   [A3. B3, C2, null],
-// ]
-// ```
-export var convertTableNodeToArrayOfRows = function convertTableNodeToArrayOfRows(tableNode) {
-  var map = TableMap.get(tableNode);
-  var rows = [];
-  for (var rowIndex = 0; rowIndex < map.height; rowIndex++) {
-    var rowCells = [];
-    var seen = {};
-    for (var colIndex = 0; colIndex < map.width; colIndex++) {
-      var cellPos = map.map[rowIndex * map.width + colIndex];
-      var cell = tableNode.nodeAt(cellPos);
-      var rect = map.findCell(cellPos);
-      if (!cell || seen[cellPos] || rect.top !== rowIndex) {
-        rowCells.push(null);
-        continue;
-      }
-      seen[cellPos] = true;
-      rowCells.push(cell);
-    }
-    rows.push(rowCells);
-  }
-  return rows;
-};
-export var moveTableRow = function moveTableRow(table, indexesOrigin, indexesTarget, direction) {
-  var rows = convertTableNodeToArrayOfRows(table.node);
-  rows = moveRowInArrayOfRows(rows, indexesOrigin, indexesTarget, direction);
-  return convertArrayOfRowsToTableNode(table.node, rows);
-};
-export var moveTableColumn = function moveTableColumn(table, indexesOrigin, indexesTarget, direction) {
-  var rows = transpose(convertTableNodeToArrayOfRows(table.node));
-  rows = moveRowInArrayOfRows(rows, indexesOrigin, indexesTarget, direction);
-  rows = transpose(rows);
-  return convertArrayOfRowsToTableNode(table.node, rows);
-};
-export var isValidReorder = function isValidReorder(originIndex, targetIndex, targets, type) {
-  var direction = originIndex > targetIndex ? -1 : 1;
-  var errorMessage = "Target position is invalid, you can't move the ".concat(type, " ").concat(originIndex, " to ").concat(targetIndex, ", the target can't be split. You could use tryToFit option.");
-  if (direction === 1) {
-    if (targets.slice(0, targets.length - 1).indexOf(targetIndex) !== -1) {
-      throw new Error(errorMessage);
-    }
-  } else {
-    if (targets.slice(1).indexOf(targetIndex) !== -1) {
-      throw new Error(errorMessage);
-    }
-  }
-  return true;
-};
+/**
+ * @deprecated Use `import { moveRowInArrayOfRows } from '@atlaskit/editor-tables/utils/reorder-utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { moveRowInArrayOfRows } from './move-row-in-array-of-rows';

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

@@ -1,7 +1,7 @@
 import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
 import { TextSelection } from '@atlaskit/editor-prosemirror/state';
-import { findTable } from './find';
-import { isTableSelected } from './is-selected';
+import { findTable } from './find-table';
+import { isTableSelected } from './is-table-selected';
 export var replaceSelectedTable = function replaceSelectedTable(state, content) {
   if (isTableSelected(state.selection)) {
     var table = findTable(state.selection);

package/dist/esm/utils/select-nodes.js

@@ -1,9 +1,11 @@
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-import { editorExperiment } from '@atlaskit/tmp-editor-statsig/editor-experiment';
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
+
 import { CellSelection } from '../cell-selection';
 import { TableMap } from '../table-map';
 import { cloneTr } from './clone-tr';
-import { findCellClosestToPos, findTable, findTableClosestToPos } from './find';
+import { findCellClosestToPos } from './find-cell-closest-to-pos';
+import { findTable } from './find-table';
 var select = function select(type) {
   return function (index, expand) {
     return function (tr) {
@@ -144,57 +146,18 @@ export var selectRows = selectRowsOrColumns('rows');
 // Returns a new transaction that selects all columns at `indexes`.
 export var selectColumns = selectRowsOrColumns('columns');
 
-// Returns a new transaction that selects a table.
-export var selectTable = function selectTable(tr) {
-  var table = findTable(tr.selection);
-  if (table) {
-    var _TableMap$get = TableMap.get(table.node),
-      map = _TableMap$get.map;
-    if (map && map.length) {
-      var head = table.start + map[0];
-      var anchor = table.start + map[map.length - 1];
-      var $head = tr.doc.resolve(head);
-      var $anchor = tr.doc.resolve(anchor);
-      return cloneTr(tr.setSelection(new CellSelection($anchor, $head)));
-    }
-  }
-  return tr;
-};
-export var getTableSelectionClosesToPos = function getTableSelectionClosesToPos($pos) {
-  var table = findTableClosestToPos($pos);
-  if (table) {
-    var _TableMap$get2 = TableMap.get(table.node),
-      map = _TableMap$get2.map;
-    if (map && map.length) {
-      var head = table.start + map[0];
-      var anchor = table.start + map[map.length - 1];
-      var $head = $pos.doc.resolve(head);
-      var $anchor = $pos.doc.resolve(anchor);
-      return new CellSelection($anchor, $head);
-    }
-  }
-};
-export var selectTableClosestToPos = function selectTableClosestToPos(tr, $pos) {
-  if (editorExperiment('platform_editor_block_menu', true, {
-    exposure: true
-  })) {
-    var tableSelection = getTableSelectionClosesToPos($pos);
-    if (tableSelection) {
-      return cloneTr(tr.setSelection(tableSelection));
-    }
-    return tr;
-  }
-  var table = findTableClosestToPos($pos);
-  if (table) {
-    var _TableMap$get3 = TableMap.get(table.node),
-      map = _TableMap$get3.map;
-    if (map && map.length) {
-      var head = table.start + map[0];
-      var anchor = table.start + map[map.length - 1];
-      var $head = tr.doc.resolve(head);
-      var $anchor = tr.doc.resolve(anchor);
-      return cloneTr(tr.setSelection(new CellSelection($anchor, $head)));
-    }
-  }
-  return tr;
-};
+/**
+ * @deprecated Use `import { selectTable } from '@atlaskit/editor-tables/select-table'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { selectTable } from './select-table';
+/**
+ * @deprecated Use `import { getTableSelectionClosesToPos } from '@atlaskit/editor-tables/get-table-selection-closes-to-pos'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { getTableSelectionClosesToPos } from './get-table-selection-closes-to-pos';
+/**
+ * @deprecated Use `import { selectTableClosestToPos } from '@atlaskit/editor-tables/select-table-closest-to-pos'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { selectTableClosestToPos } from './select-table-closest-to-pos';

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

@@ -0,0 +1,30 @@
+import { editorExperiment } from '@atlaskit/tmp-editor-statsig/editor-experiment';
+import { CellSelection } from '../cell-selection';
+import { TableMap } from '../table-map';
+import { cloneTr } from './clone-tr';
+import { findTableClosestToPos } from './find-table-closest-to-pos';
+import { getTableSelectionClosesToPos } from './get-table-selection-closes-to-pos';
+export var selectTableClosestToPos = function selectTableClosestToPos(tr, $pos) {
+  if (editorExperiment('platform_editor_block_menu', true, {
+    exposure: true
+  })) {
+    var tableSelection = getTableSelectionClosesToPos($pos);
+    if (tableSelection) {
+      return cloneTr(tr.setSelection(tableSelection));
+    }
+    return tr;
+  }
+  var table = findTableClosestToPos($pos);
+  if (table) {
+    var _TableMap$get = TableMap.get(table.node),
+      map = _TableMap$get.map;
+    if (map && map.length) {
+      var head = table.start + map[0];
+      var anchor = table.start + map[map.length - 1];
+      var $head = tr.doc.resolve(head);
+      var $anchor = tr.doc.resolve(anchor);
+      return cloneTr(tr.setSelection(new CellSelection($anchor, $head)));
+    }
+  }
+  return tr;
+};

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

@@ -0,0 +1,21 @@
+import { CellSelection } from '../cell-selection';
+import { TableMap } from '../table-map';
+import { cloneTr } from './clone-tr';
+import { findTable } from './find-table';
+
+// Returns a new transaction that selects a table.
+export var selectTable = function selectTable(tr) {
+  var table = findTable(tr.selection);
+  if (table) {
+    var _TableMap$get = TableMap.get(table.node),
+      map = _TableMap$get.map;
+    if (map && map.length) {
+      var head = table.start + map[0];
+      var anchor = table.start + map[map.length - 1];
+      var $head = tr.doc.resolve(head);
+      var $anchor = tr.doc.resolve(anchor);
+      return cloneTr(tr.setSelection(new CellSelection($anchor, $head)));
+    }
+  }
+  return tr;
+};

package/dist/esm/utils/selection-cell.js

@@ -1,4 +1,5 @@
-import { cellAround, cellNear } from './cells';
+import { cellAround } from './cell-around';
+import { cellNear } from './cell-near';
 import { isSelectionType } from './is-selection-type';
 export function selectionCell(selection) {
   if (isSelectionType(selection, 'cell')) {

package/dist/esm/utils/split-cell-with-type.js

@@ -3,18 +3,12 @@ function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbol
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 import { ResolvedPos } from '@atlaskit/editor-prosemirror/model';
 import { CellSelection } from '../cell-selection';
-import { cellAround } from './cells';
+import { cellAround } from './cell-around';
+import { cellWrapping } from './cell-wrapping';
 import { selectedRect } from './selection-rect';
-export function cellWrapping($pos) {
-  for (var d = $pos.depth; d > 0; d--) {
-    // Sometimes the cell can be in the same depth.
-    var role = $pos.node(d).type.spec.tableRole;
-    if (role === 'cell' || role === 'header_cell') {
-      return $pos.node(d);
-    }
-  }
-  return null;
-}
+
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Preserve the existing public entry-point API.
+export { cellWrapping } from './cell-wrapping';
 // Split a selected cell, whose rowpan or colspan is greater than one,
 // into smaller cells with the cell type (th, td) returned by getType function.
 export function splitCellWithType(getCellType) {

package/dist/esm/utils/tables.js

@@ -1,12 +1,12 @@
-export function isInTable(state) {
-  var $head = state.selection.$head;
-  for (var d = $head.depth; d > 0; d--) {
-    if ($head.node(d).type.spec.tableRole === 'row') {
-      return true;
-    }
-  }
-  return false;
-}
-export function inSameTable($a, $b) {
-  return $a.depth === $b.depth && $a.pos >= $b.start(-1) && $a.pos <= $b.end(-1);
-}
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
+
+/**
+ * @deprecated Use `import { isInTable } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { isInTable } from './is-in-table';
+/**
+ * @deprecated Use `import { inSameTable } from '@atlaskit/editor-tables/utils'` instead.
+ */
+// eslint-disable-next-line @atlaskit/editor/no-re-export -- Compatibility shim for deprecated API
+export { inSameTable } from './in-same-table';

package/dist/esm/utils/toggle-header.js

@@ -1,24 +1,8 @@
-import { Rect } from '../table-map';
+import { Rect } from '../rect';
+import { isHeaderEnabledByType } from './is-header-enabled-by-type';
+import { isInTable } from './is-in-table';
 import { selectedRect } from './selection-rect';
 import { tableNodeTypes } from './table-node-types';
-import { isInTable } from './tables';
-export function isHeaderEnabledByType(type, rect, types) {
-  // Get cell positions for first row or first column
-  var cellPositions = rect.map.cellsInRect({
-    left: 0,
-    top: 0,
-    right: type === 'row' ? rect.map.width : 1,
-    bottom: type === 'column' ? rect.map.height : 1
-  });
-  for (var i = 0; i < cellPositions.length; i++) {
-    var cell = rect.table.nodeAt(cellPositions[i]);
-    if (cell && cell.type !== types.header_cell) {
-      return false;
-    }
-  }
-  return true;
-}
-
 // Toggles between row/column header and normal cells (Only applies to first row/column).
 export function toggleHeader(type) {
   return function (state, dispatch) {

package/dist/esm/utils/transpose.js

@@ -0,0 +1,33 @@
+// This function transposes an array of array flipping the columns for rows,
+// transposition is a familiar algebra concept;
+// you can get more details here:
+// https://en.wikipedia.org/wiki/Transpose
+//
+// ```javascript
+//
+//  const arr = [
+//    ['a1', 'a2', 'a3'],
+//    ['b1', 'b2', 'b3'],
+//    ['c1', 'c2', 'c3'],
+//    ['d1', 'd2', 'd3'],
+//  ];
+//
+//  const result = transpose(arr);
+//
+//  result === [
+//    ['a1', 'b1', 'c1', 'd1'],
+//    ['a2', 'b2', 'c2', 'd2'],
+//    ['a3', 'b3', 'c3', 'd3'],
+//  ]
+// ```
+// Ignored via go/ees005
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export var transpose = function transpose(array) {
+  // Ignored via go/ees005
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return array[0].map(function (_, i) {
+    return array.map(function (column) {
+      return column[i];
+    });
+  });
+};