@atlaskit/editor-tables 2.2.4 → 2.2.6

package/dist/es2019/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,7 +18,6 @@ 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({
   allowTableNodeSelection = false,
   reportFixedTable
@@ -30,49 +31,39 @@ export function tableEditing({
       init() {
         return null;
       },
-
       apply(unsafeTr, cur) {
         const tr = unsafeTr;
         const set = tr.getMeta(tableEditingKey);
-
         if (set != null) {
           return set === -1 ? null : set;
         }
-
         if (cur == null || !tr.docChanged) {
           return cur;
         }
-
         const {
           deleted,
           pos
         } = tr.mapping.mapResult(cur);
         return deleted ? null : pos;
       }
-
     },
     props: {
       decorations: drawCellSelection,
       handleDOMEvents: {
         mousedown: handleMouseDown
       },
-
       createSelectionBetween(view) {
         if (tableEditingKey.getState(view.state) != null) {
           return view.state.selection;
         }
-
         return null;
       },
-
       handleTripleClick,
       handleKeyDown,
       handlePaste
     },
-
     appendTransaction(_, oldState, state) {
       return normalizeSelection(state, fixTables(state, oldState, reportFixedTable), allowTableNodeSelection);
     }
-
   });
 }

package/dist/es2019/table-map.js

@@ -8,14 +8,12 @@
 // 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.
-let readFromCache, addToCache; // Prefer using a weak map to cache table maps. Fall back on a
+let 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') {
   let cache = new WeakMap();
-
   readFromCache = key => cache.get(key);
-
   addToCache = (key, value) => {
     cache.set(key, value);
     return value;
@@ -24,7 +22,6 @@ if (typeof WeakMap !== 'undefined') {
   let cache = [];
   let cacheSize = 10;
   let cachePos = 0;
-
   readFromCache = key => {
     for (let i = 0; i < cache.length; i += 2) {
       if (cache[i] === key) {
@@ -32,17 +29,14 @@ if (typeof WeakMap !== 'undefined') {
       }
     }
   };
-
   addToCache = (key, value) => {
     if (cachePos === cacheSize) {
       cachePos = 0;
     }
-
     cache[cachePos++] = key;
     return cache[cachePos++] = value;
   };
 }
-
 export class Rect {
   constructor(left, top, right, bottom) {
     this.left = left;
@@ -50,102 +44,92 @@ export class Rect {
     this.right = right;
     this.bottom = bottom;
   }
-
 }
-export let TableProblemTypes;
-
-(function (TableProblemTypes) {
+export let 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 const tableNewColumnMinWidth = 140; // ::- A table map describes the structore of a given table. To avoid
+export const 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 class TableMap {
   // The width of the table
+
   // The table's height
+
   constructor(width, height, map, problems) {
     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.
   findCell(pos) {
     for (let i = 0; i < this.map.length; i++) {
       let curPos = this.map[i];
-
       if (curPos !== pos) {
         continue;
       }
-
       let left = i % this.width;
       let top = i / this.width | 0;
       let right = left + 1;
       let bottom = top + 1;
-
       for (let j = 1; right < this.width && this.map[i + j] === curPos; j++) {
         right++;
       }
-
       for (let 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.
   colCount(pos) {
     for (let i = 0; i < this.map.length; i++) {
       if (this.map[i] === pos) {
         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.
   rowCount(pos) {
     if (this.width <= 0) {
       throw new RangeError('Wrong table width found');
     }
-
     for (let 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');
   }
-
   isPosMerged(pos) {
     return this.map.filter(cellPos => 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.
-
-
   nextCell(pos, axis, dir) {
     let {
       left,
@@ -153,24 +137,21 @@ export class TableMap {
       top,
       bottom
     } = this.findCell(pos);
-
     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.
   rectBetween(a, b) {
     let {
       left: leftA,
@@ -185,109 +166,92 @@ export class TableMap {
       bottom: bottomB
     } = this.findCell(b);
     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.
-
-
   cellsInRect(rect) {
     let result = [];
     let seen = {};
-
     for (let row = rect.top; row < rect.bottom; row++) {
       for (let col = rect.left; col < rect.right; col++) {
         let index = row * this.width + col;
         let 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.
-
-
   positionAt(row, col, table) {
     for (let i = 0, rowStart = 0;; i++) {
       let rowEnd = rowStart + table.child(i).nodeSize;
-
       if (i === row) {
         let index = col + row * this.width;
-        let rowEndIndex = (row + 1) * this.width; // Skip past cells from previous rows (via rowspan)
-
+        let 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;
     }
   }
-
   getMaxColInRow(pos) {
     let 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.
   static get(table) {
     return readFromCache(table) || addToCache(table, computeMap(table));
   }
+}
 
-} // 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);
   }
-
   let width = findWidth(table);
   let height = table.childCount;
   let map = [],
-      mapPos = 0,
-      problems = null,
-      colWidths = [];
-
+    mapPos = 0,
+    problems = null,
+    colWidths = [];
   for (let i = 0, e = width * height; i < e; i++) {
     map[i] = 0;
   }
-
   for (let row = 0, pos = 0; row < height; row++) {
     let rowNode = table.child(row);
     pos++;
-
     for (let i = 0;; i++) {
       while (mapPos < map.length && map[mapPos] !== 0) {
         mapPos++;
       }
-
       if (i === rowNode.childCount) {
         break;
       }
-
       let cellNode = rowNode.child(i),
-          {
-        colspan,
-        rowspan,
-        colwidth
-      } = cellNode.attrs;
-
+        {
+          colspan,
+          rowspan,
+          colwidth
+        } = cellNode.attrs;
       for (let h = 0; h < rowspan; h++) {
         if (h + row >= height) {
           (problems || (problems = [])).push({
@@ -297,9 +261,7 @@ function computeMap(table) {
           });
           break;
         }
-
         let start = mapPos + h * width;
-
         for (let w = 0; w < colspan; w++) {
           if (map[start + w] === 0) {
             map[start + w] = pos;
@@ -311,13 +273,10 @@ function computeMap(table) {
               n: colspan - w
             });
           }
-
           let colW = colwidth && colwidth[w];
-
           if (colW) {
             let 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;
@@ -327,20 +286,16 @@ function computeMap(table) {
           }
         }
       }
-
       mapPos += colspan;
       pos += cellNode.nodeSize;
     }
-
     let expectedPos = (row + 1) * width;
     let missing = 0;
-
     while (mapPos < expectedPos) {
       if (map[mapPos++] === 0) {
         missing++;
       }
     }
-
     if (missing) {
       (problems || (problems = [])).push({
         type: TableProblemTypes.MISSING,
@@ -348,109 +303,88 @@ function computeMap(table) {
         n: missing
       });
     }
-
     pos++;
   }
-
   let tableMap = new TableMap(width, height, map, problems);
-  let badWidths = false; // For columns that have defined widths, but whose widths disagree
+  let 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 (let i = 0; !badWidths && i < colWidths.length; i += 2) {
     if (colWidths[i] != null && colWidths[i + 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 (let i = 0; i < width * 2 - colWidths.length; i++) {
       colWidths.push(tableNewColumnMinWidth, 0);
     }
-
     badWidths = true;
   }
-
   if (badWidths) {
     findBadColWidths(tableMap, colWidths, table);
   }
-
   return tableMap;
 }
-
 function findWidth(table) {
   let width = -1;
   let hasRowSpan = false;
-
   for (let row = 0; row < table.childCount; row++) {
     let rowNode = table.child(row);
     let rowWidth = 0;
-
     if (hasRowSpan) {
       for (let j = 0; j < row; j++) {
         let prevRow = table.child(j);
-
         for (let i = 0; i < prevRow.childCount; i++) {
           let cell = prevRow.child(i);
-
           if (j + cell.attrs.rowspan > row) {
             rowWidth += cell.attrs.colspan;
           }
         }
       }
     }
-
     for (let i = 0; i < rowNode.childCount; i++) {
       let cell = rowNode.child(i);
       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 = [];
   }
-
   let seen = {};
-
   for (let i = 0; i < map.map.length; i++) {
     let pos = map.map[i];
-
     if (seen[pos]) {
       continue;
     }
-
     seen[pos] = true;
     let node = table.nodeAt(pos),
-        updated = null;
-
+      updated = null;
     for (let j = 0; j < node.attrs.colspan; j++) {
       let 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,
@@ -460,17 +394,13 @@ function findBadColWidths(map, colWidths, table) {
     }
   }
 }
-
 function freshColWidth(attrs) {
   if (attrs.colwidth) {
     return attrs.colwidth.slice();
   }
-
   let result = [];
-
   for (let i = 0; i < attrs.colspan; i++) {
     result.push(0);
   }
-
   return result;
 }

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

@@ -1,14 +1,13 @@
 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 const addColumnAt = columnIndex => tr => {
   const table = findTable(tr.selection);
-
   if (table) {
     const map = TableMap.get(table.node);
-
     if (columnIndex >= 0 && columnIndex <= map.width) {
       return cloneTr(addColumn(tr, {
         map,
@@ -17,6 +16,5 @@ export const addColumnAt = columnIndex => tr => {
       }, columnIndex));
     }
   }
-
   return tr;
 };

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

@@ -2,65 +2,55 @@ import { addColSpan, assertColspan } from './colspan';
 import { tableNodeTypes } from './table-node-types';
 export function columnIsHeader(map, table, col) {
   const headerCell = tableNodeTypes(table.type.schema).header_cell;
-
   for (let row = 0; row < map.height; row++) {
     const 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, {
   map,
   tableStart,
   table
 }, col) {
   let refColumn = col > 0 ? -1 : 0;
-
   if (columnIsHeader(map, table, col + refColumn)) {
     refColumn = col === 0 || col === map.width ? null : 0;
   }
-
   for (let row = 0; row < map.height; row++) {
-    const index = row * map.width + col; // If this position falls inside a col-spanning cell
+    const 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]) {
       const pos = map.map[index];
       const cell = table.nodeAt(pos);
-
       if (!cell) {
         throw new Error(`addColumn: invalid cell for pos ${pos}`);
       }
-
       const 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 {
       let type;
-
       if (refColumn === null) {
         type = tableNodeTypes(table.type.schema).cell;
       } else {
         const mappedPos = map.map[index + refColumn];
         const cell = table.nodeAt(mappedPos);
-
         if (!cell) {
           throw new Error(`addColumn: invalid node at mapped pos ${mappedPos}`);
         }
-
         type = cell.type;
       }
-
       const pos = map.positionAt(row, col, table);
       tr.insert(tr.mapping.map(tableStart + pos), type.createAndFill());
     }
   }
-
   return tr;
 }