@atlaskit/editor-tables 2.2.4 → 2.2.6

package/dist/cjs/table-map.js

@@ -1,16 +1,12 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.tableNewColumnMinWidth = exports.TableProblemTypes = exports.TableMap = exports.Rect = void 0;
-
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
 // Because working with row and column-spanning cells is not quite
 // trivial, this code builds up a descriptive structure for a given
 // table node. The structures are cached with the (persistent) table
@@ -21,16 +17,14 @@ var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/cl
 // 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;
@@ -39,7 +33,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) {
@@ -47,17 +40,14 @@ if (typeof WeakMap !== 'undefined') {
       }
     }
   };
-
   addToCache = function addToCache(key, value) {
     if (cachePos === cacheSize) {
       cachePos = 0;
     }
-
     _cache[cachePos++] = key;
     return _cache[cachePos++] = value;
   };
 }
-
 var Rect = /*#__PURE__*/(0, _createClass2.default)(function Rect(left, top, right, bottom) {
   (0, _classCallCheck2.default)(this, Rect);
   this.left = left;
@@ -66,73 +56,68 @@ var Rect = /*#__PURE__*/(0, _createClass2.default)(function Rect(left, top, righ
   this.bottom = bottom;
 });
 exports.Rect = Rect;
-var TableProblemTypes;
-exports.TableProblemTypes = TableProblemTypes;
-
-(function (TableProblemTypes) {
+var TableProblemTypes = /*#__PURE__*/function (TableProblemTypes) {
   TableProblemTypes["COLLISION"] = "collision";
   TableProblemTypes["OVERLONG_ROWSPAN"] = "overlong_rowspan";
   TableProblemTypes["MISSING"] = "missing";
   TableProblemTypes["COLWIDTH_MISMATCH"] = "colwidth mismatch";
-})(TableProblemTypes || (exports.TableProblemTypes = TableProblemTypes = {}));
-
+  return TableProblemTypes;
+}({});
+exports.TableProblemTypes = 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.
-var tableNewColumnMinWidth = 140; // ::- A table map describes the structore of a given table. To avoid
+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.
-
 exports.tableNewColumnMinWidth = tableNewColumnMinWidth;
-
 var TableMap = /*#__PURE__*/function () {
   // The width of the table
+
   // The table's height
+
   function TableMap(width, height, map, problems) {
     (0, _classCallCheck2.default)(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.
   (0, _createClass2.default)(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) {
@@ -141,23 +126,21 @@ 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');
     }
   }, {
@@ -166,100 +149,91 @@ 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;
       }
     }
@@ -267,13 +241,13 @@ 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) {
@@ -282,45 +256,35 @@ var TableMap = /*#__PURE__*/function () {
   }]);
   return TableMap;
 }(); // Compute a table map.
-
-
 exports.TableMap = TableMap;
-
 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({
@@ -330,9 +294,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;
@@ -344,13 +306,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;
@@ -360,20 +319,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,
@@ -381,110 +336,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,
@@ -494,17 +427,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/cjs/utils/add-column-at.js

@@ -4,23 +4,16 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.addColumnAt = void 0;
-
 var _tableMap = require("../table-map");
-
 var _addColumn = require("./add-column");
-
 var _cloneTr = require("./clone-tr");
-
 var _find = require("./find");
-
 // Returns a new transaction that adds a new column at index `columnIndex`.
 var addColumnAt = function addColumnAt(columnIndex) {
   return function (tr) {
     var table = (0, _find.findTable)(tr.selection);
-
     if (table) {
       var map = _tableMap.TableMap.get(table.node);
-
       if (columnIndex >= 0 && columnIndex <= map.width) {
         return (0, _cloneTr.cloneTr)((0, _addColumn.addColumn)(tr, {
           map: map,
@@ -29,9 +22,7 @@ var addColumnAt = function addColumnAt(columnIndex) {
         }, columnIndex));
       }
     }
-
     return tr;
   };
 };
-
 exports.addColumnAt = addColumnAt;

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

@@ -5,74 +5,58 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.addColumn = addColumn;
 exports.columnIsHeader = columnIsHeader;
-
 var _colspan = require("./colspan");
-
 var _tableNodeTypes = require("./table-node-types");
-
 function columnIsHeader(map, table, col) {
   var headerCell = (0, _tableNodeTypes.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.
 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;
       (0, _colspan.assertColspan)(attributes);
-      tr.setNodeMarkup(tr.mapping.map(tableStart + pos), undefined, (0, _colspan.addColSpan)(attributes, col - map.colCount(pos))); // Skip ahead if rowspan > 1
-
+      tr.setNodeMarkup(tr.mapping.map(tableStart + pos), undefined, (0, _colspan.addColSpan)(attributes, col - map.colCount(pos)));
+      // Skip ahead if rowspan > 1
       row += attributes.rowspan - 1;
     } else {
       var type = void 0;
-
       if (refColumn === null) {
         type = (0, _tableNodeTypes.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;
 }