@atlaskit/editor-tables 2.2.3 → 2.2.5

package/dist/esm/utils/copy-paste.js

@@ -1,9 +1,6 @@
 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; }
-
 // Utilities used for copy/paste handling.
 //
 // This module handles pasting cell content into tables, or pasting
@@ -15,54 +12,70 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 // cell selection is different, here the cells in the selection are
 // clipped to the selection's rectangle, optionally repeating the
 // pasted cells when they are smaller than the selection.
+
 import { Fragment, Slice } from 'prosemirror-model';
 import { Transform } from 'prosemirror-transform';
 import { CellSelection } from '../cell-selection';
 import { TableMap } from '../table-map';
 import { removeColSpan } from './colspan';
-import { tableNodeTypes } from './table-node-types'; // Utilities to help with copying and pasting table cells
+import { selectedRect } from './selection-rect';
+import { tableNodeTypes } from './table-node-types';
+import { isHeaderEnabledByType } from './toggle-header';
+
+// Utilities to help with copying and pasting table cells
+
+/**
+ * Replace any header cells with table cells.
+ *
+ * @param schema
+ * @param cells
+ * @returns Fragment with header cells converted to table cells
+ */
+function stripHeaderType(schema, cells) {
+  var newCells = [];
+  cells.forEach(function (cell) {
+    var _cellNodeType$createA;
+    // Convert to cell type if not already
+    var cellNodeType = tableNodeTypes(schema).cell;
+    var tableCell = cell.type === cellNodeType ? cell : (_cellNodeType$createA = cellNodeType.createAndFill(cell.attrs, cell.content, cell.marks)) !== null && _cellNodeType$createA !== void 0 ? _cellNodeType$createA : cell;
+    newCells.push(tableCell);
+  });
+  return Fragment.from(newCells);
+}
+
 // : (Slice) → ?{width: number, height: number, rows: [Fragment]}
 // Get a rectangular area of cells from a slice, or null if the outer
 // nodes of the slice aren't table cells or rows.
-
 export function pastedCells(slice) {
   if (!slice.size) {
     return null;
   }
-
   var content = slice.content,
-      openStart = slice.openStart,
-      openEnd = slice.openEnd;
-
+    openStart = slice.openStart,
+    openEnd = slice.openEnd;
   if (!content.firstChild) {
     throw new Error('pastedCells: no firstChild defined for content');
   }
-
   while (content.childCount === 1 && (openStart > 0 && openEnd > 0 || content.firstChild.type.spec.tableRole === 'table')) {
     openStart--;
     openEnd--;
     content = content.firstChild.content;
-
     if (!content.firstChild) {
       throw new Error('pastedCells: no firstChild defined for content');
     }
   }
-
   var first = content.firstChild;
   var role = first.type.spec.tableRole;
   var schema = first.type.schema;
   var rows = [];
-
   if (role === 'row') {
     for (var i = 0; i < content.childCount; i++) {
       var cells = content.child(i).content;
       var left = i ? 0 : Math.max(0, openStart - 1);
       var right = i < content.childCount - 1 ? 0 : Math.max(0, openEnd - 1);
-
       if (left || right) {
         cells = fitSlice(tableNodeTypes(schema).row, new Slice(cells, left, right)).content;
       }
-
       rows.push(cells);
     }
   } else if (role === 'cell' || role === 'header_cell') {
@@ -70,350 +83,316 @@ export function pastedCells(slice) {
   } else {
     return null;
   }
+  var rowsWithoutHeaders = rows.map(function (row) {
+    return stripHeaderType(schema, row);
+  });
+  return ensureRectangular(schema, rowsWithoutHeaders);
+}
 
-  return ensureRectangular(schema, rows);
-} // : (Schema, [Fragment]) → {width: number, height: number, rows: [Fragment]}
+// : (Schema, [Fragment]) → {width: number, height: number, rows: [Fragment]}
 // Compute the width and height of a set of cells, and make sure each
 // row has the same number of cells.
-
 function ensureRectangular(schema, rowsFragment) {
   var rows = rowsFragment;
   var widths = [];
-
   for (var i = 0; i < rows.length; i++) {
     var row = rows[i];
-
     for (var j = row.childCount - 1; j >= 0; j--) {
       var _row$child$attrs = row.child(j).attrs,
-          rowspan = _row$child$attrs.rowspan,
-          colspan = _row$child$attrs.colspan;
-
+        rowspan = _row$child$attrs.rowspan,
+        colspan = _row$child$attrs.colspan;
       for (var r = i; r < i + rowspan; r++) {
         widths[r] = (widths[r] || 0) + colspan;
       }
     }
   }
-
   var width = 0;
-
   for (var _r = 0; _r < widths.length; _r++) {
     width = Math.max(width, widths[_r]);
   }
-
   for (var _r2 = 0; _r2 < widths.length; _r2++) {
     if (_r2 >= rows.length) {
       rows.push(Fragment.empty);
     }
-
     if (widths[_r2] < width) {
       var empty = tableNodeTypes(schema).cell.createAndFill();
       var cells = [];
-
       for (var _i = widths[_r2]; _i < width; _i++) {
         cells.push(empty);
       }
-
       rows[_r2] = rows[_r2].append(Fragment.from(cells));
     }
   }
-
   return {
     height: rows.length,
     width: width,
     rows: rows
   };
 }
-
 export function fitSlice(nodeType, slice) {
   var node = nodeType.createAndFill();
-
   if (!node) {
     throw new Error("fitSlice: unable to create node");
   }
-
   var tr = new Transform(node).replace(0, node.content.size, slice);
   return tr.doc;
-} // : ({width: number, height: number, rows: [Fragment]}, number, number) → {width: number, height: number, rows: [Fragment]}
+}
+
+// : ({width: number, height: number, rows: [Fragment]}, number, number) → {width: number, height: number, rows: [Fragment]}
 // Clip or extend (repeat) the given set of cells to cover the given
 // width and height. Will clip rowspan/colspan cells at the edges when
 // they stick out.
-
 export function clipCells(_ref, newWidth, newHeight) {
   var currentWidth = _ref.width,
-      currentHeight = _ref.height,
-      currentRows = _ref.rows;
+    currentHeight = _ref.height,
+    currentRows = _ref.rows;
   var rows = currentRows;
   var width = currentWidth;
   var height = currentHeight;
-
   if (width !== newWidth) {
     var added = [];
     var newRows = [];
-
     for (var row = 0; row < rows.length; row++) {
       var frag = rows[row];
       var cells = [];
-
       for (var col = added[row] || 0, i = 0; col < newWidth; i++) {
         var cell = frag.child(i % frag.childCount);
-
         if (col + cell.attrs.colspan > newWidth) {
           cell = cell.type.create(removeColSpan(cell.attrs, cell.attrs.colspan, col + cell.attrs.colspan - newWidth), cell.content);
         }
-
         cells.push(cell);
         col += cell.attrs.colspan;
-
         for (var j = 1; j < cell.attrs.rowspan; j++) {
           added[row + j] = (added[row + j] || 0) + cell.attrs.colspan;
         }
       }
-
       newRows.push(Fragment.from(cells));
     }
-
     rows = newRows;
     width = newWidth;
   }
-
   if (height !== newHeight) {
     var _newRows = [];
-
     for (var _row = 0, _i2 = 0; _row < newHeight; _row++, _i2++) {
       var _cells = [];
       var source = rows[_i2 % height];
-
       for (var _j = 0; _j < source.childCount; _j++) {
         var _cell = source.child(_j);
-
         if (_row + _cell.attrs.rowspan > newHeight) {
           _cell = _cell.type.create(_objectSpread(_objectSpread({}, _cell.attrs), {}, {
             rowspan: Math.max(1, newHeight - _cell.attrs.rowspan)
           }), _cell.content);
         }
-
         _cells.push(_cell);
       }
-
       _newRows.push(Fragment.from(_cells));
     }
-
     rows = _newRows;
     height = newHeight;
   }
-
   return {
     width: width,
     height: height,
     rows: rows
   };
-} // Make sure a table has at least the given width and height. Return
-// true if something was changed.
+}
 
+// Make sure a table has at least the given width and height. Return
+// true if something was changed.
 function growTable(tr, map, table, start, width, height, mapFrom) {
   var schema = tr.doc.type.schema;
   var types = tableNodeTypes(schema);
   var empty;
   var emptyHead;
-
   if (width > map.width) {
     for (var row = 0, rowEnd = 0; row < map.height; row++) {
       var rowNode = table.child(row);
       rowEnd += rowNode.nodeSize;
       var cells = [];
       var add = void 0;
-
       if (rowNode.lastChild == null || rowNode.lastChild.type === types.cell) {
         add = empty || (empty = types.cell.createAndFill());
       } else {
         add = emptyHead || (emptyHead = types.header_cell.createAndFill());
       }
-
       for (var i = map.width; i < width; i++) {
         cells.push(add);
       }
-
       tr.insert(tr.mapping.slice(mapFrom).map(rowEnd - 1 + start), cells);
     }
   }
-
   if (height > map.height) {
     var _cells2 = [];
-
     for (var _i3 = 0, k = (map.height - 1) * map.width; _i3 < Math.max(map.width, width); _i3++) {
       var header = void 0;
-
       if (_i3 >= map.width) {
         header = false;
       } else {
         var mappedPos = map.map[k + _i3];
         var node = table.nodeAt(mappedPos);
-
         if (!node) {
           throw new Error("growTable: no node found at pos ".concat(mappedPos));
         }
-
         header = node.type === types.header_cell;
       }
-
       _cells2.push(header ? emptyHead || (emptyHead = types.header_cell.createAndFill()) : empty || (empty = types.cell.createAndFill()));
     }
-
     var emptyRow = types.row.create(null, Fragment.from(_cells2));
     var rows = [];
-
     for (var _i4 = map.height; _i4 < height; _i4++) {
       rows.push(emptyRow);
     }
-
     tr.insert(tr.mapping.slice(mapFrom).map(start + table.nodeSize - 2), rows);
   }
-
   return !!(empty || emptyHead);
-} // Make sure the given line (left, top) to (right, top) doesn't cross
+}
+
+// Make sure the given line (left, top) to (right, top) doesn't cross
 // any rowspan cells by splitting cells that cross it. Return true if
 // something changed.
-
-
 function isolateHorizontal(tr, map, table, start, left, right, top, mapFrom) {
   if (top === 0 || top === map.height) {
     return false;
   }
-
   var found = false;
-
   for (var col = left; col < right; col++) {
     var index = top * map.width + col;
     var pos = map.map[index];
-
     if (map.map[index - map.width] === pos) {
       found = true;
       var cell = table.nodeAt(pos);
-
       if (!cell) {
         throw new Error("isolateHorizontal: no cell found at pos ".concat(pos));
       }
-
       var _map$findCell = map.findCell(pos),
-          cellTop = _map$findCell.top,
-          cellLeft = _map$findCell.left;
-
+        cellTop = _map$findCell.top,
+        cellLeft = _map$findCell.left;
       tr.setNodeMarkup(tr.mapping.slice(mapFrom).map(pos + start), undefined, _objectSpread(_objectSpread({}, cell.attrs), {}, {
         rowspan: top - cellTop
       }));
       var newCell = cell.type.createAndFill(_objectSpread(_objectSpread({}, cell.attrs), {}, {
         rowspan: cellTop + cell.attrs.rowspan - top
       }));
-
       if (!newCell) {
         throw new Error('isolateHorizontal: failed to create cell');
       }
-
       tr.insert(tr.mapping.slice(mapFrom).map(map.positionAt(top, cellLeft, table)), newCell);
       col += cell.attrs.colspan - 1;
     }
   }
-
   return found;
-} // Make sure the given line (left, top) to (left, bottom) doesn't
+}
+
+// Make sure the given line (left, top) to (left, bottom) doesn't
 // cross any colspan cells by splitting cells that cross it. Return
 // true if something changed.
-
-
 function isolateVertical(tr, map, table, start, top, bottom, left, mapFrom) {
   if (left === 0 || left === map.width) {
     return false;
   }
-
   var found = false;
-
   for (var row = top; row < bottom; row++) {
     var index = row * map.width + left;
     var pos = map.map[index];
-
     if (map.map[index - 1] === pos) {
       found = true;
       var cell = table.nodeAt(pos);
-
       if (!cell) {
         throw new Error("isolateVertical: could not find cell at pos ".concat(pos));
       }
-
       var cellLeft = map.colCount(pos);
       var updatePos = tr.mapping.slice(mapFrom).map(pos + start);
       tr.setNodeMarkup(updatePos, undefined, removeColSpan(cell.attrs, left - cellLeft, cell.attrs.colspan - (left - cellLeft)));
       var newCell = cell.type.createAndFill(removeColSpan(cell.attrs, 0, left - cellLeft));
-
       if (!newCell) {
         throw new Error('isolateVertical: failed to create cell');
       }
-
       tr.insert(updatePos + cell.nodeSize, newCell);
       row += cell.attrs.rowspan - 1;
     }
   }
-
   return found;
-} // Insert the given set of cells (as returned by `pastedCells`) into a
-// table, at the position pointed at by rect.
+}
+function applyHeaderCells(tr, tableMap, state, tableStart, table, headerRowEnabled, headerColumnEnabled) {
+  var schema = state.schema;
+  var setMarkup = function setMarkup(tr, row, col, headerEnabled) {
+    var cellPos = tableStart + tableMap.positionAt(row, col, table);
+    var cell = tr.doc.nodeAt(cellPos);
+    var newType = headerEnabled ? schema.nodes.tableHeader : schema.nodes.tableCell;
+    var isCellTypeChanged = newType !== (cell === null || cell === void 0 ? void 0 : cell.type);
+    var isCellTypeValid = [schema.nodes.tableCell, schema.nodes.tableHeader].includes(cell === null || cell === void 0 ? void 0 : cell.type);
+    if (isCellTypeChanged && isCellTypeValid) {
+      tr.setNodeMarkup(cellPos, newType, cell === null || cell === void 0 ? void 0 : cell.attrs, cell === null || cell === void 0 ? void 0 : cell.marks);
+    }
+  };
 
+  // For row === 0 && col === 0 it is enabled if either are enabled
+  setMarkup(tr, 0, 0, headerColumnEnabled || headerRowEnabled);
+
+  // Header Column
+  for (var col = 1; col < tableMap.width; col++) {
+    setMarkup(tr, 0, col, headerRowEnabled);
+  }
+  // Header Row
+  for (var row = 1; row < tableMap.height; row++) {
+    setMarkup(tr, row, 0, headerColumnEnabled);
+  }
+}
 
+// Insert the given set of cells (as returned by `pastedCells`) into a
+// table, at the position pointed at by rect.
 export function insertCells(state, dispatch, tableStart, rect, cells) {
   var table = state.doc;
+  var newRect = selectedRect(state);
+  var types = tableNodeTypes(state.schema);
 
+  // Get if the header row and column are enabled on the original table
+  var headerRowEnabled = isHeaderEnabledByType('row', newRect, types);
+  var headerColumnEnabled = isHeaderEnabledByType('column', newRect, types);
   if (tableStart) {
     table = state.doc.nodeAt(tableStart - 1);
-
     if (!table) {
       throw new Error("insertCells: could not find table at pos ".concat(tableStart - 1));
     }
   }
-
   var map = TableMap.get(table);
   var top = rect.top,
-      left = rect.left;
+    left = rect.left;
   var right = left + cells.width;
   var bottom = top + cells.height;
   var tr = state.tr;
   var mapFrom = 0;
-
   function recomp() {
     table = tableStart ? tr.doc.nodeAt(tableStart - 1) : tr.doc;
     map = TableMap.get(table);
     mapFrom = tr.mapping.maps.length;
-  } // Prepare the table to be large enough and not have any cells
+  }
+  // Prepare the table to be large enough and not have any cells
   // crossing the boundaries of the rectangle that we want to
   // insert into. If anything about it changes, recompute the table
   // map so that subsequent operations can see the current shape.
-
-
   if (growTable(tr, map, table, tableStart, right, bottom, mapFrom)) {
     recomp();
   }
-
   if (isolateHorizontal(tr, map, table, tableStart, left, right, top, mapFrom)) {
     recomp();
   }
-
   if (isolateHorizontal(tr, map, table, tableStart, left, right, bottom, mapFrom)) {
     recomp();
   }
-
   if (isolateVertical(tr, map, table, tableStart, top, bottom, left, mapFrom)) {
     recomp();
   }
-
   if (isolateVertical(tr, map, table, tableStart, top, bottom, right, mapFrom)) {
     recomp();
   }
-
   for (var row = top; row < bottom; row++) {
     var from = map.positionAt(row, left, table);
     var to = map.positionAt(row, right, table);
     tr.replace(tr.mapping.slice(mapFrom).map(from + tableStart), tr.mapping.slice(mapFrom).map(to + tableStart), new Slice(cells.rows[row - top], 0, 0));
   }
-
   recomp();
+  applyHeaderCells(tr, map, state, tableStart, table, headerRowEnabled, headerColumnEnabled);
   tr.setSelection(new CellSelection(tr.doc.resolve(tableStart + map.positionAt(top, left, table)), tr.doc.resolve(tableStart + map.positionAt(bottom - 1, right - 1, table))));
   dispatch(tr);
 }

package/dist/esm/utils/create-table.js

@@ -1,58 +1,47 @@
 import { tableNodeTypes } from './table-node-types';
 import { uuid } from './uuid';
-
 var createCell = function createCell(cellType, cellContent) {
   if (cellContent) {
     return cellType.createChecked(null, cellContent);
   }
-
   return cellType.createAndFill();
-}; // Returns a table node of a given size.
+};
+
+// Returns a table node of a given size.
 // `withHeaderRow` defines whether the first row of the table will be a header row.
 // `cellContent` defines the content of each cell.
-
-
 export var createTable = function createTable(_ref) {
   var schema = _ref.schema,
-      _ref$rowsCount = _ref.rowsCount,
-      rowsCount = _ref$rowsCount === void 0 ? 3 : _ref$rowsCount,
-      _ref$colsCount = _ref.colsCount,
-      colsCount = _ref$colsCount === void 0 ? 3 : _ref$colsCount,
-      _ref$withHeaderRow = _ref.withHeaderRow,
-      withHeaderRow = _ref$withHeaderRow === void 0 ? true : _ref$withHeaderRow,
-      cellContent = _ref.cellContent;
-
+    _ref$rowsCount = _ref.rowsCount,
+    rowsCount = _ref$rowsCount === void 0 ? 3 : _ref$rowsCount,
+    _ref$colsCount = _ref.colsCount,
+    colsCount = _ref$colsCount === void 0 ? 3 : _ref$colsCount,
+    _ref$withHeaderRow = _ref.withHeaderRow,
+    withHeaderRow = _ref$withHeaderRow === void 0 ? true : _ref$withHeaderRow,
+    cellContent = _ref.cellContent;
   var _tableNodeTypes = tableNodeTypes(schema),
-      tableCell = _tableNodeTypes.cell,
-      tableHeader = _tableNodeTypes.header_cell,
-      tableRow = _tableNodeTypes.row,
-      table = _tableNodeTypes.table;
-
+    tableCell = _tableNodeTypes.cell,
+    tableHeader = _tableNodeTypes.header_cell,
+    tableRow = _tableNodeTypes.row,
+    table = _tableNodeTypes.table;
   var cells = [];
   var headerCells = [];
-
   for (var i = 0; i < colsCount; i++) {
     var cell = createCell(tableCell, cellContent);
-
     if (cell) {
       cells.push(cell);
     }
-
     if (withHeaderRow) {
       var headerCell = createCell(tableHeader, cellContent);
-
       if (headerCell) {
         headerCells.push(headerCell);
       }
     }
   }
-
   var rows = [];
-
   for (var _i = 0; _i < rowsCount; _i++) {
     rows.push(tableRow.createChecked(null, withHeaderRow && _i === 0 ? headerCells : cells));
   }
-
   return table.createChecked({
     localId: uuid.generate()
   }, rows);

package/dist/esm/utils/draw-cell-selection.js

@@ -4,7 +4,6 @@ export function drawCellSelection(state) {
   if (!(state.selection instanceof CellSelection)) {
     return null;
   }
-
   var cells = [];
   state.selection.forEachCell(function (node, pos) {
     cells.push(Decoration.node(pos, pos + node.nodeSize, {

package/dist/esm/utils/empty-cells.js

@@ -1,17 +1,16 @@
 import { cloneTr } from './clone-tr';
-import { tableNodeTypes } from './table-node-types'; // Returns a new transaction that clears the content of a given `cell`.
+import { tableNodeTypes } from './table-node-types';
 
+// Returns a new transaction that clears the content of a given `cell`.
 export var emptyCell = function emptyCell(cell, schema) {
   return function (tr) {
     if (cell) {
       var node = tableNodeTypes(schema).cell.createAndFill();
-
       if (node && !cell.node.content.eq(node.content)) {
         tr.replaceWith(cell.pos + 1, cell.pos + cell.node.nodeSize, node.content);
         return cloneTr(tr);
       }
     }
-
     return tr;
   };
 };

package/dist/esm/utils/find.js

@@ -1,34 +1,34 @@
 import { findParentNode, findParentNodeClosestToPos } from 'prosemirror-utils';
-import { TableMap } from '../table-map'; // Iterates over parent nodes, returning the closest table node.
+import { TableMap } from '../table-map';
 
+// Iterates over parent nodes, returning the closest table node.
 export var findTable = function findTable(selection) {
   return findParentNode(function (node) {
     return node.type.spec.tableRole && node.type.spec.tableRole === 'table';
   })(selection);
-}; // Iterates over parent nodes, returning a table node closest to a given `$pos`.
+};
 
+// Iterates over parent nodes, returning a table node closest to a given `$pos`.
 export var findTableClosestToPos = function findTableClosestToPos($pos) {
   var predicate = function predicate(node) {
     return node.type.spec.tableRole && node.type.spec.tableRole === 'table';
   };
-
   return findParentNodeClosestToPos($pos, predicate);
-}; // Iterates over parent nodes, returning a table cell or a table header node closest to a given `$pos`.
+};
 
+// Iterates over parent nodes, returning a table cell or a table header node closest to a given `$pos`.
 export var findCellClosestToPos = function findCellClosestToPos($pos) {
   var predicate = function predicate(node) {
     return node.type.spec.tableRole && /cell/i.test(node.type.spec.tableRole);
   };
-
   return findParentNodeClosestToPos($pos, predicate);
-}; // Returns the rectangle spanning a cell closest to a given `$pos`.
+};
 
+// Returns the rectangle spanning a cell closest to a given `$pos`.
 export var findCellRectClosestToPos = function findCellRectClosestToPos($pos) {
   var cell = findCellClosestToPos($pos);
-
   if (cell) {
     var table = findTableClosestToPos($pos);
-
     if (table) {
       var map = TableMap.get(table.node);
       var cellPos = cell.pos - table.start;