@atlaskit/editor-plugin-table 0.0.0 → 0.0.2

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

@@ -0,0 +1,159 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.tablesHaveDifferentNoOfColumns = exports.tablesHaveDifferentColumnWidths = exports.isLayoutSupported = exports.isIsolating = exports.getTableWidth = exports.containsHeaderRow = exports.containsHeaderColumn = exports.checkIfNumberColumnEnabled = exports.checkIfHeaderRowEnabled = exports.checkIfHeaderColumnEnabled = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _tableMap = require("@atlaskit/editor-tables/table-map");
+
+var _prosemirrorUtils = require("prosemirror-utils");
+
+var _utils = require("@atlaskit/editor-tables/utils");
+
+var _pluginKey = require("../pm-plugins/plugin-key");
+
+var isIsolating = function isIsolating(node) {
+  return !!node.type.spec.isolating;
+};
+
+exports.isIsolating = isIsolating;
+
+var containsHeaderColumn = function containsHeaderColumn(table) {
+  var map = _tableMap.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;
+};
+
+exports.containsHeaderColumn = containsHeaderColumn;
+
+var containsHeaderRow = function containsHeaderRow(table) {
+  var map = _tableMap.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;
+};
+
+exports.containsHeaderRow = containsHeaderRow;
+
+var checkIfHeaderColumnEnabled = function checkIfHeaderColumnEnabled(selection) {
+  return filterNearSelection(selection, _utils.findTable, containsHeaderColumn, false);
+};
+
+exports.checkIfHeaderColumnEnabled = checkIfHeaderColumnEnabled;
+
+var checkIfHeaderRowEnabled = function checkIfHeaderRowEnabled(selection) {
+  return filterNearSelection(selection, _utils.findTable, containsHeaderRow, false);
+};
+
+exports.checkIfHeaderRowEnabled = checkIfHeaderRowEnabled;
+
+var checkIfNumberColumnEnabled = function checkIfNumberColumnEnabled(selection) {
+  return filterNearSelection(selection, _utils.findTable, function (table) {
+    return !!table.attrs.isNumberColumnEnabled;
+  }, false);
+};
+
+exports.checkIfNumberColumnEnabled = checkIfNumberColumnEnabled;
+
+var isLayoutSupported = function isLayoutSupported(state) {
+  var permittedLayouts = _pluginKey.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 !(0, _prosemirrorUtils.hasParentNodeOfType)([expand, layoutSection, bodiedExtension])(state.selection) && permittedLayouts && (permittedLayouts === 'all' || permittedLayouts.indexOf('default') > -1 && permittedLayouts.indexOf('wide') > -1 && permittedLayouts.indexOf('full-page') > -1);
+};
+
+exports.isLayoutSupported = isLayoutSupported;
+
+var getTableWidth = function getTableWidth(node) {
+  return getTableWidths(node).reduce(function (acc, current) {
+    return acc + current;
+  }, 0);
+};
+
+exports.getTableWidth = getTableWidth;
+
+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;
+};
+
+exports.tablesHaveDifferentColumnWidths = tablesHaveDifferentColumnWidths;
+
+var tablesHaveDifferentNoOfColumns = function tablesHaveDifferentNoOfColumns(currentTable, previousTable) {
+  var prevMap = _tableMap.TableMap.get(previousTable);
+
+  var currentMap = _tableMap.TableMap.get(currentTable);
+
+  return prevMap.width !== currentMap.width;
+};
+
+exports.tablesHaveDifferentNoOfColumns = tablesHaveDifferentNoOfColumns;
+
+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, (0, _toConsumableArray2.default)(cell.attrs.colwidth.slice(0, colspan)));
+    }
+  });
+  return tableWidths;
+}

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

@@ -0,0 +1,148 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isHeaderRowRequired = isHeaderRowRequired;
+exports.unwrapContentFromTable = exports.transformSliceToRemoveOpenTable = exports.transformSliceToFixHardBreakProblemOnCopyFromCell = exports.transformSliceToCorrectEmptyTableCells = exports.removeTableFromLastChild = exports.removeTableFromFirstChild = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _prosemirrorModel = require("prosemirror-model");
+
+var _prosemirrorUtils = require("prosemirror-utils");
+
+var _utils = require("@atlaskit/editor-common/utils");
+
+var _pluginFactory = require("../pm-plugins/plugin-factory");
+
+// import { flatmap, mapSlice } from '@atlaskit/editor-core/src/utils/slice';
+// lifts up the content of each cell, returning an array of nodes
+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, (0, _toConsumableArray2.default)((0, _prosemirrorUtils.flatten)(maybeCell, false).map(function (child) {
+          return child.node;
+        })));
+      }
+
+      return true;
+    });
+    return content;
+  }
+
+  return maybeTable;
+};
+
+exports.unwrapContentFromTable = unwrapContentFromTable;
+
+var removeTableFromFirstChild = function removeTableFromFirstChild(node, i) {
+  return i === 0 ? unwrapContentFromTable(node) : node;
+};
+
+exports.removeTableFromFirstChild = removeTableFromFirstChild;
+
+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.
+ */
+
+
+exports.removeTableFromLastChild = removeTableFromLastChild;
+
+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 _prosemirrorModel.Slice(_prosemirrorModel.Fragment.from( // keep only the content and discard the hardBreak
+      nodes[0]), slice.openStart, slice.openEnd);
+    }
+  }
+
+  return slice;
+};
+
+exports.transformSliceToFixHardBreakProblemOnCopyFromCell = transformSliceToFixHardBreakProblemOnCopyFromCell;
+
+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 _prosemirrorModel.Slice(slice.content.firstChild.content.firstChild.content, slice.openStart - 2, slice.openEnd - 2);
+    }
+
+    return new _prosemirrorModel.Slice((0, _utils.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 _prosemirrorModel.Slice(slice.content, 1, slice.openEnd);
+  }
+
+  return slice;
+};
+
+exports.transformSliceToRemoveOpenTable = transformSliceToRemoveOpenTable;
+
+var transformSliceToCorrectEmptyTableCells = function transformSliceToCorrectEmptyTableCells(slice, schema) {
+  var _schema$nodes3 = schema.nodes,
+      tableCell = _schema$nodes3.tableCell,
+      tableHeader = _schema$nodes3.tableHeader;
+  return (0, _utils.mapSlice)(slice, function (node) {
+    if (node && (node.type === tableCell || node.type === tableHeader) && !node.content.childCount) {
+      return node.type.createAndFill(node.attrs) || node;
+    }
+
+    return node;
+  });
+};
+
+exports.transformSliceToCorrectEmptyTableCells = transformSliceToCorrectEmptyTableCells;
+
+function isHeaderRowRequired(state) {
+  var tableState = (0, _pluginFactory.getPluginState)(state);
+  return tableState && tableState.pluginConfig.isHeaderRowRequired;
+}

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

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isReferencedSource = void 0;
+
+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;
+};
+
+exports.isReferencedSource = isReferencedSource;

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

@@ -0,0 +1,254 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isRowDeleteButtonVisible = exports.getRowsParams = exports.getRowHeights = exports.getRowDeleteButtonParams = exports.getRowClassNames = exports.copyPreviousRow = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _tableMap = require("@atlaskit/editor-tables/table-map");
+
+var _cellSelection = require("@atlaskit/editor-tables/cell-selection");
+
+var _prosemirrorUtils = require("prosemirror-utils");
+
+var _utils = require("@atlaskit/editor-tables/utils");
+
+var _utils2 = require("@atlaskit/editor-common/utils");
+
+var _types = require("../types");
+
+var _consts = require("../ui/consts");
+
+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) { (0, _defineProperty2.default)(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; }
+
+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 = (0, _utils2.parsePx)(styles.paddingTop || '');
+        heights[i] -= paddingTop ? paddingTop + 1 : +1;
+      }
+    }
+  }
+
+  return heights;
+};
+
+exports.getRowHeights = getRowHeights;
+
+var isRowDeleteButtonVisible = function isRowDeleteButtonVisible(selection) {
+  if (!(0, _utils.isTableSelected)(selection) && selection instanceof _cellSelection.CellSelection && selection.isRowSelection()) {
+    return true;
+  }
+
+  return false;
+};
+
+exports.isRowDeleteButtonVisible = isRowDeleteButtonVisible;
+
+var getRowDeleteButtonParams = function getRowDeleteButtonParams(rowsHeights, selection) {
+  var offsetTop = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var rect = (0, _utils.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 - _consts.tableDeleteButtonSize / 2;
+  return {
+    top: top,
+    indexes: indexes
+  };
+};
+
+exports.getRowDeleteButtonParams = getRowDeleteButtonParams;
+
+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;
+};
+
+exports.getRowsParams = getRowsParams;
+
+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 ((0, _utils.isRowSelected)(index)(selection) || hoveredRows.indexOf(index) > -1 && !isResizing) {
+    classNames.push(_types.TableCssClassName.HOVERED_CELL_ACTIVE);
+
+    if (isInDanger) {
+      classNames.push(_types.TableCssClassName.HOVERED_CELL_IN_DANGER);
+    }
+  }
+
+  return classNames.join(' ');
+};
+
+exports.getRowClassNames = getRowClassNames;
+
+var copyPreviousRow = function copyPreviousRow(schema) {
+  return function (insertNewRowIndex) {
+    return function (tr) {
+      var table = (0, _utils.findTable)(tr.selection);
+
+      if (!table) {
+        return tr;
+      }
+
+      var map = _tableMap.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 (0, _prosemirrorUtils.safeInsert)(tableRow.createChecked(cloneRow.attrs, cells, cloneRow.marks), rowPos)(tr);
+    };
+  };
+};
+
+exports.copyPreviousRow = copyPreviousRow;