@atlaskit/editor-tables 2.2.4 → 2.2.6

package/dist/esm/pm-plugins/table-editing.js

@@ -4,7 +4,9 @@ import { drawCellSelection } from '../utils/draw-cell-selection';
 import { fixTables } from '../utils/fix-tables';
 import { normalizeSelection } from '../utils/normalize-selection';
 import { handleKeyDown, handleMouseDown, handleTripleClick } from './input';
-import { tableEditingKey } from './plugin-key'; // :: () → Plugin
+import { tableEditingKey } from './plugin-key';
+
+// :: () → Plugin
 //
 // Creates a [plugin](http://prosemirror.net/docs/ref/#state.Plugin)
 // that, when added to an editor, enables cell-selection, handles
@@ -16,13 +18,11 @@ import { tableEditingKey } from './plugin-key'; // :: () → Plugin
 // rather broadly, and other plugins, like the gap cursor or the
 // column-width dragging plugin, might want to get a turn first to
 // perform more specific behavior.
-
 export function tableEditing() {
   var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-      _ref$allowTableNodeSe = _ref.allowTableNodeSelection,
-      allowTableNodeSelection = _ref$allowTableNodeSe === void 0 ? false : _ref$allowTableNodeSe,
-      reportFixedTable = _ref.reportFixedTable;
-
+    _ref$allowTableNodeSe = _ref.allowTableNodeSelection,
+    allowTableNodeSelection = _ref$allowTableNodeSe === void 0 ? false : _ref$allowTableNodeSe,
+    reportFixedTable = _ref.reportFixedTable;
   return new Plugin({
     key: tableEditingKey,
     // This piece of state is used to remember when a mouse-drag
@@ -35,19 +35,15 @@ export function tableEditing() {
       apply: function apply(unsafeTr, cur) {
         var tr = unsafeTr;
         var set = tr.getMeta(tableEditingKey);
-
         if (set != null) {
           return set === -1 ? null : set;
         }
-
         if (cur == null || !tr.docChanged) {
           return cur;
         }
-
         var _tr$mapping$mapResult = tr.mapping.mapResult(cur),
-            deleted = _tr$mapping$mapResult.deleted,
-            pos = _tr$mapping$mapResult.pos;
-
+          deleted = _tr$mapping$mapResult.deleted,
+          pos = _tr$mapping$mapResult.pos;
         return deleted ? null : pos;
       }
     },
@@ -60,7 +56,6 @@ export function tableEditing() {
         if (tableEditingKey.getState(view.state) != null) {
           return view.state.selection;
         }
-
         return null;
       },
       handleTripleClick: handleTripleClick,

package/dist/esm/table-map.js

@@ -10,16 +10,14 @@ import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 // document-relative positions. So code that uses them will typically
 // compute the start position of the table and offset positions passed
 // to or gotten from this structure by that amount.
-var readFromCache, addToCache; // Prefer using a weak map to cache table maps. Fall back on a
+var readFromCache, addToCache;
+// Prefer using a weak map to cache table maps. Fall back on a
 // fixed-size cache if that's not supported.
-
 if (typeof WeakMap !== 'undefined') {
   var cache = new WeakMap();
-
   readFromCache = function readFromCache(key) {
     return cache.get(key);
   };
-
   addToCache = function addToCache(key, value) {
     cache.set(key, value);
     return value;
@@ -28,7 +26,6 @@ if (typeof WeakMap !== 'undefined') {
   var _cache = [];
   var cacheSize = 10;
   var cachePos = 0;
-
   readFromCache = function readFromCache(key) {
     for (var i = 0; i < _cache.length; i += 2) {
       if (_cache[i] === key) {
@@ -36,90 +33,81 @@ if (typeof WeakMap !== 'undefined') {
       }
     }
   };
-
   addToCache = function addToCache(key, value) {
     if (cachePos === cacheSize) {
       cachePos = 0;
     }
-
     _cache[cachePos++] = key;
     return _cache[cachePos++] = value;
   };
 }
-
 export var Rect = /*#__PURE__*/_createClass(function Rect(left, top, right, bottom) {
   _classCallCheck(this, Rect);
-
   this.left = left;
   this.top = top;
   this.right = right;
   this.bottom = bottom;
 });
-export var TableProblemTypes;
-
-(function (TableProblemTypes) {
+export var TableProblemTypes = /*#__PURE__*/function (TableProblemTypes) {
   TableProblemTypes["COLLISION"] = "collision";
   TableProblemTypes["OVERLONG_ROWSPAN"] = "overlong_rowspan";
   TableProblemTypes["MISSING"] = "missing";
   TableProblemTypes["COLWIDTH_MISMATCH"] = "colwidth mismatch";
-})(TableProblemTypes || (TableProblemTypes = {}));
-
+  return TableProblemTypes;
+}({});
 // Ideally tableNewColumnMinWidth should be imported
 // from '@atlaskit/editor-common/styles';
 // We don't want to introduce a new dependency.
 // Thus we define the constant here.
-export var tableNewColumnMinWidth = 140; // ::- A table map describes the structore of a given table. To avoid
+export var tableNewColumnMinWidth = 140;
+
+// ::- A table map describes the structore of a given table. To avoid
 // recomputing them all the time, they are cached per table node. To
 // be able to do that, positions saved in the map are relative to the
 // start of the table, rather than the start of the document.
-
 export var TableMap = /*#__PURE__*/function () {
   // The width of the table
+
   // The table's height
+
   function TableMap(width, height, map, problems) {
     _classCallCheck(this, TableMap);
-
     this.width = width;
-    this.height = height; // :: [number] A width * height array with the start position of
+    this.height = height;
+    // :: [number] A width * height array with the start position of
     // the cell covering that part of the table in each slot
-
-    this.map = map; // An optional array of problems (cell overlap or non-rectangular
+    this.map = map;
+    // An optional array of problems (cell overlap or non-rectangular
     // shape) for the table, used by the table normalizer.
-
     this.problems = problems;
-  } // :: (number) → Rect
-  // Find the dimensions of the cell at the given position.
-
+  }
 
+  // :: (number) → Rect
+  // Find the dimensions of the cell at the given position.
   _createClass(TableMap, [{
     key: "findCell",
     value: function findCell(pos) {
       for (var i = 0; i < this.map.length; i++) {
         var curPos = this.map[i];
-
         if (curPos !== pos) {
           continue;
         }
-
         var left = i % this.width;
         var top = i / this.width | 0;
         var right = left + 1;
         var bottom = top + 1;
-
         for (var j = 1; right < this.width && this.map[i + j] === curPos; j++) {
           right++;
         }
-
         for (var _j = 1; bottom < this.height && this.map[i + this.width * _j] === curPos; _j++) {
           bottom++;
         }
-
         return new Rect(left, top, right, bottom);
       }
-
       throw new RangeError('No cell with offset ' + pos + ' found');
-    } // Find the left side of the cell at the given position.
+    }
 
+    // Find the left side of the cell at the given position.
   }, {
     key: "colCount",
     value: function colCount(pos) {
@@ -128,23 +116,21 @@ export var TableMap = /*#__PURE__*/function () {
           return i % this.width;
         }
       }
-
       throw new RangeError('No cell with offset ' + pos + ' found');
-    } // Find the top side of the cell at the given position.
+    }
 
+    // Find the top side of the cell at the given position.
   }, {
     key: "rowCount",
     value: function rowCount(pos) {
       if (this.width <= 0) {
         throw new RangeError('Wrong table width found');
       }
-
       for (var i = 0; i < this.map.length; i++) {
         if (this.map[i] === pos) {
           return Math.floor(i / this.width);
         }
       }
-
       throw new RangeError('No cell with offset ' + pos + ' found');
     }
   }, {
@@ -153,100 +139,91 @@ export var TableMap = /*#__PURE__*/function () {
       return this.map.filter(function (cellPos) {
         return cellPos === pos;
       }).length > 1;
-    } // :: (number, string, number) → ?number
+    }
+
+    // :: (number, string, number) → ?number
     // Find the next cell in the given direction, starting from the cell
     // at `pos`, if any.
-
   }, {
     key: "nextCell",
     value: function nextCell(pos, axis, dir) {
       var _this$findCell = this.findCell(pos),
-          left = _this$findCell.left,
-          right = _this$findCell.right,
-          top = _this$findCell.top,
-          bottom = _this$findCell.bottom;
-
+        left = _this$findCell.left,
+        right = _this$findCell.right,
+        top = _this$findCell.top,
+        bottom = _this$findCell.bottom;
       if (axis === 'horiz') {
         if (dir < 0 ? left === 0 : right === this.width) {
           return null;
         }
-
         return this.map[top * this.width + (dir < 0 ? left - 1 : right)];
       } else {
         if (dir < 0 ? top === 0 : bottom === this.height) {
           return null;
         }
-
         return this.map[left + this.width * (dir < 0 ? top - 1 : bottom)];
       }
-    } // :: (number, number) → Rect
-    // Get the rectangle spanning the two given cells.
+    }
 
+    // :: (number, number) → Rect
+    // Get the rectangle spanning the two given cells.
   }, {
     key: "rectBetween",
     value: function rectBetween(a, b) {
       var _this$findCell2 = this.findCell(a),
-          leftA = _this$findCell2.left,
-          rightA = _this$findCell2.right,
-          topA = _this$findCell2.top,
-          bottomA = _this$findCell2.bottom;
-
+        leftA = _this$findCell2.left,
+        rightA = _this$findCell2.right,
+        topA = _this$findCell2.top,
+        bottomA = _this$findCell2.bottom;
       var _this$findCell3 = this.findCell(b),
-          leftB = _this$findCell3.left,
-          rightB = _this$findCell3.right,
-          topB = _this$findCell3.top,
-          bottomB = _this$findCell3.bottom;
-
+        leftB = _this$findCell3.left,
+        rightB = _this$findCell3.right,
+        topB = _this$findCell3.top,
+        bottomB = _this$findCell3.bottom;
       return new Rect(Math.min(leftA, leftB), Math.min(topA, topB), Math.max(rightA, rightB), Math.max(bottomA, bottomB));
-    } // :: (Rect) → [number]
+    }
+
+    // :: (Rect) → [number]
     // Return the position of all cells that have the top left corner in
     // the given rectangle.
-
   }, {
     key: "cellsInRect",
     value: function cellsInRect(rect) {
       var result = [];
       var seen = {};
-
       for (var row = rect.top; row < rect.bottom; row++) {
         for (var col = rect.left; col < rect.right; col++) {
           var index = row * this.width + col;
           var pos = this.map[index];
-
           if (seen[pos]) {
             continue;
           }
-
           seen[pos] = true;
-
           if ((col !== rect.left || !col || this.map[index - 1] !== pos) && (row !== rect.top || !row || this.map[index - this.width] !== pos)) {
             result.push(pos);
           }
         }
       }
-
       return result;
-    } // :: (number, number, Node) → number
+    }
+
+    // :: (number, number, Node) → number
     // Return the position at which the cell at the given row and column
     // starts, or would start, if a cell started there.
-
   }, {
     key: "positionAt",
     value: function positionAt(row, col, table) {
       for (var i = 0, rowStart = 0;; i++) {
         var rowEnd = rowStart + table.child(i).nodeSize;
-
         if (i === row) {
           var index = col + row * this.width;
-          var rowEndIndex = (row + 1) * this.width; // Skip past cells from previous rows (via rowspan)
-
+          var rowEndIndex = (row + 1) * this.width;
+          // Skip past cells from previous rows (via rowspan)
           while (index < rowEndIndex && this.map[index] < rowStart) {
             index++;
           }
-
           return index === rowEndIndex ? rowEnd - 1 : this.map[index];
         }
-
         rowStart = rowEnd;
       }
     }
@@ -254,58 +231,51 @@ export var TableMap = /*#__PURE__*/function () {
     key: "getMaxColInRow",
     value: function getMaxColInRow(pos) {
       var parentRowNode = pos.parent;
-
       if (parentRowNode.type.name === 'tableRow') {
         return parentRowNode.childCount;
       }
-    } // :: (Node) → TableMap
-    // Find the table map for the given table node.
+    }
 
+    // :: (Node) → TableMap
+    // Find the table map for the given table node.
   }], [{
     key: "get",
     value: function get(table) {
       return readFromCache(table) || addToCache(table, computeMap(table));
     }
   }]);
-
   return TableMap;
-}(); // Compute a table map.
+}();
 
+// Compute a table map.
 function computeMap(table) {
   if (table.type.spec.tableRole !== 'table') {
     throw new RangeError('Not a table node: ' + table.type.name);
   }
-
   var width = findWidth(table);
   var height = table.childCount;
   var map = [],
-      mapPos = 0,
-      problems = null,
-      colWidths = [];
-
+    mapPos = 0,
+    problems = null,
+    colWidths = [];
   for (var i = 0, e = width * height; i < e; i++) {
     map[i] = 0;
   }
-
   for (var row = 0, pos = 0; row < height; row++) {
     var rowNode = table.child(row);
     pos++;
-
     for (var _i = 0;; _i++) {
       while (mapPos < map.length && map[mapPos] !== 0) {
         mapPos++;
       }
-
       if (_i === rowNode.childCount) {
         break;
       }
-
       var cellNode = rowNode.child(_i),
-          _cellNode$attrs = cellNode.attrs,
-          colspan = _cellNode$attrs.colspan,
-          rowspan = _cellNode$attrs.rowspan,
-          colwidth = _cellNode$attrs.colwidth;
-
+        _cellNode$attrs = cellNode.attrs,
+        colspan = _cellNode$attrs.colspan,
+        rowspan = _cellNode$attrs.rowspan,
+        colwidth = _cellNode$attrs.colwidth;
       for (var h = 0; h < rowspan; h++) {
         if (h + row >= height) {
           (problems || (problems = [])).push({
@@ -315,9 +285,7 @@ function computeMap(table) {
           });
           break;
         }
-
         var start = mapPos + h * width;
-
         for (var w = 0; w < colspan; w++) {
           if (map[start + w] === 0) {
             map[start + w] = pos;
@@ -329,13 +297,10 @@ function computeMap(table) {
               n: colspan - w
             });
           }
-
           var colW = colwidth && colwidth[w];
-
           if (colW) {
             var widthIndex = (start + w) % width * 2,
-                prev = colWidths[widthIndex];
-
+              prev = colWidths[widthIndex];
             if (prev == null || prev !== colW && colWidths[widthIndex + 1] === 1) {
               colWidths[widthIndex] = colW;
               colWidths[widthIndex + 1] = 1;
@@ -345,20 +310,16 @@ function computeMap(table) {
           }
         }
       }
-
       mapPos += colspan;
       pos += cellNode.nodeSize;
     }
-
     var expectedPos = (row + 1) * width;
     var missing = 0;
-
     while (mapPos < expectedPos) {
       if (map[mapPos++] === 0) {
         missing++;
       }
     }
-
     if (missing) {
       (problems || (problems = [])).push({
         type: TableProblemTypes.MISSING,
@@ -366,110 +327,88 @@ function computeMap(table) {
         n: missing
       });
     }
-
     pos++;
   }
-
   var tableMap = new TableMap(width, height, map, problems);
-  var badWidths = false; // For columns that have defined widths, but whose widths disagree
+  var badWidths = false;
+
+  // For columns that have defined widths, but whose widths disagree
   // between rows, fix up the cells whose width doesn't match the
   // computed one.
-
   for (var _i2 = 0; !badWidths && _i2 < colWidths.length; _i2 += 2) {
     if (colWidths[_i2] != null && colWidths[_i2 + 1] < height) {
       badWidths = true;
     }
-  } // colWidths is an array of numbers, it can look like this
+  }
+
+  // colWidths is an array of numbers, it can look like this
   // const colWidths = [255, 3, 125, 3, 150, 2, 130, 1];
   // 255 is a colWidth and 3 is a number of cells with this colwidth.
   // This check exists to make sure that the table has been resized,
   // which means there will be elements in the colWidths array.
-
-
   if (colWidths.length > 0 && colWidths.length !== width * 2) {
     for (var _i3 = 0; _i3 < width * 2 - colWidths.length; _i3++) {
       colWidths.push(tableNewColumnMinWidth, 0);
     }
-
     badWidths = true;
   }
-
   if (badWidths) {
     findBadColWidths(tableMap, colWidths, table);
   }
-
   return tableMap;
 }
-
 function findWidth(table) {
   var width = -1;
   var hasRowSpan = false;
-
   for (var row = 0; row < table.childCount; row++) {
     var rowNode = table.child(row);
     var rowWidth = 0;
-
     if (hasRowSpan) {
       for (var j = 0; j < row; j++) {
         var prevRow = table.child(j);
-
         for (var i = 0; i < prevRow.childCount; i++) {
           var cell = prevRow.child(i);
-
           if (j + cell.attrs.rowspan > row) {
             rowWidth += cell.attrs.colspan;
           }
         }
       }
     }
-
     for (var _i4 = 0; _i4 < rowNode.childCount; _i4++) {
       var _cell = rowNode.child(_i4);
-
       rowWidth += _cell.attrs.colspan;
-
       if (_cell.attrs.rowspan > 1) {
         hasRowSpan = true;
       }
     }
-
     if (width === -1) {
       width = rowWidth;
     } else if (width !== rowWidth) {
       width = Math.max(width, rowWidth);
     }
   }
-
   return width;
 }
-
 function findBadColWidths(map, colWidths, table) {
   if (!map.problems) {
     map.problems = [];
   }
-
   var seen = {};
-
   for (var i = 0; i < map.map.length; i++) {
     var pos = map.map[i];
-
     if (seen[pos]) {
       continue;
     }
-
     seen[pos] = true;
     var node = table.nodeAt(pos),
-        updated = null;
-
+      updated = null;
     for (var j = 0; j < node.attrs.colspan; j++) {
       var col = (i + j) % map.width,
-          colWidth = colWidths[col * 2];
-
+        colWidth = colWidths[col * 2];
       if (colWidth != null && (!node.attrs.colwidth || node.attrs.colwidth[j] !== colWidth)) {
         (updated || (updated = freshColWidth(node.attrs)))[j] = colWidth;
       }
     }
-
     if (updated) {
       map.problems.unshift({
         type: TableProblemTypes.COLWIDTH_MISMATCH,
@@ -479,17 +418,13 @@ function findBadColWidths(map, colWidths, table) {
     }
   }
 }
-
 function freshColWidth(attrs) {
   if (attrs.colwidth) {
     return attrs.colwidth.slice();
   }
-
   var result = [];
-
   for (var i = 0; i < attrs.colspan; i++) {
     result.push(0);
   }
-
   return result;
 }

package/dist/esm/utils/add-column-at.js

@@ -1,15 +1,14 @@
 import { TableMap } from '../table-map';
 import { addColumn } from './add-column';
 import { cloneTr } from './clone-tr';
-import { findTable } from './find'; // Returns a new transaction that adds a new column at index `columnIndex`.
+import { findTable } from './find';
 
+// Returns a new transaction that adds a new column at index `columnIndex`.
 export var addColumnAt = function addColumnAt(columnIndex) {
   return function (tr) {
     var table = findTable(tr.selection);
-
     if (table) {
       var map = TableMap.get(table.node);
-
       if (columnIndex >= 0 && columnIndex <= map.width) {
         return cloneTr(addColumn(tr, {
           map: map,
@@ -18,7 +17,6 @@ export var addColumnAt = function addColumnAt(columnIndex) {
         }, columnIndex));
       }
     }
-
     return tr;
   };
 };

package/dist/esm/utils/add-column.js

@@ -2,66 +2,54 @@ import { addColSpan, assertColspan } from './colspan';
 import { tableNodeTypes } from './table-node-types';
 export function columnIsHeader(map, table, col) {
   var headerCell = tableNodeTypes(table.type.schema).header_cell;
-
   for (var row = 0; row < map.height; row++) {
     var cell = table.nodeAt(map.map[col + row * map.width]);
-
     if (cell && cell.type !== headerCell) {
       return false;
     }
   }
-
   return true;
-} // Add a column at the given position in a table.
+}
 
+// Add a column at the given position in a table.
 export function addColumn(tr, _ref, col) {
   var map = _ref.map,
-      tableStart = _ref.tableStart,
-      table = _ref.table;
+    tableStart = _ref.tableStart,
+    table = _ref.table;
   var refColumn = col > 0 ? -1 : 0;
-
   if (columnIsHeader(map, table, col + refColumn)) {
     refColumn = col === 0 || col === map.width ? null : 0;
   }
-
   for (var row = 0; row < map.height; row++) {
-    var index = row * map.width + col; // If this position falls inside a col-spanning cell
+    var index = row * map.width + col;
 
+    // If this position falls inside a col-spanning cell
     if (col > 0 && col < map.width && map.map[index - 1] === map.map[index]) {
       var pos = map.map[index];
       var cell = table.nodeAt(pos);
-
       if (!cell) {
         throw new Error("addColumn: invalid cell for pos ".concat(pos));
       }
-
       var attributes = cell.attrs;
       assertColspan(attributes);
-      tr.setNodeMarkup(tr.mapping.map(tableStart + pos), undefined, addColSpan(attributes, col - map.colCount(pos))); // Skip ahead if rowspan > 1
-
+      tr.setNodeMarkup(tr.mapping.map(tableStart + pos), undefined, addColSpan(attributes, col - map.colCount(pos)));
+      // Skip ahead if rowspan > 1
       row += attributes.rowspan - 1;
     } else {
       var type = void 0;
-
       if (refColumn === null) {
         type = tableNodeTypes(table.type.schema).cell;
       } else {
         var mappedPos = map.map[index + refColumn];
-
         var _cell = table.nodeAt(mappedPos);
-
         if (!_cell) {
           throw new Error("addColumn: invalid node at mapped pos ".concat(mappedPos));
         }
-
         type = _cell.type;
       }
-
       var _pos = map.positionAt(row, col, table);
-
       tr.insert(tr.mapping.map(tableStart + _pos), type.createAndFill());
     }
   }
-
   return tr;
 }