@atlaskit/editor-plugin-table 0.0.0 → 0.0.1

package/dist/es2019/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/es2019/plugins/table/utils/nodes.js

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

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

@@ -0,0 +1,117 @@
+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 const unwrapContentFromTable = maybeTable => {
+  const {
+    schema
+  } = maybeTable.type;
+
+  if (maybeTable.type === schema.nodes.table) {
+    const content = [];
+    const {
+      tableCell,
+      tableHeader
+    } = schema.nodes;
+    maybeTable.descendants(maybeCell => {
+      if (maybeCell.type === tableCell || maybeCell.type === tableHeader) {
+        content.push(...flatten(maybeCell, false).map(child => child.node));
+      }
+
+      return true;
+    });
+    return content;
+  }
+
+  return maybeTable;
+};
+export const removeTableFromFirstChild = (node, i) => {
+  return i === 0 ? unwrapContentFromTable(node) : node;
+};
+export const 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 const transformSliceToFixHardBreakProblemOnCopyFromCell = (slice, schema) => {
+  const {
+    paragraph,
+    table,
+    hardBreak
+  } = schema.nodes;
+  const emptyParagraphNode = paragraph.createAndFill();
+  const hardBreakNode = hardBreak === null || hardBreak === void 0 ? void 0 : hardBreak.createAndFill();
+  const paragraphNodeSize = emptyParagraphNode ? emptyParagraphNode.nodeSize : 0;
+  const hardBreakNodeSize = hardBreakNode ? hardBreakNode.nodeSize : 0;
+  const 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) {
+    const 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 const transformSliceToRemoveOpenTable = (slice, schema) => {
+  var _slice$content$firstC6;
+
+  // we're removing the table, tableRow and tableCell reducing the open depth by 3
+  const 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
+    let 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 const transformSliceToCorrectEmptyTableCells = (slice, schema) => {
+  const {
+    tableCell,
+    tableHeader
+  } = schema.nodes;
+  return mapSlice(slice, 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) {
+  const tableState = getPluginState(state);
+  return tableState && tableState.pluginConfig.isHeaderRowRequired;
+}

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

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

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

@@ -0,0 +1,210 @@
+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 const getRowHeights = tableRef => {
+  const heights = [];
+
+  if (tableRef.lastChild) {
+    const rows = tableRef.lastChild.childNodes;
+
+    for (let i = 0, count = rows.length; i < count; i++) {
+      const 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) {
+        const styles = window.getComputedStyle(row);
+        const paddingTop = parsePx(styles.paddingTop || '');
+        heights[i] -= paddingTop ? paddingTop + 1 : +1;
+      }
+    }
+  }
+
+  return heights;
+};
+export const isRowDeleteButtonVisible = selection => {
+  if (!isTableSelected(selection) && selection instanceof CellSelection && selection.isRowSelection()) {
+    return true;
+  }
+
+  return false;
+};
+export const getRowDeleteButtonParams = (rowsHeights, selection, offsetTop = 0) => {
+  const rect = getSelectionRect(selection);
+
+  if (!rect) {
+    return null;
+  }
+
+  let height = 0;
+  let offset = offsetTop; // find the rows before the selection
+
+  for (let i = 0; i < rect.top; i++) {
+    const rowHeight = rowsHeights[i];
+
+    if (rowHeight) {
+      offset += rowHeight - 1;
+    }
+  } // these are the selected rows widths
+
+
+  const indexes = [];
+
+  for (let i = rect.top; i < rect.bottom; i++) {
+    const rowHeight = rowsHeights[i];
+
+    if (rowHeight) {
+      height += rowHeight - 1;
+      indexes.push(i);
+    }
+  }
+
+  const top = offset + height / 2 - tableDeleteButtonSize / 2;
+  return {
+    top,
+    indexes
+  };
+};
+export const getRowsParams = rowsHeights => {
+  const rows = [];
+
+  for (let i = 0, count = rowsHeights.length; i < count; i++) {
+    const height = rowsHeights[i];
+
+    if (!height) {
+      continue;
+    }
+
+    let endIndex = rowsHeights.length;
+
+    for (let k = i + 1, count = rowsHeights.length; k < count; k++) {
+      if (rowsHeights[k]) {
+        endIndex = k;
+        break;
+      }
+    }
+
+    rows.push({
+      startIndex: i,
+      endIndex,
+      height
+    });
+  }
+
+  return rows;
+};
+export const getRowClassNames = (index, selection, hoveredRows = [], isInDanger, isResizing) => {
+  const 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 const copyPreviousRow = schema => insertNewRowIndex => tr => {
+  const table = findTable(tr.selection);
+
+  if (!table) {
+    return tr;
+  }
+
+  const map = TableMap.get(table.node);
+  const 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;
+  }
+
+  const tableNode = table.node;
+  const {
+    nodes: {
+      tableRow
+    }
+  } = schema;
+  const cellsInRow = map.cellsInRect({
+    left: 0,
+    right: map.width,
+    top: copyPreviousRowIndex,
+    bottom: copyPreviousRowIndex + 1
+  });
+  const offsetIndexPosition = copyPreviousRowIndex * map.width;
+  const offsetNextLineIndexPosition = insertNewRowIndex * map.width;
+  const cellsPositionsInOriginalRow = map.map.slice(offsetIndexPosition, offsetIndexPosition + map.width);
+  const cellsPositionsInNextRow = map.map.slice(offsetNextLineIndexPosition, offsetNextLineIndexPosition + map.width);
+  let cells = [];
+  let fixRowspans = [];
+
+  for (let i = 0; i < cellsPositionsInOriginalRow.length;) {
+    const pos = cellsPositionsInOriginalRow[i];
+    const documentCellPos = pos + table.start;
+    const node = tr.doc.nodeAt(documentCellPos);
+
+    if (!node) {
+      continue;
+    }
+
+    const attributes = { ...node.attrs,
+      colspan: 1,
+      rowspan: 1
+    };
+    const newCell = node.type.createAndFill(attributes);
+
+    if (!newCell) {
+      return tr;
+    }
+
+    if (cellsPositionsInNextRow.indexOf(pos) > -1) {
+      fixRowspans.push({
+        pos: documentCellPos,
+        node
+      });
+    } else if (cellsInRow.indexOf(pos) > -1) {
+      if (node.attrs.colspan > 1) {
+        const newCellWithColspanFixed = node.type.createAndFill({ ...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(cell => {
+    tr.setNodeMarkup(cell.pos, undefined, { ...cell.node.attrs,
+      rowspan: cell.node.attrs.rowspan + 1
+    });
+  });
+  const cloneRow = tableNode.child(copyPreviousRowIndex);
+  let rowPos = table.start;
+
+  for (let i = 0; i < insertNewRowIndex; i++) {
+    rowPos += tableNode.child(i).nodeSize;
+  }
+
+  return safeInsert(tableRow.createChecked(cloneRow.attrs, cells, cloneRow.marks), rowPos)(tr);
+};

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

@@ -0,0 +1,95 @@
+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 const isSelectionUpdated = (oldSelection, newSelection) => !!(!newSelection && oldSelection) || isSelectionType(oldSelection, 'cell') !== isSelectionType(newSelection, 'cell') || isSelectionType(oldSelection, 'cell') && isSelectionType(newSelection, 'cell') && oldSelection.ranges !== newSelection.ranges;
+
+const isRectangularCellSelection = (selection, rect) => {
+  const table = findTable(selection);
+
+  if (!table) {
+    return true;
+  }
+
+  const {
+    width,
+    height,
+    map
+  } = TableMap.get(table.node);
+  let indexTop = rect.top * width + rect.left;
+  let indexLeft = indexTop;
+  let indexBottom = (rect.bottom - 1) * width + rect.left;
+  let indexRight = indexTop + (rect.right - rect.left - 1);
+
+  for (let 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 (let 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 const normalizeSelection = tr => {
+  const {
+    selection
+  } = tr;
+  const rect = getSelectionRect(selection);
+
+  if (!rect || !(selection instanceof CellSelection) || isRectangularCellSelection(selection, rect)) {
+    return tr;
+  }
+
+  if (selection.isColSelection()) {
+    var _getSelectionRangeInC, _getSelectionRangeInC2;
+
+    const $anchor = (_getSelectionRangeInC = getSelectionRangeInColumn(rect.left)(tr)) === null || _getSelectionRangeInC === void 0 ? void 0 : _getSelectionRangeInC.$anchor;
+    const $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;
+
+    const $anchor = (_getSelectionRangeInR = getSelectionRangeInRow(rect.top)(tr)) === null || _getSelectionRangeInR === void 0 ? void 0 : _getSelectionRangeInR.$anchor;
+    const $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 const getSelectedColumnIndexes = selectionRect => {
+  const columnIndexes = [];
+
+  for (let i = selectionRect.left; i < selectionRect.right; i++) {
+    columnIndexes.push(i);
+  }
+
+  return columnIndexes;
+};
+export const getSelectedRowIndexes = selectionRect => {
+  const rowIndexes = [];
+
+  for (let i = selectionRect.top; i < selectionRect.bottom; i++) {
+    rowIndexes.push(i);
+  }
+
+  return rowIndexes;
+};

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

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

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

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

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

@@ -1,45 +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() {
-        const z = {
-          Mark,
-          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() {}
-
-    }
-  });
-} // const tablesPlugin = (options?: TablePluginOptions): any => ({
-
-
-const tablesPlugin = () => ({
-  name: 'nextTable',
-
-  pmPlugins() {
-    return [{
-      name: 'next-table-scaffold',
-      plugin: () => {
-        return createPlugin();
-      }
-    }];
-  }
-
-});
-
+import { default as tablesPlugin } from './table';
 export default tablesPlugin;

package/dist/es2019/version.json

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

package/dist/esm/plugins/table/commands/clear.js

@@ -0,0 +1,48 @@
+// #region Imports
+import { Selection } from 'prosemirror-state';
+import { findCellClosestToPos, emptyCell, isSelectionType } from '@atlaskit/editor-tables/utils';
+// #endregion
+// #region Commands
+export var clearMultipleCells = function clearMultipleCells(targetCellPosition) {
+  return function (state, dispatch) {
+    var cursorPos;
+    var tr = state.tr;
+
+    if (isSelectionType(tr.selection, 'cell')) {
+      var selection = tr.selection;
+      selection.forEachCell(function (_node, pos) {
+        var $pos = tr.doc.resolve(tr.mapping.map(pos + 1));
+        tr = emptyCell(findCellClosestToPos($pos), state.schema)(tr);
+      });
+      cursorPos = selection.$headCell.pos;
+    } else if (targetCellPosition) {
+      var cell = findCellClosestToPos(tr.doc.resolve(targetCellPosition + 1));
+      tr = emptyCell(cell, state.schema)(tr);
+      cursorPos = cell.pos;
+    }
+
+    if (tr.docChanged && cursorPos) {
+      var $pos = tr.doc.resolve(tr.mapping.map(cursorPos));
+      var textSelection = Selection.findFrom($pos, 1, true);
+
+      if (textSelection) {
+        tr.setSelection(textSelection);
+      }
+
+      if (dispatch) {
+        dispatch(tr);
+      }
+
+      return true;
+    }
+
+    return false;
+  };
+};
+export var clearSelection = function clearSelection(state, dispatch) {
+  if (dispatch) {
+    dispatch(state.tr.setSelection(Selection.near(state.selection.$from)).setMeta('addToHistory', false));
+  }
+
+  return true;
+}; // #endregion