@atlaskit/editor-plugin-table 0.0.0 → 0.0.1

package/dist/esm/plugins/table/utils/decoration.js

@@ -0,0 +1,366 @@
+import { TableMap } from '@atlaskit/editor-tables/table-map';
+import { findTable, getCellsInRow, getSelectionRect } from '@atlaskit/editor-tables/utils';
+import { Decoration } from 'prosemirror-view';
+// import { nonNullable } from '@atlaskit/editor-core/src/utils';
+import { nonNullable } from '@atlaskit/editor-common/utils';
+import { TableCssClassName as ClassName, TableDecorations } from '../types';
+
+var filterDecorationByKey = function filterDecorationByKey(key, decorationSet) {
+  return decorationSet.find(undefined, undefined, function (spec) {
+    return spec.key.indexOf(key) > -1;
+  });
+};
+
+export var findColumnControlSelectedDecoration = function findColumnControlSelectedDecoration(decorationSet) {
+  return filterDecorationByKey(TableDecorations.COLUMN_SELECTED, decorationSet);
+};
+export var findControlsHoverDecoration = function findControlsHoverDecoration(decorationSet) {
+  return filterDecorationByKey(TableDecorations.ALL_CONTROLS_HOVER, decorationSet);
+};
+export var createCellHoverDecoration = function createCellHoverDecoration(cells, type) {
+  return cells.map(function (cell) {
+    return Decoration.node(cell.pos, cell.pos + cell.node.nodeSize, {
+      class: ClassName.HOVERED_CELL_WARNING
+    }, {
+      key: TableDecorations.CELL_CONTROLS_HOVER
+    });
+  });
+};
+export var createControlsHoverDecoration = function createControlsHoverDecoration(cells, type, danger, selected) {
+  return cells.map(function (cell) {
+    var classes = [ClassName.HOVERED_CELL];
+
+    if (danger) {
+      classes.push(ClassName.HOVERED_CELL_IN_DANGER);
+    }
+
+    if (selected) {
+      classes.push(ClassName.SELECTED_CELL);
+    }
+
+    classes.push(type === 'column' ? ClassName.HOVERED_COLUMN : type === 'row' ? ClassName.HOVERED_ROW : ClassName.HOVERED_TABLE);
+    var key;
+
+    switch (type) {
+      case 'row':
+        key = TableDecorations.ROW_CONTROLS_HOVER;
+        break;
+
+      case 'column':
+        key = TableDecorations.COLUMN_CONTROLS_HOVER;
+        break;
+
+      default:
+        key = TableDecorations.TABLE_CONTROLS_HOVER;
+        break;
+    }
+
+    return Decoration.node(cell.pos, cell.pos + cell.node.nodeSize, {
+      class: classes.join(' ')
+    }, {
+      key: key
+    });
+  });
+};
+export var createColumnSelectedDecoration = function createColumnSelectedDecoration(tr) {
+  var selection = tr.selection,
+      doc = tr.doc;
+  var table = findTable(selection);
+  var rect = getSelectionRect(selection);
+
+  if (!table || !rect) {
+    return [];
+  }
+
+  var map = TableMap.get(table.node);
+  var cellPositions = map.cellsInRect(rect);
+  return cellPositions.map(function (pos, index) {
+    var cell = doc.nodeAt(pos + table.start);
+    return Decoration.node(pos + table.start, pos + table.start + cell.nodeSize, {
+      class: ClassName.COLUMN_SELECTED
+    }, {
+      key: "".concat(TableDecorations.COLUMN_SELECTED, "_").concat(index)
+    });
+  });
+};
+export var createColumnControlsDecoration = function createColumnControlsDecoration(selection) {
+  var cells = getCellsInRow(0)(selection) || [];
+  var index = 0;
+  return cells.map(function (cell) {
+    var colspan = cell.node.attrs.colspan || 1;
+    var element = document.createElement('div');
+    element.classList.add(ClassName.COLUMN_CONTROLS_DECORATIONS);
+    element.dataset.startIndex = "".concat(index);
+    index += colspan;
+    element.dataset.endIndex = "".concat(index);
+    return Decoration.widget(cell.pos + 1, function () {
+      return element;
+    }, {
+      key: "".concat(TableDecorations.COLUMN_CONTROLS_DECORATIONS, "_").concat(index),
+      // this decoration should be the first one, even before gap cursor.
+      side: -100
+    });
+  });
+};
+export var updateDecorations = function updateDecorations(node, decorationSet, decorations, key) {
+  var filteredDecorations = filterDecorationByKey(key, decorationSet);
+  var decorationSetFiltered = decorationSet.remove(filteredDecorations);
+  return decorationSetFiltered.add(node, decorations);
+};
+
+var makeArray = function makeArray(n) {
+  return Array.from(Array(n).keys());
+};
+/*
+ * This function will create two specific decorations for each cell in a column index target,
+ * for example given that table:
+ *
+ * ```
+ *    0       1      2      3
+ * _____________________ _______
+ * |      |             |      |
+ * |  B1  |     C1      |  A1  |
+ * |______|______ ______|______|
+ * |             |      |      |
+ * |     B2      |      |  A2  |
+ * |______ ______|      |______|
+ * |      |      |  D1  |      |
+ * |  B3  |  C2  |      |  A3  |
+ * |______|______|______|______|
+ *        ^      ^      ^      ^
+ *        |      |      |      |
+ *        |      |      |      |
+ *        |      |      |      |
+ *        0      1      3      4
+ *         \     |      |     /
+ *          \    |      |    /
+ *           \   |      |   /
+ *            \  |      |  /
+ *             \ |      | /
+ *         columnEndIndexTarget === CellColumnPositioning.right
+ * ```
+ *
+ * When a user wants to resize a cell,
+ * they need to grab and hold the end of that column,
+ * and this will be the `columnEndIndexTarget` using
+ * the CellColumnPositioning interface.
+ *
+ * Let's say the `columnEndIndexTarget.right` is 3,
+ * so this function will return two types of decorations for each cell on that column,
+ * that means 2 `resizerHandle` and 2 `lastCellElement`,
+ * here is the explanation for each one of them :
+ *
+ * - resizerHandle:
+ *
+ *   Given the cell C1, this decoration will add a div to create this area
+ * ```
+ *    ▁▁▁▁▁▁▁▁▁▁▁▁▁
+ *   |           ▒▒|
+ *   |     C1    ▒▒|
+ *   |           ▒▒|
+ *    ▔▔▔▔▔▔▔▔▔▔▔▔▔
+ * ```
+ *   This ▒ represents the area where table resizing will start,
+ *   and you can follow that using checking the class name `ClassName.RESIZE_HANDLE_DECORATION` on the code
+ *
+ * - lastCellElementDecoration
+ *
+ *   Given the content of the cell C1
+ *    ▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁
+ *   |                   |
+ *   |   _____________   |
+ *   |  |             |  |
+ *   |  |     <p>     |  |
+ *   |  |_____________|  |
+ *   |                   |
+ *   |   _____________   |
+ *   |  |             |  |
+ *   |  |   <media>   |  |
+ *   |  |_____________|  |
+ *   |                   |
+ *   |   _____________   |
+ *   |  |             |  |
+ *   |  |   <media>   |  |
+ *   |  |_____________|  |
+ *   |                   |
+ *    ▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔▔
+ *   Currently, we are removing the margin-bottom from the last media using this kind of CSS rule:
+ *   `div:last-of-type`; This is quite unstable, and after we create the `resizerHandle` div,
+ *   that logic will apply the margin in the wrong element, to avoid that,
+ *   we will add a new class on the last item for each cell,
+ *   hence the second media will receive this class `ClassName.LAST_ITEM_IN_CELL`
+ */
+
+
+export var createResizeHandleDecoration = function createResizeHandleDecoration(tr, columnEndIndexTarget) {
+  var emptyResult = [[], []];
+  var table = findTable(tr.selection);
+
+  if (!table || !table.node) {
+    return emptyResult;
+  }
+
+  var map = TableMap.get(table.node);
+
+  if (!map.width) {
+    return emptyResult;
+  }
+
+  var createResizerHandleDecoration = function createResizerHandleDecoration(cellColumnPositioning, columnIndex, rowIndex, cellPos, cellNode) {
+    var element = document.createElement('div');
+    element.classList.add(ClassName.RESIZE_HANDLE_DECORATION);
+    element.dataset.startIndex = "".concat(cellColumnPositioning.left);
+    element.dataset.endIndex = "".concat(cellColumnPositioning.right);
+    var position = cellPos + cellNode.nodeSize - 1;
+    return Decoration.widget(position, element, {
+      key: "".concat(TableDecorations.COLUMN_RESIZING_HANDLE, "_").concat(rowIndex, "_").concat(columnIndex)
+    });
+  };
+
+  var createLastCellElementDecoration = function createLastCellElementDecoration(cellColumnPositioning, cellPos, cellNode) {
+    var lastItemPositions;
+    cellNode.forEach(function (childNode, offset, index) {
+      if (index === cellNode.childCount - 1) {
+        var from = offset + cellPos + 1;
+        lastItemPositions = {
+          from: from,
+          to: from + childNode.nodeSize
+        };
+      }
+    });
+
+    if (!lastItemPositions) {
+      return null;
+    }
+
+    return Decoration.node(lastItemPositions.from, lastItemPositions.to, {
+      class: ClassName.LAST_ITEM_IN_CELL
+    }, {
+      key: "".concat(TableDecorations.LAST_CELL_ELEMENT, "_").concat(cellColumnPositioning.left, "_").concat(cellColumnPositioning.right)
+    });
+  };
+
+  var resizeHandleCellDecorations = [];
+  var lastCellElementsDecorations = [];
+
+  for (var rowIndex = 0; rowIndex < map.height; rowIndex++) {
+    var seen = {};
+
+    for (var columnIndex = 0; columnIndex < map.width; columnIndex++) {
+      var cellPosition = map.map[map.width * rowIndex + columnIndex];
+
+      if (seen[cellPosition]) {
+        continue;
+      }
+
+      seen[cellPosition] = true;
+      var cellPos = table.start + cellPosition;
+      var cell = tr.doc.nodeAt(cellPos);
+
+      if (!cell) {
+        continue;
+      }
+
+      var colspan = cell.attrs.colspan || 1;
+      var startIndex = columnIndex;
+      var endIndex = colspan + startIndex;
+
+      if (endIndex !== columnEndIndexTarget.right) {
+        continue;
+      }
+
+      var resizerHandleDec = createResizerHandleDecoration({
+        left: startIndex,
+        right: endIndex
+      }, columnIndex, rowIndex, cellPos, cell);
+      var lastCellDec = createLastCellElementDecoration({
+        left: startIndex,
+        right: endIndex
+      }, cellPos, cell);
+      resizeHandleCellDecorations.push(resizerHandleDec);
+      lastCellElementsDecorations.push(lastCellDec);
+    }
+  }
+
+  return [resizeHandleCellDecorations, lastCellElementsDecorations.filter(nonNullable)];
+};
+/*
+ * This function will create a decoration for each cell using the right position on the CellColumnPositioning
+ * for example given that table:
+ *
+ * ```
+ *    0       1      2      3   <--- column indexes
+ * _____________________ _______
+ * |      |             |      |
+ * |  B1  |     C1      |  A1  |
+ * |______|______ ______|______|
+ * |             |      |      |
+ * |     B2      |  D1  |  A2  |
+ * |______ ______|______|______|
+ * |      |      |             |
+ * |  B3  |  C2  |      D2     |
+ * |______|______|_____________|
+ * ```
+ *
+ * and given the left and right represents the C1 cell:
+ *
+ * ```
+ *      left          right
+ *        1             3
+ *        |             |
+ *        |             |
+ *        |             |
+ * _______∨_____________∨_______
+ * |      |             |      |
+ * |  B1  |     C1      |  A1  |
+ * |______|______ ______|______|
+ * |             |      |      |
+ * |     B2      |  D1  |  A2  |
+ * |______ ______|______|______|
+ * |      |      |             |
+ * |  B3  |  C2  |      D2     |
+ * |______|______|_____________|
+ * ```
+ *
+ * Taking that table, and the right as parameters,
+ * this function will return two decorations applying a new class `ClassName.WITH_RESIZE_LINE`
+ * only on the cells: `C1` and `D1`.
+ */
+
+export var createColumnLineResize = function createColumnLineResize(selection, cellColumnPositioning) {
+  var table = findTable(selection);
+
+  if (!table || cellColumnPositioning.right === null) {
+    return [];
+  }
+
+  var columnIndex = cellColumnPositioning.right - 1;
+  var map = TableMap.get(table.node);
+  var cellPositions = makeArray(map.height).map(function (rowIndex) {
+    return map.map[map.width * rowIndex + columnIndex];
+  }).filter(function (cellPosition, rowIndex) {
+    if (columnIndex === map.width) {
+      return true; // If is the last column no filter applied
+    }
+
+    var nextPosition = map.map[map.width * rowIndex + columnIndex + 1];
+    return cellPosition !== nextPosition; // Removed it if next position is merged
+  });
+  var cells = cellPositions.map(function (pos) {
+    return {
+      pos: pos + table.start,
+      node: table.node.nodeAt(pos)
+    };
+  });
+  return cells.map(function (cell, index) {
+    if (!cell || !cell.node) {
+      return;
+    }
+
+    return Decoration.node(cell.pos, cell.pos + cell.node.nodeSize, {
+      class: ClassName.WITH_RESIZE_LINE
+    }, {
+      key: "".concat(TableDecorations.COLUMN_RESIZING_HANDLE_LINE, "_").concat(cellColumnPositioning.right, "_").concat(index)
+    });
+  }).filter(nonNullable);
+};

package/dist/esm/plugins/table/utils/dom.js

@@ -0,0 +1,175 @@
+// import { containsClassName } from '@atlaskit/editor-core/src/utils';
+// import { closestElement } from '@atlaskit/editor-core/src/utils/dom';
+import { closestElement, containsClassName } from '@atlaskit/editor-common/utils';
+import { TableCssClassName as ClassName } from '../types';
+import { tableToolbarSize } from '../ui/consts';
+var SELECTOR_TABLE_LEAFS = ".".concat(ClassName.TABLE_CELL, ", .").concat(ClassName.TABLE_HEADER_CELL);
+export var isCell = function isCell(node) {
+  return Boolean(node && (['TH', 'TD'].indexOf(node.tagName) > -1 || !!closestElement(node, ".".concat(ClassName.TABLE_HEADER_CELL)) || !!closestElement(node, ".".concat(ClassName.TABLE_CELL))));
+};
+export var isCornerButton = function isCornerButton(node) {
+  return containsClassName(node, ClassName.CONTROLS_CORNER_BUTTON);
+};
+export var isInsertRowButton = function isInsertRowButton(node) {
+  return containsClassName(node, ClassName.CONTROLS_INSERT_ROW) || closestElement(node, ".".concat(ClassName.CONTROLS_INSERT_ROW)) || containsClassName(node, ClassName.CONTROLS_BUTTON_OVERLAY) && closestElement(node, ".".concat(ClassName.ROW_CONTROLS));
+};
+export var getColumnOrRowIndex = function getColumnOrRowIndex(target) {
+  return [parseInt(target.getAttribute('data-start-index') || '-1', 10), parseInt(target.getAttribute('data-end-index') || '-1', 10)];
+};
+export var isColumnControlsDecorations = function isColumnControlsDecorations(node) {
+  return containsClassName(node, ClassName.COLUMN_CONTROLS_DECORATIONS);
+};
+export var isRowControlsButton = function isRowControlsButton(node) {
+  return containsClassName(node, ClassName.ROW_CONTROLS_BUTTON) || containsClassName(node, ClassName.NUMBERED_COLUMN_BUTTON);
+};
+export var isResizeHandleDecoration = function isResizeHandleDecoration(node) {
+  return containsClassName(node, ClassName.RESIZE_HANDLE_DECORATION);
+};
+export var isTableControlsButton = function isTableControlsButton(node) {
+  return containsClassName(node, ClassName.CONTROLS_BUTTON) || containsClassName(node, ClassName.ROW_CONTROLS_BUTTON_WRAP);
+};
+export var isTableContainerOrWrapper = function isTableContainerOrWrapper(node) {
+  return containsClassName(node, ClassName.TABLE_CONTAINER) || containsClassName(node, ClassName.TABLE_NODE_WRAPPER);
+};
+/*
+ * This function returns which side of a given element the mouse cursor is,
+ * using as a base the half of the width by default, for example:
+ *
+ * legend
+ * ⌖ = mouse pointer
+ * ▒ = gap
+ *
+ * given this box:
+ * ┏━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┓
+ * ┃                    ┊                     ┃
+ * ┃       left         ┊        right        ┃
+ * ┃                    ┊                     ┃
+ * ┗━━━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━━┛
+ *
+ * if the mouse is on the left, it will return `left`,
+ * if it is on the right it will return `right`.
+ *
+ * You can extend this behavior using the parameter `gapInPixels`
+ * to determinate if the mouse is inside of a gap for each side,
+ * for example:
+ *
+ * given `gapInPixels` is `5`
+ * and given this box:
+ * ┏━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┓
+ * ┃▒▒▒▒▒               ┊                ▒▒▒▒▒┃
+ * ┃▒▒▒▒▒   left        ┊        right   ▒▒▒▒▒┃
+ * ┃▒▒▒▒▒               ┊                ▒▒▒▒▒┃
+ * ┗━━━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━━┛
+ *
+ * if the mouse cursor is inside of the gap like that:
+ *
+ * ┏━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┓
+ * ┃▒▒▒▒▒               ┊                ▒▒▒▒▒┃
+ * ┃▒▒⌖▒▒   left        ┊        right   ▒▒▒▒▒┃
+ * ┃▒▒▒▒▒               ┊                ▒▒▒▒▒┃
+ * ┗━━━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━━┛
+ *
+ * the function will return `left` because the mouse is inside of the gap on the left side.
+ *
+ * if the mouse cursor is outside of the gap like that:
+ *
+ * ┏━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━┓
+ * ┃▒▒▒▒▒               ┊                ▒▒▒▒▒┃
+ * ┃▒▒▒▒▒   left  ⌖     ┊        right   ▒▒▒▒▒┃
+ * ┃▒▒▒▒▒               ┊                ▒▒▒▒▒┃
+ * ┗━━━━━━━━━━━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━━┛
+ *
+ * the function will return `null` because the mouse is inside of left
+ * but is outside of the gap.
+ *
+ * the same is valid to the right side.
+ */
+
+export var getMousePositionHorizontalRelativeByElement = function getMousePositionHorizontalRelativeByElement(mouseEvent, mouseMoveOptimization, elementContentRects, gapInPixels) {
+  var element = mouseEvent.target;
+
+  if (element instanceof HTMLElement) {
+    var width, x;
+    var closestCell = element.closest(SELECTOR_TABLE_LEAFS);
+
+    if (mouseMoveOptimization) {
+      var _closestCell$id, _elementContentRects$, _elementContentRects$2;
+
+      var id = (_closestCell$id = closestCell === null || closestCell === void 0 ? void 0 : closestCell.id) !== null && _closestCell$id !== void 0 ? _closestCell$id : '';
+      width = (_elementContentRects$ = elementContentRects === null || elementContentRects === void 0 ? void 0 : (_elementContentRects$2 = elementContentRects[id]) === null || _elementContentRects$2 === void 0 ? void 0 : _elementContentRects$2.width) !== null && _elementContentRects$ !== void 0 ? _elementContentRects$ : 0;
+      x = mouseEvent.offsetX;
+    } else {
+      var elementRect = element.getBoundingClientRect();
+      width = elementRect.width;
+      var left = elementRect.left;
+      x = mouseEvent.clientX - left;
+    }
+
+    if (width <= 0) {
+      return null;
+    }
+
+    if (!gapInPixels) {
+      return x / width > 0.5 ? 'right' : 'left';
+    } else {
+      if (x <= gapInPixels) {
+        return 'left';
+      } else if (x >= width - gapInPixels) {
+        return 'right';
+      }
+    }
+  }
+
+  return null;
+};
+export var getMousePositionVerticalRelativeByElement = function getMousePositionVerticalRelativeByElement(mouseEvent) {
+  var element = mouseEvent.target;
+
+  if (element instanceof HTMLElement) {
+    var elementRect = element.getBoundingClientRect();
+
+    if (elementRect.height <= 0) {
+      return null;
+    }
+
+    var y = mouseEvent.clientY - elementRect.top;
+    return y / elementRect.height > 0.5 ? 'bottom' : 'top';
+  }
+
+  return null;
+};
+export var updateResizeHandles = function updateResizeHandles(tableRef) {
+  if (!tableRef) {
+    return;
+  }
+
+  var height = tableRef.offsetHeight + tableToolbarSize; // see ED-7600
+
+  var nodes = Array.from(tableRef.querySelectorAll(".".concat(ClassName.RESIZE_HANDLE)));
+
+  if (!nodes || !nodes.length) {
+    return;
+  }
+
+  nodes.forEach(function (node) {
+    node.style.height = "".concat(height, "px");
+  });
+};
+export var hasResizeHandler = function hasResizeHandler(_ref) {
+  var columnEndIndexTarget = _ref.columnEndIndexTarget,
+      target = _ref.target;
+  var tableElement = closestElement(target, 'table');
+
+  if (!tableElement) {
+    return false;
+  }
+
+  var query = [".".concat(ClassName.RESIZE_HANDLE_DECORATION), "[data-end-index=\"".concat(columnEndIndexTarget, "\"]")];
+  var decorationElement = tableElement.querySelectorAll(query.join(''));
+
+  if (!decorationElement || decorationElement.length === 0) {
+    return false;
+  }
+
+  return true;
+};

package/dist/esm/plugins/table/utils/get-allow-add-column-custom-step.js

@@ -0,0 +1,5 @@
+import { getPluginState } from '../pm-plugins/plugin-factory';
+export function getAllowAddColumnCustomStep(state) {
+  var tablePluginState = getPluginState(state);
+  return Boolean(tablePluginState) && Boolean(tablePluginState.pluginConfig.allowAddColumnWithCustomStep);
+}

package/dist/esm/plugins/table/utils/index.js

@@ -0,0 +1,10 @@
+export { getSelectedColumnIndexes, getSelectedRowIndexes, normalizeSelection, isSelectionUpdated } from './selection';
+export { findControlsHoverDecoration, createControlsHoverDecoration, createColumnControlsDecoration, createColumnSelectedDecoration, createCellHoverDecoration, updateDecorations, createResizeHandleDecoration, createColumnLineResize } from './decoration';
+export { isIsolating, containsHeaderColumn, containsHeaderRow, checkIfHeaderColumnEnabled, checkIfHeaderRowEnabled, checkIfNumberColumnEnabled, isLayoutSupported, getTableWidth, tablesHaveDifferentColumnWidths, tablesHaveDifferentNoOfColumns } from './nodes';
+export { unwrapContentFromTable, removeTableFromFirstChild, removeTableFromLastChild, transformSliceToRemoveOpenTable, transformSliceToCorrectEmptyTableCells, transformSliceToFixHardBreakProblemOnCopyFromCell } from './paste';
+export { isCell, isCornerButton, isInsertRowButton, isColumnControlsDecorations, isTableControlsButton, isTableContainerOrWrapper, isRowControlsButton, getColumnOrRowIndex, getMousePositionHorizontalRelativeByElement, getMousePositionVerticalRelativeByElement, updateResizeHandles, isResizeHandleDecoration, hasResizeHandler } from './dom';
+export { getColumnsWidths, isColumnDeleteButtonVisible, getColumnDeleteButtonParams, getColumnClassNames } from './column-controls';
+export { getRowHeights, isRowDeleteButtonVisible, getRowDeleteButtonParams, getRowsParams, getRowClassNames, copyPreviousRow } from './row-controls';
+export { getSelectedTableInfo, getSelectedCellInfo } from './analytics';
+export { getMergedCellsPositions } from './table';
+export { updatePluginStateDecorations } from './update-plugin-state-decorations';

package/dist/esm/plugins/table/utils/nodes.js

@@ -0,0 +1,112 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { TableMap } from '@atlaskit/editor-tables/table-map';
+import { hasParentNodeOfType } from 'prosemirror-utils';
+import { findTable } from '@atlaskit/editor-tables/utils';
+import { pluginKey } from '../pm-plugins/plugin-key';
+export var isIsolating = function isIsolating(node) {
+  return !!node.type.spec.isolating;
+};
+export var containsHeaderColumn = function containsHeaderColumn(table) {
+  var map = TableMap.get(table); // Get cell positions for first column.
+
+  var cellPositions = map.cellsInRect({
+    left: 0,
+    top: 0,
+    right: 1,
+    bottom: map.height
+  });
+
+  for (var i = 0; i < cellPositions.length; i++) {
+    try {
+      var cell = table.nodeAt(cellPositions[i]);
+
+      if (cell && cell.type !== table.type.schema.nodes.tableHeader) {
+        return false;
+      }
+    } catch (e) {
+      return false;
+    }
+  }
+
+  return true;
+};
+export var containsHeaderRow = function containsHeaderRow(table) {
+  var map = TableMap.get(table);
+
+  for (var i = 0; i < map.width; i++) {
+    var cell = table.nodeAt(map.map[i]);
+
+    if (cell && cell.type !== table.type.schema.nodes.tableHeader) {
+      return false;
+    }
+  }
+
+  return true;
+};
+export var checkIfHeaderColumnEnabled = function checkIfHeaderColumnEnabled(selection) {
+  return filterNearSelection(selection, findTable, containsHeaderColumn, false);
+};
+export var checkIfHeaderRowEnabled = function checkIfHeaderRowEnabled(selection) {
+  return filterNearSelection(selection, findTable, containsHeaderRow, false);
+};
+export var checkIfNumberColumnEnabled = function checkIfNumberColumnEnabled(selection) {
+  return filterNearSelection(selection, findTable, function (table) {
+    return !!table.attrs.isNumberColumnEnabled;
+  }, false);
+};
+export var isLayoutSupported = function isLayoutSupported(state) {
+  var permittedLayouts = pluginKey.getState(state).pluginConfig.permittedLayouts;
+  var _state$schema$nodes = state.schema.nodes,
+      bodiedExtension = _state$schema$nodes.bodiedExtension,
+      layoutSection = _state$schema$nodes.layoutSection,
+      expand = _state$schema$nodes.expand;
+  return !hasParentNodeOfType([expand, layoutSection, bodiedExtension])(state.selection) && permittedLayouts && (permittedLayouts === 'all' || permittedLayouts.indexOf('default') > -1 && permittedLayouts.indexOf('wide') > -1 && permittedLayouts.indexOf('full-page') > -1);
+};
+export var getTableWidth = function getTableWidth(node) {
+  return getTableWidths(node).reduce(function (acc, current) {
+    return acc + current;
+  }, 0);
+};
+export var tablesHaveDifferentColumnWidths = function tablesHaveDifferentColumnWidths(currentTable, previousTable) {
+  var currentTableWidths = getTableWidths(currentTable);
+  var previousTableWidths = getTableWidths(previousTable);
+
+  if (currentTableWidths.length !== previousTableWidths.length) {
+    return true;
+  }
+
+  var sameWidths = currentTableWidths.every(function (value, index) {
+    return value === previousTableWidths[index];
+  });
+  return sameWidths === false;
+};
+export var tablesHaveDifferentNoOfColumns = function tablesHaveDifferentNoOfColumns(currentTable, previousTable) {
+  var prevMap = TableMap.get(previousTable);
+  var currentMap = TableMap.get(currentTable);
+  return prevMap.width !== currentMap.width;
+};
+
+function filterNearSelection(selection, findNode, predicate, defaultValue) {
+  var found = findNode(selection);
+
+  if (!found) {
+    return defaultValue;
+  }
+
+  return predicate(found.node, found.pos);
+}
+
+function getTableWidths(node) {
+  if (!node.content.firstChild) {
+    return [];
+  }
+
+  var tableWidths = [];
+  node.content.firstChild.content.forEach(function (cell) {
+    if (Array.isArray(cell.attrs.colwidth)) {
+      var colspan = cell.attrs.colspan || 1;
+      tableWidths.push.apply(tableWidths, _toConsumableArray(cell.attrs.colwidth.slice(0, colspan)));
+    }
+  });
+  return tableWidths;
+}