@atlaskit/editor-plugin-table 0.0.0 → 0.0.1

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

@@ -0,0 +1,115 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { Fragment, Slice } from 'prosemirror-model';
+import { flatten } from 'prosemirror-utils'; // import { flatmap, mapSlice } from '@atlaskit/editor-core/src/utils/slice';
+
+import { flatmap, mapSlice } from '@atlaskit/editor-common/utils';
+import { getPluginState } from '../pm-plugins/plugin-factory'; // lifts up the content of each cell, returning an array of nodes
+
+export var unwrapContentFromTable = function unwrapContentFromTable(maybeTable) {
+  var schema = maybeTable.type.schema;
+
+  if (maybeTable.type === schema.nodes.table) {
+    var content = [];
+    var _schema$nodes = schema.nodes,
+        tableCell = _schema$nodes.tableCell,
+        tableHeader = _schema$nodes.tableHeader;
+    maybeTable.descendants(function (maybeCell) {
+      if (maybeCell.type === tableCell || maybeCell.type === tableHeader) {
+        content.push.apply(content, _toConsumableArray(flatten(maybeCell, false).map(function (child) {
+          return child.node;
+        })));
+      }
+
+      return true;
+    });
+    return content;
+  }
+
+  return maybeTable;
+};
+export var removeTableFromFirstChild = function removeTableFromFirstChild(node, i) {
+  return i === 0 ? unwrapContentFromTable(node) : node;
+};
+export var removeTableFromLastChild = function removeTableFromLastChild(node, i, fragment) {
+  return i === fragment.childCount - 1 ? unwrapContentFromTable(node) : node;
+};
+/**
+ * When we copy from a table cell with a hardBreak at the end,
+ * the slice generated will come with a hardBreak outside of the table.
+ * This code will look for that pattern and fix it.
+ */
+
+export var transformSliceToFixHardBreakProblemOnCopyFromCell = function transformSliceToFixHardBreakProblemOnCopyFromCell(slice, schema) {
+  var _schema$nodes2 = schema.nodes,
+      paragraph = _schema$nodes2.paragraph,
+      table = _schema$nodes2.table,
+      hardBreak = _schema$nodes2.hardBreak;
+  var emptyParagraphNode = paragraph.createAndFill();
+  var hardBreakNode = hardBreak === null || hardBreak === void 0 ? void 0 : hardBreak.createAndFill();
+  var paragraphNodeSize = emptyParagraphNode ? emptyParagraphNode.nodeSize : 0;
+  var hardBreakNodeSize = hardBreakNode ? hardBreakNode.nodeSize : 0;
+  var paragraphWithHardBreakSize = paragraphNodeSize + hardBreakNodeSize;
+
+  if (slice.content.childCount === 2 && slice.content.firstChild && slice.content.lastChild && slice.content.firstChild.type === table && slice.content.lastChild.type === paragraph && slice.content.lastChild.nodeSize === paragraphWithHardBreakSize) {
+    var nodes = unwrapContentFromTable(slice.content.firstChild);
+
+    if (nodes instanceof Array) {
+      return new Slice(Fragment.from( // keep only the content and discard the hardBreak
+      nodes[0]), slice.openStart, slice.openEnd);
+    }
+  }
+
+  return slice;
+};
+export var transformSliceToRemoveOpenTable = function transformSliceToRemoveOpenTable(slice, schema) {
+  var _slice$content$firstC6;
+
+  // we're removing the table, tableRow and tableCell reducing the open depth by 3
+  var depthDecrement = 3; // Case 1: A slice entirely within a single CELL
+
+  if ( // starts and ends inside of a cell
+  slice.openStart >= 4 && slice.openEnd >= 4 && // slice is a table node
+  slice.content.childCount === 1 && slice.content.firstChild.type === schema.nodes.table) {
+    var _slice$content$firstC, _slice$content$firstC2, _slice$content$firstC3, _slice$content$firstC4, _slice$content$firstC5;
+
+    // prosemirror-view has a bug that it duplicates table entry when selecting multiple paragraphs in a table cell.
+    // https://github.com/ProseMirror/prosemirror/issues/1270
+    // The structure becomes
+    // table(genuine) > tableRow(genuine) > table(duplicated) > tableRow(duplicated) > tableCell/tableHeader(genuine) > contents(genuine)
+    // As we are removing wrapping table anyway, we keep duplicated table and tableRow for simplicity
+    var cleaned = slice;
+
+    if (((_slice$content$firstC = slice.content.firstChild) === null || _slice$content$firstC === void 0 ? void 0 : (_slice$content$firstC2 = _slice$content$firstC.content) === null || _slice$content$firstC2 === void 0 ? void 0 : (_slice$content$firstC3 = _slice$content$firstC2.firstChild) === null || _slice$content$firstC3 === void 0 ? void 0 : (_slice$content$firstC4 = _slice$content$firstC3.content) === null || _slice$content$firstC4 === void 0 ? void 0 : (_slice$content$firstC5 = _slice$content$firstC4.firstChild) === null || _slice$content$firstC5 === void 0 ? void 0 : _slice$content$firstC5.type) === schema.nodes.table) {
+      cleaned = new Slice(slice.content.firstChild.content.firstChild.content, slice.openStart - 2, slice.openEnd - 2);
+    }
+
+    return new Slice(flatmap(cleaned.content, unwrapContentFromTable), cleaned.openStart - depthDecrement, cleaned.openEnd - depthDecrement);
+  } // Case 2: A slice starting within a CELL and ending outside the table
+
+
+  if ( // starts inside of a cell but ends outside of the starting table
+  slice.openStart >= 4 && // slice starts from a table node (and spans across more than one node)
+  slice.content.childCount > 1 && ((_slice$content$firstC6 = slice.content.firstChild) === null || _slice$content$firstC6 === void 0 ? void 0 : _slice$content$firstC6.type) === schema.nodes.table) {
+    // repoint the slice's cutting depth so that cell content where the slice starts
+    // does not get lifted out of the cell on paste
+    return new Slice(slice.content, 1, slice.openEnd);
+  }
+
+  return slice;
+};
+export var transformSliceToCorrectEmptyTableCells = function transformSliceToCorrectEmptyTableCells(slice, schema) {
+  var _schema$nodes3 = schema.nodes,
+      tableCell = _schema$nodes3.tableCell,
+      tableHeader = _schema$nodes3.tableHeader;
+  return mapSlice(slice, function (node) {
+    if (node && (node.type === tableCell || node.type === tableHeader) && !node.content.childCount) {
+      return node.type.createAndFill(node.attrs) || node;
+    }
+
+    return node;
+  });
+};
+export function isHeaderRowRequired(state) {
+  var tableState = getPluginState(state);
+  return tableState && tableState.pluginConfig.isHeaderRowRequired;
+}

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

@@ -0,0 +1,20 @@
+export var isReferencedSource = function isReferencedSource(state, localId) {
+  var found = false;
+  state.doc.descendants(function (node) {
+    if (found) {
+      return false;
+    }
+
+    var dataConsumer = node.marks.find(function (mark) {
+      return mark.type === state.schema.marks.dataConsumer;
+    });
+
+    if (!dataConsumer) {
+      return true;
+    }
+
+    found = (dataConsumer.attrs.sources || []).includes(localId);
+    return !found;
+  });
+  return found;
+};

package/dist/esm/plugins/table/utils/row-controls.js

@@ -0,0 +1,221 @@
+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';
+import { CellSelection } from '@atlaskit/editor-tables/cell-selection';
+import { safeInsert } from 'prosemirror-utils';
+import { findTable, getSelectionRect, isRowSelected, isTableSelected } from '@atlaskit/editor-tables/utils'; // import { parsePx } from '@atlaskit/editor-core/src/utils/dom';
+
+import { parsePx } from '@atlaskit/editor-common/utils';
+import { TableCssClassName as ClassName } from '../types';
+import { tableDeleteButtonSize } from '../ui/consts';
+export var getRowHeights = function getRowHeights(tableRef) {
+  var heights = [];
+
+  if (tableRef.lastChild) {
+    var rows = tableRef.lastChild.childNodes;
+
+    for (var i = 0, count = rows.length; i < count; i++) {
+      var row = rows[i];
+      heights[i] = row.getBoundingClientRect().height + 1; // padding only gets applied when the container has sticky
+
+      if (row.classList.contains('sticky') && i === 0) {
+        var styles = window.getComputedStyle(row);
+        var paddingTop = parsePx(styles.paddingTop || '');
+        heights[i] -= paddingTop ? paddingTop + 1 : +1;
+      }
+    }
+  }
+
+  return heights;
+};
+export var isRowDeleteButtonVisible = function isRowDeleteButtonVisible(selection) {
+  if (!isTableSelected(selection) && selection instanceof CellSelection && selection.isRowSelection()) {
+    return true;
+  }
+
+  return false;
+};
+export var getRowDeleteButtonParams = function getRowDeleteButtonParams(rowsHeights, selection) {
+  var offsetTop = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var rect = getSelectionRect(selection);
+
+  if (!rect) {
+    return null;
+  }
+
+  var height = 0;
+  var offset = offsetTop; // find the rows before the selection
+
+  for (var i = 0; i < rect.top; i++) {
+    var rowHeight = rowsHeights[i];
+
+    if (rowHeight) {
+      offset += rowHeight - 1;
+    }
+  } // these are the selected rows widths
+
+
+  var indexes = [];
+
+  for (var _i = rect.top; _i < rect.bottom; _i++) {
+    var _rowHeight = rowsHeights[_i];
+
+    if (_rowHeight) {
+      height += _rowHeight - 1;
+      indexes.push(_i);
+    }
+  }
+
+  var top = offset + height / 2 - tableDeleteButtonSize / 2;
+  return {
+    top: top,
+    indexes: indexes
+  };
+};
+export var getRowsParams = function getRowsParams(rowsHeights) {
+  var rows = [];
+
+  for (var i = 0, count = rowsHeights.length; i < count; i++) {
+    var height = rowsHeights[i];
+
+    if (!height) {
+      continue;
+    }
+
+    var endIndex = rowsHeights.length;
+
+    for (var k = i + 1, _count = rowsHeights.length; k < _count; k++) {
+      if (rowsHeights[k]) {
+        endIndex = k;
+        break;
+      }
+    }
+
+    rows.push({
+      startIndex: i,
+      endIndex: endIndex,
+      height: height
+    });
+  }
+
+  return rows;
+};
+export var getRowClassNames = function getRowClassNames(index, selection) {
+  var hoveredRows = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  var isInDanger = arguments.length > 3 ? arguments[3] : undefined;
+  var isResizing = arguments.length > 4 ? arguments[4] : undefined;
+  var classNames = [];
+
+  if (isRowSelected(index)(selection) || hoveredRows.indexOf(index) > -1 && !isResizing) {
+    classNames.push(ClassName.HOVERED_CELL_ACTIVE);
+
+    if (isInDanger) {
+      classNames.push(ClassName.HOVERED_CELL_IN_DANGER);
+    }
+  }
+
+  return classNames.join(' ');
+};
+export var copyPreviousRow = function copyPreviousRow(schema) {
+  return function (insertNewRowIndex) {
+    return function (tr) {
+      var table = findTable(tr.selection);
+
+      if (!table) {
+        return tr;
+      }
+
+      var map = TableMap.get(table.node);
+      var copyPreviousRowIndex = insertNewRowIndex - 1;
+
+      if (insertNewRowIndex <= 0) {
+        throw Error("Row Index less or equal 0 isn't not allowed since there is not a previous to copy");
+      }
+
+      if (insertNewRowIndex > map.height) {
+        return tr;
+      }
+
+      var tableNode = table.node;
+      var tableRow = schema.nodes.tableRow;
+      var cellsInRow = map.cellsInRect({
+        left: 0,
+        right: map.width,
+        top: copyPreviousRowIndex,
+        bottom: copyPreviousRowIndex + 1
+      });
+      var offsetIndexPosition = copyPreviousRowIndex * map.width;
+      var offsetNextLineIndexPosition = insertNewRowIndex * map.width;
+      var cellsPositionsInOriginalRow = map.map.slice(offsetIndexPosition, offsetIndexPosition + map.width);
+      var cellsPositionsInNextRow = map.map.slice(offsetNextLineIndexPosition, offsetNextLineIndexPosition + map.width);
+      var cells = [];
+      var fixRowspans = [];
+
+      for (var i = 0; i < cellsPositionsInOriginalRow.length;) {
+        var pos = cellsPositionsInOriginalRow[i];
+        var documentCellPos = pos + table.start;
+        var node = tr.doc.nodeAt(documentCellPos);
+
+        if (!node) {
+          continue;
+        }
+
+        var attributes = _objectSpread(_objectSpread({}, node.attrs), {}, {
+          colspan: 1,
+          rowspan: 1
+        });
+
+        var newCell = node.type.createAndFill(attributes);
+
+        if (!newCell) {
+          return tr;
+        }
+
+        if (cellsPositionsInNextRow.indexOf(pos) > -1) {
+          fixRowspans.push({
+            pos: documentCellPos,
+            node: node
+          });
+        } else if (cellsInRow.indexOf(pos) > -1) {
+          if (node.attrs.colspan > 1) {
+            var newCellWithColspanFixed = node.type.createAndFill(_objectSpread(_objectSpread({}, attributes), {}, {
+              colspan: node.attrs.colspan
+            }));
+
+            if (!newCellWithColspanFixed) {
+              return tr;
+            }
+
+            cells.push(newCellWithColspanFixed);
+            i = i + node.attrs.colspan;
+            continue;
+          }
+
+          cells.push(newCell);
+        } else {
+          cells.push(newCell);
+        }
+
+        i++;
+      }
+
+      fixRowspans.forEach(function (cell) {
+        tr.setNodeMarkup(cell.pos, undefined, _objectSpread(_objectSpread({}, cell.node.attrs), {}, {
+          rowspan: cell.node.attrs.rowspan + 1
+        }));
+      });
+      var cloneRow = tableNode.child(copyPreviousRowIndex);
+      var rowPos = table.start;
+
+      for (var _i2 = 0; _i2 < insertNewRowIndex; _i2++) {
+        rowPos += tableNode.child(_i2).nodeSize;
+      }
+
+      return safeInsert(tableRow.createChecked(cloneRow.attrs, cells, cloneRow.marks), rowPos)(tr);
+    };
+  };
+};

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

@@ -0,0 +1,96 @@
+import { TableMap } from '@atlaskit/editor-tables/table-map';
+import { CellSelection } from '@atlaskit/editor-tables/cell-selection';
+import { findTable, getSelectionRangeInColumn, getSelectionRangeInRow, getSelectionRect, isSelectionType } from '@atlaskit/editor-tables/utils';
+export var isSelectionUpdated = function isSelectionUpdated(oldSelection, newSelection) {
+  return !!(!newSelection && oldSelection) || isSelectionType(oldSelection, 'cell') !== isSelectionType(newSelection, 'cell') || isSelectionType(oldSelection, 'cell') && isSelectionType(newSelection, 'cell') && oldSelection.ranges !== newSelection.ranges;
+};
+
+var isRectangularCellSelection = function isRectangularCellSelection(selection, rect) {
+  var table = findTable(selection);
+
+  if (!table) {
+    return true;
+  }
+
+  var _TableMap$get = TableMap.get(table.node),
+      width = _TableMap$get.width,
+      height = _TableMap$get.height,
+      map = _TableMap$get.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 false;
+    }
+
+    indexLeft += width;
+    indexRight += width;
+  }
+
+  for (var _i = rect.left; _i < rect.right; _i++) {
+    if (rect.top > 0 && map[indexTop] === map[indexTop - width] || rect.bottom < height && map[indexBottom] === map[indexBottom + width]) {
+      return false;
+    }
+
+    indexTop++;
+    indexBottom++;
+  }
+
+  return true;
+};
+
+export var normalizeSelection = function normalizeSelection(tr) {
+  var selection = tr.selection;
+  var rect = getSelectionRect(selection);
+
+  if (!rect || !(selection instanceof CellSelection) || isRectangularCellSelection(selection, rect)) {
+    return tr;
+  }
+
+  if (selection.isColSelection()) {
+    var _getSelectionRangeInC, _getSelectionRangeInC2;
+
+    var $anchor = (_getSelectionRangeInC = getSelectionRangeInColumn(rect.left)(tr)) === null || _getSelectionRangeInC === void 0 ? void 0 : _getSelectionRangeInC.$anchor;
+    var $head = (_getSelectionRangeInC2 = getSelectionRangeInColumn(rect.right - 1)(tr)) === null || _getSelectionRangeInC2 === void 0 ? void 0 : _getSelectionRangeInC2.$head;
+
+    if ($anchor && $head) {
+      return tr.setSelection(new CellSelection($anchor, $head));
+    }
+  }
+
+  if (selection.isRowSelection()) {
+    var _getSelectionRangeInR, _getSelectionRangeInR2;
+
+    var _$anchor = (_getSelectionRangeInR = getSelectionRangeInRow(rect.top)(tr)) === null || _getSelectionRangeInR === void 0 ? void 0 : _getSelectionRangeInR.$anchor;
+
+    var _$head = (_getSelectionRangeInR2 = getSelectionRangeInRow(rect.bottom - 1)(tr)) === null || _getSelectionRangeInR2 === void 0 ? void 0 : _getSelectionRangeInR2.$head;
+
+    if (_$anchor && _$head) {
+      return tr.setSelection(new CellSelection(_$anchor, _$head));
+    }
+  }
+
+  return tr;
+};
+export var getSelectedColumnIndexes = function getSelectedColumnIndexes(selectionRect) {
+  var columnIndexes = [];
+
+  for (var i = selectionRect.left; i < selectionRect.right; i++) {
+    columnIndexes.push(i);
+  }
+
+  return columnIndexes;
+};
+export var getSelectedRowIndexes = function getSelectedRowIndexes(selectionRect) {
+  var rowIndexes = [];
+
+  for (var i = selectionRect.top; i < selectionRect.bottom; i++) {
+    rowIndexes.push(i);
+  }
+
+  return rowIndexes;
+};

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

@@ -0,0 +1,30 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { TableMap } from '@atlaskit/editor-tables/table-map';
+import { findTable } from '@atlaskit/editor-tables/utils';
+export var getMergedCellsPositions = function getMergedCellsPositions(tr) {
+  var table = findTable(tr.selection);
+
+  if (!table) {
+    return [];
+  }
+
+  var map = TableMap.get(table.node);
+  var cellPositions = new Set();
+  var mergedCells = [];
+  map.map.forEach(function (value) {
+    if (cellPositions.has(value)) {
+      mergedCells.push(value);
+    } else {
+      cellPositions.add(value);
+    }
+  });
+  return mergedCells;
+};
+export var colsToRect = function colsToRect(cols, noOfRows) {
+  return {
+    left: Math.min.apply(Math, _toConsumableArray(cols)),
+    right: Math.max.apply(Math, _toConsumableArray(cols)) + 1,
+    top: 0,
+    bottom: noOfRows
+  };
+};

package/dist/esm/plugins/table/utils/update-plugin-state-decorations.js

@@ -0,0 +1,5 @@
+import { getDecorations } from '../pm-plugins/decorations/plugin';
+import { updateDecorations } from './decoration';
+export var updatePluginStateDecorations = function updatePluginStateDecorations(state, decorations, key) {
+  return updateDecorations(state.doc, getDecorations(state), decorations, key);
+};

package/dist/esm/plugins/table-plugin.js

@@ -1,43 +1,2 @@
-import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-import { pluginKey } from './plugin-key';
-import { Mark } from 'prosemirror-model';
-import { EditorView } from 'prosemirror-view';
-
-function createPlugin() {
-  return new SafePlugin({
-    key: pluginKey,
-    state: {
-      init: function init() {
-        var z = {
-          Mark: Mark,
-          EditorView: EditorView
-        }; // eslint-disable-next-line no-console
-
-        console.log('delete to use prosemirror-model/view', z); // eslint-disable-next-line no-console
-
-        console.log('next table plugin loaded');
-        return {
-          scaffold: true
-        };
-      },
-      apply: function apply() {}
-    }
-  });
-} // const tablesPlugin = (options?: TablePluginOptions): any => ({
-
-
-var tablesPlugin = function tablesPlugin() {
-  return {
-    name: 'nextTable',
-    pmPlugins: function pmPlugins() {
-      return [{
-        name: 'next-table-scaffold',
-        plugin: function plugin() {
-          return createPlugin();
-        }
-      }];
-    }
-  };
-};
-
+import { default as tablesPlugin } from './table';
 export default tablesPlugin;

package/dist/esm/version.json

@@ -1,4 +1,4 @@
 {
 	"name": "@atlaskit/editor-plugin-table",
-	"version": "0.0.0"
+	"version": "0.0.1"
 }

package/dist/types/plugins/table/commands/clear.d.ts

@@ -0,0 +1,3 @@
+import { Command } from '@atlaskit/editor-common/types';
+export declare const clearMultipleCells: (targetCellPosition?: number | undefined) => Command;
+export declare const clearSelection: Command;

package/dist/types/plugins/table/commands/collapse.d.ts

@@ -0,0 +1,2 @@
+import { Command } from '@atlaskit/editor-common/types';
+export declare const wrapTableInExpand: Command;

package/dist/types/plugins/table/commands/go-to-next-cell.d.ts

@@ -0,0 +1,4 @@
+import { Direction } from '@atlaskit/editor-tables/types';
+import { Command } from '@atlaskit/editor-common/types';
+import type { EditorAnalyticsAPI } from '@atlaskit/editor-common/analytics';
+export declare const goToNextCell: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined | null) => (direction: Direction) => Command;

package/dist/types/plugins/table/commands/hover.d.ts

@@ -0,0 +1,8 @@
+import { CellColumnPositioning } from '../types';
+export declare const hoverMergedCells: () => import("@atlaskit/editor-common/types").Command;
+export declare const hoverColumns: (hoveredColumns: number[], isInDanger?: boolean | undefined) => import("@atlaskit/editor-common/types").Command;
+export declare const hoverRows: (hoveredRows: number[], isInDanger?: boolean | undefined) => import("@atlaskit/editor-common/types").Command;
+export declare const hoverTable: (isInDanger?: boolean | undefined, isSelected?: boolean | undefined) => import("@atlaskit/editor-common/types").Command;
+export declare const clearHoverSelection: () => import("@atlaskit/editor-common/types").Command;
+export declare const showResizeHandleLine: (cellColumnPositioning: CellColumnPositioning) => import("@atlaskit/editor-common/types").Command;
+export declare const hideResizeHandleLine: () => import("@atlaskit/editor-common/types").Command;

package/dist/types/plugins/table/commands/index.d.ts

@@ -0,0 +1,7 @@
+export { hoverColumns, hoverRows, hoverTable, hoverMergedCells, clearHoverSelection, showResizeHandleLine, hideResizeHandleLine, } from './hover';
+export { insertColumn, insertRow, createTable } from './insert';
+export { getNextLayout, toggleContextualMenu, toggleHeaderColumn, toggleHeaderRow, toggleNumberColumn, toggleTableLayout, } from './toggle';
+export { clearMultipleCells } from './clear';
+export { autoSizeTable, convertFirstRowToHeader, deleteTable, hideInsertColumnOrRowButton, moveCursorBackward, selectColumn, selectRow, setCellAttr, setEditorFocus, setMultipleCellAttrs, setTableRef, showInsertColumnButton, showInsertRowButton, transformSliceToAddTableHeaders, triggerUnlessTableHeader, addBoldInEmptyHeaderCells, addResizeHandleDecorations, } from './misc';
+export { sortByColumn } from './sort';
+export { goToNextCell } from './go-to-next-cell';

package/dist/types/plugins/table/commands/insert.d.ts

@@ -0,0 +1,10 @@
+import { Transaction } from 'prosemirror-state';
+import { Command } from '@atlaskit/editor-common/types';
+import { EditorView } from 'prosemirror-view';
+import type { GetEditorContainerWidth } from '@atlaskit/editor-common/types';
+export declare function addColumnAt(getEditorContainerWidth: GetEditorContainerWidth): (column: number, allowAddColumnCustomStep: boolean | undefined, view: EditorView | undefined) => (tr: Transaction) => Transaction<any>;
+export declare const addColumnBefore: (getEditorContainerWidth: GetEditorContainerWidth) => Command;
+export declare const addColumnAfter: (getEditorContainerWidth: GetEditorContainerWidth) => Command;
+export declare const insertColumn: (getEditorContainerWidth: GetEditorContainerWidth) => (column: number) => Command;
+export declare const insertRow: (row: number, moveCursorToTheNewRow: boolean) => Command;
+export declare const createTable: () => Command;

package/dist/types/plugins/table/commands/misc.d.ts

@@ -0,0 +1,27 @@
+import { Node as PMNode, Schema, Slice } from 'prosemirror-model';
+import { Transaction } from 'prosemirror-state';
+import { ContentNodeWithPos } from 'prosemirror-utils';
+import { EditorView } from 'prosemirror-view';
+import { Command } from '@atlaskit/editor-common/types';
+export declare const setEditorFocus: (editorHasFocus: boolean) => Command;
+export declare const setTableRef: (ref?: HTMLTableElement | undefined) => Command;
+export declare const setCellAttr: (name: string, value: any) => Command;
+export declare const triggerUnlessTableHeader: (command: Command) => Command;
+export declare const transformSliceRemoveCellBackgroundColor: (slice: Slice, schema: Schema) => Slice;
+export declare const transformSliceToAddTableHeaders: (slice: Slice, schema: Schema) => Slice;
+export declare const transformSliceToRemoveColumnsWidths: (slice: Slice, schema: Schema) => Slice;
+export declare const deleteTable: Command;
+export declare const deleteTableIfSelected: Command;
+export declare const convertFirstRowToHeader: (schema: Schema) => (tr: Transaction) => Transaction;
+export declare const moveCursorBackward: Command;
+export declare const setMultipleCellAttrs: (attrs: Object, targetCellPosition?: number | undefined) => Command;
+export declare const selectColumn: (column: number, expand?: boolean | undefined) => Command;
+export declare const selectRow: (row: number, expand?: boolean | undefined) => Command;
+export declare const showInsertColumnButton: (columnIndex: number) => Command;
+export declare const showInsertRowButton: (rowIndex: number) => Command;
+export declare const hideInsertColumnOrRowButton: () => Command;
+export declare const addResizeHandleDecorations: (columnIndex: number) => Command;
+export declare const autoSizeTable: (view: EditorView, node: PMNode, table: HTMLTableElement, basePos: number, opts: {
+    containerWidth: number;
+}) => boolean;
+export declare const addBoldInEmptyHeaderCells: (tableCellHeader: ContentNodeWithPos) => Command;

package/dist/types/plugins/table/commands/selection.d.ts

@@ -0,0 +1,8 @@
+import type { Command } from '@atlaskit/editor-common/types';
+import { EditorSelectionAPI } from '@atlaskit/editor-common/selection';
+export declare enum TableSelectionDirection {
+    TopToBottom = "TopToBottom",
+    BottomToTop = "BottomToTop"
+}
+export declare const arrowLeftFromTable: (editorSelectionAPI: EditorSelectionAPI | undefined | null) => () => Command;
+export declare const arrowRightFromTable: (editorSelectionAPI: EditorSelectionAPI | undefined | null) => () => Command;

package/dist/types/plugins/table/commands/sort.d.ts

@@ -0,0 +1,3 @@
+import { Command } from '@atlaskit/editor-common/types';
+import { TableSortOrder as SortOrder } from '@atlaskit/adf-schema/steps';
+export declare const sortByColumn: (columnIndex: number, order?: SortOrder) => Command;

package/dist/types/plugins/table/commands/split-cell.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@atlaskit/editor-common/types';
+/**
+ * We need to split cell keeping the right type of cell given current table configuration.
+ * We are using editor-tables splitCellWithType that allows you to choose what cell type should be.
+ */
+export declare const splitCell: Command;

package/dist/types/plugins/table/commands/toggle.d.ts

@@ -0,0 +1,12 @@
+import { TableLayout } from '@atlaskit/adf-schema';
+import { Command } from '@atlaskit/editor-common/types';
+/**
+ * Table layout toggle logic
+ * default -> wide -> full-width -> default
+ */
+export declare const getNextLayout: (currentLayout: TableLayout) => TableLayout;
+export declare const toggleHeaderRow: Command;
+export declare const toggleHeaderColumn: Command;
+export declare const toggleNumberColumn: Command;
+export declare const toggleTableLayout: Command;
+export declare const toggleContextualMenu: () => Command;