@atlaskit/editor-plugin-table 0.0.0 → 0.0.1

package/dist/esm/plugins/table/transforms/merge.js

@@ -0,0 +1,324 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import { Fragment } from 'prosemirror-model';
+import { Selection } from 'prosemirror-state';
+import { TableMap } from '@atlaskit/editor-tables/table-map';
+import { CellSelection } from '@atlaskit/editor-tables/cell-selection';
+import { findTable, getSelectionRect } from '@atlaskit/editor-tables/utils';
+import { setMeta } from './metadata'; // re-creates table node with merged cells
+
+export function mergeCells(tr) {
+  var selection = tr.selection;
+
+  if (!(selection instanceof CellSelection) || !canMergeCells(tr)) {
+    return tr;
+  }
+
+  var rect = getSelectionRect(selection);
+  var table = findTable(selection);
+  var map = TableMap.get(table.node);
+  var seen = [];
+  var selectedCells = map.cellsInRect(rect);
+  var mergedCellPos;
+  var rows = [];
+
+  for (var rowIndex = 0; rowIndex < map.height; rowIndex++) {
+    var rowCells = [];
+    var row = table.node.child(rowIndex);
+
+    for (var colIndex = 0; colIndex < map.width; colIndex++) {
+      var cellPos = map.map[rowIndex * map.width + colIndex];
+      var cell = table.node.nodeAt(cellPos);
+
+      if (!cell || seen.indexOf(cellPos) > -1) {
+        continue;
+      }
+
+      seen.push(cellPos); // merged cell
+
+      if (colIndex === rect.left && rowIndex === rect.top) {
+        mergedCellPos = cellPos; // merge content of the selected cells, dropping empty cells
+
+        var content = isEmptyCell(cell) ? Fragment.empty : cell.content;
+        var seenContent = [mergedCellPos];
+
+        for (var i = rect.top; i < rect.bottom; i++) {
+          for (var j = rect.left; j < rect.right; j++) {
+            var pos = map.map[i * map.width + j];
+
+            if (seenContent.indexOf(pos) === -1) {
+              seenContent.push(pos);
+              var copyCell = table.node.nodeAt(pos);
+
+              if (copyCell && !isEmptyCell(copyCell)) {
+                content = content.append(copyCell.content);
+              }
+            }
+          }
+        }
+
+        var rowspan = rect.bottom - rect.top;
+
+        if (rowspan < 1) {
+          return setMeta({
+            type: 'MERGE_CELLS',
+            problem: 'NEGATIVE_ROWSPAN'
+          })(tr);
+        } // update colspan and rowspan of the merged cell to span the selection
+
+
+        var attrs = addColSpan(_objectSpread(_objectSpread({}, cell.attrs), {}, {
+          rowspan: rowspan
+        }), cell.attrs.colspan, rect.right - rect.left - cell.attrs.colspan);
+        var newCell = content === Fragment.empty ? cell.type.createAndFill(attrs, content, cell.marks) : cell.type.createChecked(attrs, content, cell.marks);
+        rowCells.push(newCell);
+      } else if (selectedCells.indexOf(cellPos) === -1) {
+        // if its one of the selected cells, but not the merged cell, we get rid of it
+        // otherwise we keep the cell
+        rowCells.push(cell);
+      }
+    }
+
+    if (rowCells.length) {
+      rows.push(row.type.createChecked(row.attrs, rowCells, row.marks));
+    } else {
+      // empty row, we need to fix rowspans for rows above the current one
+      for (var _i = rows.length - 1; _i >= 0; _i--) {
+        var prevRow = rows[_i];
+        var cells = [];
+        var rowChanged = false;
+
+        for (var _j = 0; _j < prevRow.childCount; _j++) {
+          var _cell = prevRow.child(_j);
+
+          var _rowspan = _cell.attrs.rowspan;
+
+          if (_rowspan && _rowspan + _i - 1 >= rows.length) {
+            rowChanged = true;
+
+            if (_rowspan < 2) {
+              return setMeta({
+                type: 'MERGE_CELLS',
+                problem: 'NEGATIVE_ROWSPAN'
+              })(tr);
+            }
+
+            cells.push(_cell.type.createChecked(_objectSpread(_objectSpread({}, _cell.attrs), {}, {
+              rowspan: _rowspan - 1
+            }), _cell.content, _cell.marks));
+          } else {
+            cells.push(_cell);
+          }
+        }
+
+        if (rowChanged) {
+          rows[_i] = row.type.createChecked(prevRow.attrs, cells, prevRow.marks);
+        }
+      }
+    }
+  } // empty tables? cancel merging like nothing happened
+
+
+  if (!rows.length) {
+    return setMeta({
+      type: 'MERGE_CELLS',
+      problem: 'EMPTY_TABLE'
+    })(tr);
+  }
+
+  var newTable = table.node.type.createChecked(table.node.attrs, rows, table.node.marks);
+  var fixedTable = removeEmptyColumns(newTable);
+
+  if (fixedTable === null) {
+    return setMeta({
+      type: 'MERGE_CELLS',
+      problem: 'REMOVE_EMPTY_COLUMNS'
+    })(tr);
+  }
+
+  return setMeta({
+    type: 'MERGE_CELLS'
+  })(tr.replaceWith(table.pos, table.pos + table.node.nodeSize, fixedTable).setSelection(Selection.near(tr.doc.resolve((mergedCellPos || 0) + table.start))));
+}
+export function canMergeCells(tr) {
+  var selection = tr.selection;
+
+  if (!(selection instanceof CellSelection) || selection.$anchorCell.pos === selection.$headCell.pos) {
+    return false;
+  }
+
+  var rect = getSelectionRect(selection);
+
+  if (!rect) {
+    return false;
+  }
+
+  var table = selection.$anchorCell.node(-1);
+  var map = TableMap.get(table);
+
+  if (cellsOverlapRectangle(map, rect)) {
+    return false;
+  }
+
+  return true;
+}
+
+function isEmptyCell(cell) {
+  var content = cell.content;
+  return content.childCount === 1 && content.firstChild && content.firstChild.isTextblock && content.firstChild.childCount === 0;
+}
+
+function addColSpan(attrs, pos) {
+  var span = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+
+  var newAttrs = _objectSpread(_objectSpread({}, attrs), {}, {
+    colspan: (attrs.colspan || 1) + span
+  });
+
+  if (newAttrs.colwidth) {
+    newAttrs.colwidth = newAttrs.colwidth.slice();
+
+    for (var i = 0; i < span; i++) {
+      newAttrs.colwidth.splice(pos, 0, 0);
+    }
+  }
+
+  return newAttrs;
+}
+
+function cellsOverlapRectangle(_ref, rect) {
+  var width = _ref.width,
+      height = _ref.height,
+      map = _ref.map;
+  var indexTop = rect.top * width + rect.left;
+  var indexLeft = indexTop;
+  var indexBottom = (rect.bottom - 1) * width + rect.left;
+  var indexRight = indexTop + (rect.right - rect.left - 1);
+
+  for (var i = rect.top; i < rect.bottom; i++) {
+    if (rect.left > 0 && map[indexLeft] === map[indexLeft - 1] || rect.right < width && map[indexRight] === map[indexRight + 1]) {
+      return true;
+    }
+
+    indexLeft += width;
+    indexRight += width;
+  }
+
+  for (var _i2 = rect.left; _i2 < rect.right; _i2++) {
+    if (rect.top > 0 && map[indexTop] === map[indexTop - width] || rect.bottom < height && map[indexBottom] === map[indexBottom + width]) {
+      return true;
+    }
+
+    indexTop++;
+    indexBottom++;
+  }
+
+  return false;
+} // returns an array of numbers, each number indicates the minimum colSpan in each column
+
+
+function getMinColSpans(table) {
+  var map = TableMap.get(table);
+  var minColspans = [];
+
+  for (var colIndex = map.width - 1; colIndex >= 0; colIndex--) {
+    var cellsPositions = map.cellsInRect({
+      left: colIndex,
+      right: colIndex + 1,
+      top: 0,
+      bottom: map.height
+    });
+
+    if (cellsPositions.length) {
+      var colspans = cellsPositions.map(function (cellPos) {
+        var cell = table.nodeAt(cellPos);
+
+        if (cell) {
+          return cell.attrs.colspan;
+        }
+      });
+      var minColspan = Math.min.apply(Math, _toConsumableArray(colspans)); // only care about the case when the next column is invisible
+
+      if (!minColspans[colIndex + 1]) {
+        minColspans[colIndex] = minColspan;
+      } else {
+        minColspans[colIndex] = 1;
+      }
+    }
+  }
+
+  return minColspans;
+}
+
+export function removeEmptyColumns(table) {
+  var map = TableMap.get(table);
+  var minColSpans = getMinColSpans(table);
+
+  if (!minColSpans.some(function (colspan) {
+    return colspan > 1;
+  })) {
+    return table;
+  }
+
+  var rows = [];
+
+  var _loop = function _loop(rowIndex) {
+    var cellsByCols = {};
+    var cols = Object.keys(minColSpans).map(Number);
+
+    for (var idx in cols) {
+      var colIndex = cols[idx];
+      var cellPos = map.map[colIndex + rowIndex * map.width];
+      var rect = map.findCell(cellPos);
+      var cell = cellsByCols[rect.left] || table.nodeAt(cellPos);
+
+      if (cell && rect.top === rowIndex) {
+        if (minColSpans[colIndex] > 1) {
+          var colspan = cell.attrs.colspan - minColSpans[colIndex] + 1;
+
+          if (colspan < 1) {
+            return {
+              v: null
+            };
+          }
+
+          var colwidth = cell.attrs.colwidth;
+          var newCell = cell.type.createChecked(_objectSpread(_objectSpread({}, cell.attrs), {}, {
+            colspan: colspan,
+            colwidth: colwidth ? colwidth.slice(0, colspan) : null
+          }), cell.content, cell.marks);
+          cellsByCols[rect.left] = newCell;
+        } else {
+          cellsByCols[rect.left] = cell;
+        }
+      }
+    }
+
+    var rowCells = Object.keys(cellsByCols).map(function (col) {
+      return cellsByCols[col];
+    });
+    var row = table.child(rowIndex);
+
+    if (row) {
+      rows.push(row.type.createChecked(row.attrs, rowCells, row.marks));
+    }
+  };
+
+  for (var rowIndex = 0; rowIndex < map.height; rowIndex++) {
+    var _ret = _loop(rowIndex);
+
+    if (_typeof(_ret) === "object") return _ret.v;
+  }
+
+  if (!rows.length) {
+    return null;
+  }
+
+  return table.type.createChecked(table.attrs, rows, table.marks);
+}

package/dist/esm/plugins/table/transforms/metadata.js

@@ -0,0 +1,13 @@
+import { pluginKey } from '../pm-plugins/plugin-key';
+import { fireAnalytics } from './fix-tables'; // Set metadata on a ProseMirror transaction for debugging purposes in Synchrony
+
+export var setMeta = function setMeta(meta) {
+  return function (tr) {
+    if ('problem' in meta) {
+      // Send analytics event whenever we encounter with a problem
+      fireAnalytics(meta);
+    }
+
+    return tr.setMeta(pluginKey, meta);
+  };
+};

package/dist/esm/plugins/table/transforms/replace-table.js

@@ -0,0 +1,34 @@
+import { TextSelection } from 'prosemirror-state';
+import { Slice, Fragment } from 'prosemirror-model';
+import { findTable, isTableSelected } from '@atlaskit/editor-tables/utils';
+import { TABLE_ACTION, ACTION_SUBJECT, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
+import { getSelectedTableInfo } from '../utils';
+export var replaceSelectedTable = function replaceSelectedTable(state, content, inputMethod, editorAnalyticsAPI) {
+  if (isTableSelected(state.selection)) {
+    var table = findTable(state.selection);
+
+    if (table) {
+      var slice = typeof content === 'string' ? new Slice(Fragment.from(state.schema.text(content)), 0, 0) : content;
+      var tr = state.tr.replace(table.pos, table.pos + table.node.nodeSize, slice);
+      tr.setSelection(TextSelection.create(tr.doc, table.pos + slice.size + 1));
+
+      var _getSelectedTableInfo = getSelectedTableInfo(state.selection),
+          totalRowCount = _getSelectedTableInfo.totalRowCount,
+          totalColumnCount = _getSelectedTableInfo.totalColumnCount;
+
+      editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 ? void 0 : editorAnalyticsAPI.attachAnalyticsEvent({
+        action: TABLE_ACTION.REPLACED,
+        actionSubject: ACTION_SUBJECT.TABLE,
+        attributes: {
+          totalColumnCount: totalColumnCount,
+          totalRowCount: totalRowCount,
+          inputMethod: inputMethod
+        },
+        eventType: EVENT_TYPE.TRACK
+      })(tr);
+      return tr;
+    }
+  }
+
+  return state.tr;
+};

package/dist/esm/plugins/table/transforms/split.js

@@ -0,0 +1,82 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import { TableMap } from '@atlaskit/editor-tables/table-map';
+
+/**
+ * Helper to split all the cells in a range of columns
+ * @param tr
+ * @param tablePos
+ * @param columnStart - Start of the rect included (rect.left)
+ * @param columnEnd - End of the rect not included (rect.right)
+ */
+export function splitCellsInColumns(tr, tablePos, columnStart, columnEnd) {
+  var mapStart = tr.mapping.maps.length;
+  var table = tr.doc.nodeAt(tablePos);
+
+  if (!table) {
+    return tr;
+  }
+
+  var tableStart = tr.doc.resolve(tablePos).start(1);
+  var map = TableMap.get(table);
+
+  for (var column = columnStart; column < columnEnd; column++) {
+    for (var rowIndex = 0; rowIndex < map.height; rowIndex++) {
+      var cellIndex = rowIndex * map.width + column;
+      var cellPos = map.map[cellIndex]; // Check if the cell is contained by another by another row/column
+
+      var hasMergedCellsBefore = column > 0 && map.map[cellIndex - 1] === cellPos || rowIndex > 0 && map.map[(rowIndex - 1) * map.width + column] === cellPos; // Check if the cell contains another row/column
+
+      var hasMergedCellsAfter = column < map.width - 1 && map.map[cellIndex + 1] === cellPos || rowIndex < map.height - 1 && map.map[(rowIndex + 1) * map.width + column] === cellPos;
+
+      if (!hasMergedCellsBefore && hasMergedCellsAfter) {
+        // Is a merged cell that start in this row/column
+        var cellNode = table.nodeAt(cellPos);
+
+        if (!cellNode) {
+          continue;
+        }
+
+        var _ref = cellNode.attrs,
+            colwidth = _ref.colwidth,
+            _ref$colspan = _ref.colspan,
+            colspan = _ref$colspan === void 0 ? 1 : _ref$colspan,
+            _ref$rowspan = _ref.rowspan,
+            rowspan = _ref$rowspan === void 0 ? 1 : _ref$rowspan;
+        var mapping = tr.mapping.slice(mapStart); // Update current node with the simple colspan
+
+        var baseAttrs = _objectSpread(_objectSpread({}, cellNode.attrs), {}, {
+          colspan: 1,
+          rowspan: 1
+        }); // Add the new cells
+
+
+        for (var cellRowIndex = rowIndex; cellRowIndex < rowIndex + rowspan; cellRowIndex++) {
+          for (var i = 0; i < colspan; i++) {
+            var _mapping = tr.mapping.slice(mapStart);
+
+            var _cellPos = map.positionAt(cellRowIndex, column + i, table);
+
+            tr.insert(_mapping.map(_cellPos + tableStart), cellNode.type.createAndFill(_objectSpread(_objectSpread({}, baseAttrs), {}, {
+              colwidth: colwidth ? [colwidth[i]] : undefined
+            })));
+          }
+        } // Delete the original cell
+
+
+        mapping = tr.mapping.slice(mapStart);
+        tr.delete(mapping.map(cellPos + tableStart), mapping.map(cellPos + tableStart + cellNode.nodeSize)); // Skip rows based on rowspan
+
+        if (rowspan && rowspan > 1) {
+          rowIndex += rowspan - 1;
+        }
+      }
+    }
+  }
+
+  return tr;
+}

package/dist/esm/plugins/table/types.js

@@ -0,0 +1,90 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import { tableCellSelector, tableHeaderSelector, tablePrefixSelector } from '@atlaskit/adf-schema';
+import { TableSharedCssClassName } from '@atlaskit/editor-common/styles';
+export var RESIZE_HANDLE_AREA_DECORATION_GAP = 30;
+export var TableDecorations;
+
+(function (TableDecorations) {
+  TableDecorations["ALL_CONTROLS_HOVER"] = "CONTROLS_HOVER";
+  TableDecorations["ROW_CONTROLS_HOVER"] = "ROW_CONTROLS_HOVER";
+  TableDecorations["COLUMN_CONTROLS_HOVER"] = "COLUMN_CONTROLS_HOVER";
+  TableDecorations["TABLE_CONTROLS_HOVER"] = "TABLE_CONTROLS_HOVER";
+  TableDecorations["CELL_CONTROLS_HOVER"] = "CELL_CONTROLS_HOVER";
+  TableDecorations["COLUMN_CONTROLS_DECORATIONS"] = "COLUMN_CONTROLS_DECORATIONS";
+  TableDecorations["COLUMN_SELECTED"] = "COLUMN_SELECTED";
+  TableDecorations["COLUMN_RESIZING_HANDLE"] = "COLUMN_RESIZING_HANDLE";
+  TableDecorations["COLUMN_RESIZING_HANDLE_LINE"] = "COLUMN_RESIZING_HANDLE_LINE";
+  TableDecorations["LAST_CELL_ELEMENT"] = "LAST_CELL_ELEMENT";
+})(TableDecorations || (TableDecorations = {}));
+
+export var TableCssClassName = _objectSpread(_objectSpread({}, TableSharedCssClassName), {}, {
+  COLUMN_CONTROLS: "".concat(tablePrefixSelector, "-column-controls"),
+  COLUMN_CONTROLS_DECORATIONS: "".concat(tablePrefixSelector, "-column-controls-decoration"),
+  COLUMN_SELECTED: "".concat(tablePrefixSelector, "-column__selected"),
+  ROW_CONTROLS_WRAPPER: "".concat(tablePrefixSelector, "-row-controls-wrapper"),
+  ROW_CONTROLS: "".concat(tablePrefixSelector, "-row-controls"),
+  ROW_CONTROLS_INNER: "".concat(tablePrefixSelector, "-row-controls__inner"),
+  ROW_CONTROLS_BUTTON_WRAP: "".concat(tablePrefixSelector, "-row-controls__button-wrap"),
+  ROW_CONTROLS_BUTTON: "".concat(tablePrefixSelector, "-row-controls__button"),
+  CONTROLS_BUTTON: "".concat(tablePrefixSelector, "-controls__button"),
+  CONTROLS_BUTTON_ICON: "".concat(tablePrefixSelector, "-controls__button-icon"),
+  CONTROLS_INSERT_BUTTON: "".concat(tablePrefixSelector, "-controls__insert-button"),
+  CONTROLS_INSERT_BUTTON_INNER: "".concat(tablePrefixSelector, "-controls__insert-button-inner"),
+  CONTROLS_INSERT_BUTTON_WRAP: "".concat(tablePrefixSelector, "-controls__insert-button-wrap"),
+  CONTROLS_INSERT_LINE: "".concat(tablePrefixSelector, "-controls__insert-line"),
+  CONTROLS_BUTTON_OVERLAY: "".concat(tablePrefixSelector, "-controls__button-overlay"),
+  LAYOUT_BUTTON: "".concat(tablePrefixSelector, "-layout-button"),
+  CONTROLS_INSERT_MARKER: "".concat(tablePrefixSelector, "-controls__insert-marker"),
+  CONTROLS_INSERT_COLUMN: "".concat(tablePrefixSelector, "-controls__insert-column"),
+  CONTROLS_INSERT_ROW: "".concat(tablePrefixSelector, "-controls__insert-row"),
+  CONTROLS_DELETE_BUTTON_WRAP: "".concat(tablePrefixSelector, "-controls__delete-button-wrap"),
+  CONTROLS_DELETE_BUTTON: "".concat(tablePrefixSelector, "-controls__delete-button"),
+  CONTROLS_FLOATING_BUTTON_COLUMN: "".concat(tablePrefixSelector, "-controls-floating__button-column"),
+  CONTROLS_FLOATING_BUTTON_ROW: "".concat(tablePrefixSelector, "-controls-floating__button-row"),
+  CORNER_CONTROLS: "".concat(tablePrefixSelector, "-corner-controls"),
+  CORNER_CONTROLS_INSERT_ROW_MARKER: "".concat(tablePrefixSelector, "-corner-controls__insert-row-marker"),
+  CORNER_CONTROLS_INSERT_COLUMN_MARKER: "".concat(tablePrefixSelector, "-corner-controls__insert-column-marker"),
+  CONTROLS_CORNER_BUTTON: "".concat(tablePrefixSelector, "-corner-button"),
+  NUMBERED_COLUMN: "".concat(tablePrefixSelector, "-numbered-column"),
+  NUMBERED_COLUMN_BUTTON: "".concat(tablePrefixSelector, "-numbered-column__button"),
+  HOVERED_COLUMN: "".concat(tablePrefixSelector, "-hovered-column"),
+  HOVERED_ROW: "".concat(tablePrefixSelector, "-hovered-row"),
+  HOVERED_TABLE: "".concat(tablePrefixSelector, "-hovered-table"),
+  HOVERED_CELL: "".concat(tablePrefixSelector, "-hovered-cell"),
+  HOVERED_CELL_IN_DANGER: 'danger',
+  HOVERED_CELL_ACTIVE: 'active',
+  HOVERED_CELL_WARNING: "".concat(tablePrefixSelector, "-hovered-cell__warning"),
+  HOVERED_DELETE_BUTTON: "".concat(tablePrefixSelector, "-hovered-delete-button"),
+  WITH_CONTROLS: "".concat(tablePrefixSelector, "-with-controls"),
+  RESIZING_PLUGIN: "".concat(tablePrefixSelector, "-resizing-plugin"),
+  RESIZE_CURSOR: "".concat(tablePrefixSelector, "-resize-cursor"),
+  IS_RESIZING: "".concat(tablePrefixSelector, "-is-resizing"),
+  RESIZE_HANDLE: "".concat(tablePrefixSelector, "-resize-handle"),
+  RESIZE_HANDLE_DECORATION: "".concat(tablePrefixSelector, "-resize-decoration"),
+  CONTEXTUAL_SUBMENU: "".concat(tablePrefixSelector, "-contextual-submenu"),
+  CONTEXTUAL_MENU_BUTTON_WRAP: "".concat(tablePrefixSelector, "-contextual-menu-button-wrap"),
+  CONTEXTUAL_MENU_BUTTON: "".concat(tablePrefixSelector, "-contextual-menu-button"),
+  CONTEXTUAL_MENU_ICON: "".concat(tablePrefixSelector, "-contextual-submenu-icon"),
+  // come from prosemirror-table
+  SELECTED_CELL: 'selectedCell',
+  // defined in ReactNodeView based on PM node name
+  NODEVIEW_WRAPPER: 'tableView-content-wrap',
+  TABLE_SELECTED: "".concat(tablePrefixSelector, "-table__selected"),
+  TABLE_CELL: tableCellSelector,
+  TABLE_HEADER_CELL: tableHeaderSelector,
+  TABLE_STICKY: "".concat(tablePrefixSelector, "-sticky"),
+  TOP_LEFT_CELL: 'table > tbody > tr:nth-child(2) > td:nth-child(1)',
+  LAST_ITEM_IN_CELL: "".concat(tablePrefixSelector, "-last-item-in-cell"),
+  WITH_RESIZE_LINE: "".concat(tablePrefixSelector, "-column-resize-line")
+});
+export var ShadowEvent;
+
+(function (ShadowEvent) {
+  ShadowEvent["SHOW_BEFORE_SHADOW"] = "showBeforeShadow";
+  ShadowEvent["SHOW_AFTER_SHADOW"] = "showAfterShadow";
+})(ShadowEvent || (ShadowEvent = {}));