@atlaskit/editor-tables 2.2.4 → 2.2.6

package/dist/es2019/cell-selection.js

@@ -1,8 +1,10 @@
 // Was copied from https://github.com/ProseMirror/prosemirror-tables/blob/master/src/cellselection.js
+
 // This file defines a ProseMirror selection subclass that models
 // table cell selections. The table plugin needs to be active to wire
 // in the user interaction part of table selections (so that you
 // actually get such selections when you select across cells).
+
 import { Fragment, Slice } from 'prosemirror-model';
 import { Selection, TextSelection } from 'prosemirror-state';
 import { CellBookmark } from './cell-bookmark';
@@ -10,56 +12,52 @@ import { TableMap } from './table-map';
 import { pointsAtCell } from './utils/cells';
 import { removeColSpan } from './utils/colspan';
 import { getCellSelectionRanges } from './utils/get-cell-selection-ranges';
-import { inSameTable } from './utils/tables'; // ::- A [`Selection`](http://prosemirror.net/docs/ref/#state.Selection)
+import { inSameTable } from './utils/tables';
+
+// ::- A [`Selection`](http://prosemirror.net/docs/ref/#state.Selection)
 // subclass that represents a cell selection spanning part of a table.
 // With the plugin enabled, these will be created when the user
 // selects across cells, and will be drawn by giving selected cells a
 // `selectedCell` CSS class.
-
 export class CellSelection extends Selection {
   // :: (ResolvedPos, ?ResolvedPos)
   // A table selection is identified by its anchor and head cells. The
   // positions given to this constructor should point _before_ two
   // cells in the same table. They may be the same, to select a single
   // cell.
+
   constructor($anchorCell, $headCell = $anchorCell) {
     const ranges = getCellSelectionRanges($anchorCell, $headCell);
-    super(ranges[0].$from, ranges[0].$to, ranges); // :: ResolvedPos
+    super(ranges[0].$from, ranges[0].$to, ranges);
+    // :: ResolvedPos
     // A resolved position pointing _in front of_ the anchor cell (the one
     // that doesn't move when extending the selection).
-
-    this.$anchorCell = $anchorCell; // :: ResolvedPos
+    this.$anchorCell = $anchorCell;
+    // :: ResolvedPos
     // A resolved position pointing in front of the head cell (the one
     // moves when extending the selection).
-
     this.$headCell = $headCell;
     this.visible = false;
   }
-
   map(doc, mapping) {
     const $anchorCell = doc.resolve(mapping.map(this.$anchorCell.pos));
     const $headCell = doc.resolve(mapping.map(this.$headCell.pos));
-
     if (pointsAtCell($anchorCell) && pointsAtCell($headCell) && inSameTable($anchorCell, $headCell)) {
       const tableChanged = this.$anchorCell.node(-1) !== $anchorCell.node(-1);
-
       if (tableChanged && this.isRowSelection()) {
         return CellSelection.rowSelection($anchorCell, $headCell);
       }
-
       if (tableChanged && this.isColSelection()) {
         return CellSelection.colSelection($anchorCell, $headCell);
       }
-
       return new CellSelection($anchorCell, $headCell);
     }
-
     return TextSelection.between($anchorCell, $headCell);
-  } // :: () → Slice
+  }
+
+  // :: () → Slice
   // Returns a rectangular slice of table rows containing the selected
   // cells.
-
-
   content() {
     const table = this.$anchorCell.node(-1);
     const map = TableMap.get(table);
@@ -67,86 +65,68 @@ export class CellSelection extends Selection {
     const rect = map.rectBetween(this.$anchorCell.pos - start, this.$headCell.pos - start);
     const seen = {};
     const rows = [];
-
     for (let row = rect.top; row < rect.bottom; row++) {
       const rowContent = [];
-
       for (let index = row * map.width + rect.left, col = rect.left; col < rect.right; col++, index++) {
         const pos = map.map[index];
-
         if (!seen[pos]) {
           seen[pos] = true;
           const cellRect = map.findCell(pos);
           let cell = table.nodeAt(pos);
-
           if (cell === null || cell === undefined) {
             throw new Error(`No cell at position ${pos}`);
           }
-
           const extraLeft = rect.left - cellRect.left;
           const extraRight = cellRect.right - rect.right;
-
           if (extraLeft > 0 || extraRight > 0) {
             let {
               attrs
             } = cell;
-
             if (!attrs) {
               throw new Error(`No cell at position ${pos}`);
             }
-
             if (extraLeft > 0) {
               attrs = removeColSpan(attrs, 0, extraLeft);
             }
-
             if (extraRight > 0) {
               attrs = removeColSpan(attrs, attrs.colspan - extraRight, extraRight);
             }
-
             if (cellRect.left < rect.left) {
               cell = cell.type.createAndFill(attrs);
             } else {
               cell = cell.type.create(attrs, cell.content);
             }
           }
-
           if (cell === null || cell === undefined) {
             throw new Error(`No cell at position after create/createAndFill`);
           }
-
           if (cellRect.top < rect.top || cellRect.bottom > rect.bottom) {
-            const attrs = { ...cell.attrs,
+            const attrs = {
+              ...cell.attrs,
               rowspan: Math.min(cellRect.bottom, rect.bottom) - Math.max(cellRect.top, rect.top)
             };
-
             if (cellRect.top < rect.top) {
               cell = cell.type.createAndFill(attrs);
             } else {
               cell = cell.type.create(attrs, cell.content);
             }
           }
-
           if (cell === null || cell === undefined) {
             throw new Error(`No cell at position before rowContent.push`);
           }
-
           rowContent.push(cell);
         }
       }
-
       rows.push(table.child(row).copy(Fragment.from(rowContent)));
     }
-
     const fragment = this.isColSelection() && this.isRowSelection() ? table : rows;
     return new Slice(Fragment.from(fragment), 1, 1);
   }
-
   replace(tr, content = Slice.empty) {
     const mapFrom = tr.steps.length;
     const {
       ranges
     } = this;
-
     for (let i = 0; i < ranges.length; i++) {
       const {
         $from,
@@ -155,58 +135,48 @@ export class CellSelection extends Selection {
       const mapping = tr.mapping.slice(mapFrom);
       tr.replace(mapping.map($from.pos), mapping.map($to.pos), i ? Slice.empty : content);
     }
-
     const sel = Selection.findFrom(tr.doc.resolve(tr.mapping.slice(mapFrom).map(this.to)), -1);
-
     if (sel) {
       tr.setSelection(sel);
     }
   }
-
   replaceWith(tr, node) {
     this.replace(tr, new Slice(Fragment.from(node), 0, 0));
   }
-
   forEachCell(f) {
     const table = this.$anchorCell.node(-1);
     const map = TableMap.get(table);
     const start = this.$anchorCell.start(-1);
     const cells = map.cellsInRect(map.rectBetween(this.$anchorCell.pos - start, this.$headCell.pos - start));
-
     for (let i = 0; i < cells.length; i++) {
       const cell = table.nodeAt(cells[i]);
-
       if (cell === null || cell === undefined) {
         throw new Error(`undefined cell at pos ${cells[i]}`);
       }
-
       f(cell, start + cells[i]);
     }
-  } // :: () → bool
+  }
+
+  // :: () → bool
   // True if this selection goes all the way from the top to the
   // bottom of the table.
-
-
   isColSelection() {
     if (!this.$anchorCell || !this.$headCell) {
       throw new Error('invalid $anchorCell or $headCell');
     }
-
     const anchorTop = this.$anchorCell.index(-1);
     const headTop = this.$headCell.index(-1);
-
     if (Math.min(anchorTop, headTop) > 0) {
       return false;
     }
-
     const anchorBot = anchorTop + this.$anchorCell.nodeAfter.attrs.rowspan;
     const headBot = headTop + this.$headCell.nodeAfter.attrs.rowspan;
     return Math.max(anchorBot, headBot) === this.$headCell.node(-1).childCount;
-  } // :: (ResolvedPos, ?ResolvedPos) → CellSelection
+  }
+
+  // :: (ResolvedPos, ?ResolvedPos) → CellSelection
   // Returns the smallest column selection that covers the given anchor
   // and head cell.
-
-
   static colSelection($anchorCell, $headCell = $anchorCell) {
     let $calculatedAnchorCell = $anchorCell;
     let $calculatedHeadCell = $headCell;
@@ -215,12 +185,10 @@ export class CellSelection extends Selection {
     const anchorRect = map.findCell($calculatedAnchorCell.pos - start);
     const headRect = map.findCell($calculatedHeadCell.pos - start);
     const doc = $calculatedAnchorCell.node(0);
-
     if (anchorRect.top <= headRect.top) {
       if (anchorRect.top > 0) {
         $calculatedAnchorCell = doc.resolve(start + map.map[anchorRect.left]);
       }
-
       if (headRect.bottom < map.height) {
         $calculatedHeadCell = doc.resolve(start + map.map[map.width * (map.height - 1) + headRect.right - 1]);
       }
@@ -228,59 +196,55 @@ export class CellSelection extends Selection {
       if (headRect.top > 0) {
         $calculatedHeadCell = doc.resolve(start + map.map[headRect.left]);
       }
-
       if (anchorRect.bottom < map.height) {
         $calculatedAnchorCell = doc.resolve(start + map.map[map.width * (map.height - 1) + anchorRect.right - 1]);
       }
     }
-
     return new CellSelection($calculatedAnchorCell, $calculatedHeadCell);
-  } // :: () → bool
+  }
+
+  // :: () → bool
   // True if this selection goes all the way from the left to the
   // right of the table.
-
-
   isRowSelection() {
     if (!this.$anchorCell || !this.$headCell) {
       return false;
     }
-
     const start = this.$anchorCell.start(-1);
     const map = TableMap.get(this.$anchorCell.node(-1));
     const rowAtAnchorCell = map.rowCount(this.$anchorCell.pos - start);
     const rowAtHeadCell = map.rowCount(this.$headCell.pos - start);
-    const isSelectionSameRow = rowAtAnchorCell === rowAtHeadCell; // if anchor and head in the same line, counting how many cells
+    const isSelectionSameRow = rowAtAnchorCell === rowAtHeadCell;
+
+    // if anchor and head in the same line, counting how many cells
     // should be in the row except merged cell
+    let maxColumnInSelectedRow = map.getMaxColInRow(this.$anchorCell);
 
-    let maxColumnInSelectedRow = map.getMaxColInRow(this.$anchorCell); // if selected cells less than table max column amount, and
+    // if selected cells less than table max column amount, and
     // the anchor/head not in a merged cell
     // it should be select maxColumnInSelectedRow to be TRUE
-
     if (isSelectionSameRow && this.ranges.length <= map.width && !map.isPosMerged(this.$anchorCell.pos - start) && !map.isPosMerged(this.$headCell.pos - start)) {
       return this.ranges.length === maxColumnInSelectedRow;
-    } // If anchor and head in different row, it should be always in first and
-    // last column to select the whole row.
-
+    }
 
+    // If anchor and head in different row, it should be always in first and
+    // last column to select the whole row.
     const anchorLeft = map.colCount(this.$anchorCell.pos - start);
     const headLeft = map.colCount(this.$headCell.pos - start);
-
     if (Math.min(anchorLeft, headLeft) > 0) {
       return false;
     }
-
     const anchorRight = anchorLeft + this.$anchorCell.nodeAfter.attrs.colspan;
     const headRight = headLeft + this.$headCell.nodeAfter.attrs.colspan;
     return Math.max(anchorRight, headRight) === map.width;
   }
-
   eq(other) {
     return other instanceof CellSelection && other.$anchorCell.pos === this.$anchorCell.pos && other.$headCell.pos === this.$headCell.pos;
-  } // :: (ResolvedPos, ?ResolvedPos) → CellSelection
+  }
+
+  // :: (ResolvedPos, ?ResolvedPos) → CellSelection
   // Returns the smallest row selection that covers the given anchor
   // and head cell.
-
-
   static rowSelection($anchorCell, $headCell = $anchorCell) {
     let $calculatedAnchorCell = $anchorCell;
     let $calculatedHeadCell = $headCell;
@@ -289,12 +253,10 @@ export class CellSelection extends Selection {
     const anchorRect = map.findCell($calculatedAnchorCell.pos - start);
     const headRect = map.findCell($calculatedHeadCell.pos - start);
     const doc = $calculatedAnchorCell.node(0);
-
     if (anchorRect.left <= headRect.left) {
       if (anchorRect.left > 0) {
         $calculatedAnchorCell = doc.resolve(start + map.map[anchorRect.top * map.width]);
       }
-
       if (headRect.right < map.width) {
         $calculatedHeadCell = doc.resolve(start + map.map[map.width * (headRect.top + 1) - 1]);
       }
@@ -302,15 +264,12 @@ export class CellSelection extends Selection {
       if (headRect.left > 0) {
         $calculatedHeadCell = doc.resolve(start + map.map[headRect.top * map.width]);
       }
-
       if (anchorRect.right < map.width) {
         $calculatedAnchorCell = doc.resolve(start + map.map[map.width * (anchorRect.top + 1) - 1]);
       }
     }
-
     return new CellSelection($calculatedAnchorCell, $calculatedHeadCell);
   }
-
   toJSON() {
     return {
       type: 'cell',
@@ -318,19 +277,16 @@ export class CellSelection extends Selection {
       head: this.$headCell.pos
     };
   }
-
   static fromJSON(doc, json) {
     return new CellSelection(doc.resolve(json.anchor), doc.resolve(json.head));
-  } // :: (Node, number, ?number) → CellSelection
-
+  }
 
+  // :: (Node, number, ?number) → CellSelection
   static create(doc, anchorCell, headCell = anchorCell) {
     return new CellSelection(doc.resolve(anchorCell), doc.resolve(headCell));
   }
-
   getBookmark() {
     return new CellBookmark(this.$anchorCell.pos, this.$headCell.pos);
   }
-
 }
 Selection.jsonID('cell', CellSelection);

package/dist/es2019/index.js

@@ -21,6 +21,7 @@
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   THE SOFTWARE.
  */
+
 export { TableMap, Rect } from './table-map';
 export { CellSelection } from './cell-selection';
 export { findTable } from './utils/find';

package/dist/es2019/pm-plugins/input.js

@@ -1,5 +1,6 @@
 // This file defines a number of helpers for wiring up user input to
 // table-related functionality.
+
 import { keydownHandler } from 'prosemirror-keymap';
 import { Slice } from 'prosemirror-model';
 import { Selection, TextSelection } from 'prosemirror-state';
@@ -22,46 +23,35 @@ export const handleKeyDown = keydownHandler({
   Delete: deleteCellSelection,
   'Mod-Delete': deleteCellSelection
 });
-
 function maybeSetSelection(state, dispatch, selection) {
   if (selection.eq(state.selection)) {
     return false;
   }
-
   if (dispatch) {
     dispatch(state.tr.setSelection(selection).scrollIntoView());
   }
-
   return true;
 }
-
 function arrow(axis, dir) {
   return (state, dispatch, view) => {
     if (dispatch) {
       const sel = state.selection;
-
       if (sel instanceof CellSelection) {
         return maybeSetSelection(state, dispatch, Selection.near(sel.$headCell, dir));
       }
-
       if (axis !== 'horiz' && !sel.empty) {
         return false;
       }
-
       const end = view ? atEndOfCell(view, axis, dir) : null;
-
       if (end === null) {
         return false;
       }
-
       if (axis === 'horiz') {
         return maybeSetSelection(state, dispatch, Selection.near(state.doc.resolve(sel.head + dir), dir));
       }
-
       const $cell = state.doc.resolve(end);
       const $next = nextCell($cell, axis, dir);
       let newSel;
-
       if ($next) {
         newSel = Selection.near($next, 1);
       } else if (dir < 0) {
@@ -69,65 +59,50 @@ function arrow(axis, dir) {
       } else {
         newSel = Selection.near(state.doc.resolve($cell.after(-1)), 1);
       }
-
       return maybeSetSelection(state, dispatch, newSel);
     }
-
     return true;
   };
 }
-
 function shiftArrow(axis, dir) {
   return (state, dispatch, view) => {
     let sel = state.selection;
-
     if (!(sel instanceof CellSelection)) {
       var _maybeTableCell$paren;
-
       const end = view ? atEndOfCell(view, axis, dir) : null;
-
       if (end === null) {
         return false;
       }
-
       const {
         selection: {
           $head,
           $anchor
         }
       } = state;
-      const maybeTableCell = $head.blockRange($anchor); // Make sure the selection is coming from the same cell
+      const maybeTableCell = $head.blockRange($anchor);
 
+      // Make sure the selection is coming from the same cell
       const sameCell = ['tableCell', 'tableHeader'].includes((maybeTableCell === null || maybeTableCell === void 0 ? void 0 : (_maybeTableCell$paren = maybeTableCell.parent) === null || _maybeTableCell$paren === void 0 ? void 0 : _maybeTableCell$paren.type.name) || '');
-
       if (!sameCell) {
         return false;
       }
-
       sel = new CellSelection(state.doc.resolve(end));
     }
-
     const $head = nextCell(sel.$headCell, axis, dir);
-
     if (!$head) {
       return false;
     }
-
     if (dispatch) {
       return maybeSetSelection(state, dispatch, new CellSelection(sel.$anchorCell, $head));
     }
-
     return true;
   };
 }
-
 function deleteCellSelection(state, dispatch) {
   const sel = state.selection;
-
   if (!(sel instanceof CellSelection)) {
     return false;
   }
-
   if (dispatch) {
     const {
       tr
@@ -138,39 +113,32 @@ function deleteCellSelection(state, dispatch) {
         tr.replace(tr.mapping.map(pos + 1), tr.mapping.map(pos + cell.nodeSize - 1), new Slice(baseContent, 0, 0));
       }
     });
-
     if (tr.docChanged) {
       dispatch(tr);
     }
   }
-
   return true;
 }
-
 export function handleTripleClick(view, pos) {
   const {
     doc
   } = view.state;
   const $cell = cellAround(doc.resolve(pos));
-
   if (!$cell) {
     return false;
   }
-
   view.dispatch(view.state.tr.setSelection(new CellSelection($cell)));
   return true;
 }
 export function handleMouseDown(view, event) {
-  const startEvent = event; // Prevent right clicks from making a cell selection https://product-fabric.atlassian.net/browse/ED-12527
-
+  const startEvent = event;
+  // Prevent right clicks from making a cell selection https://product-fabric.atlassian.net/browse/ED-12527
   if (startEvent.ctrlKey || startEvent.metaKey || startEvent.button === 2 // right mouse click
   ) {
     return false;
   }
-
   const startDOMCell = domInCell(view, startEvent.target);
   const $anchor = cellAround(view.state.selection.$anchor);
-
   if (startEvent.shiftKey && view.state.selection instanceof CellSelection) {
     // Adding to an existing cell selection
     setCellSelection(view.state.selection.$anchorCell, startEvent);
@@ -183,14 +151,13 @@ export function handleMouseDown(view, event) {
   } else if (!startDOMCell) {
     // Not in a cell, let the default behavior happen.
     return false;
-  } // Create and dispatch a cell selection between the given anchor and
-  // the position under the mouse.
-
+  }
 
+  // Create and dispatch a cell selection between the given anchor and
+  // the position under the mouse.
   function setCellSelection($selectionAnchor, event) {
     let $head = cellUnderMouse(view, event);
     const starting = tableEditingKey.getState(view.state) == null;
-
     if (!$head || !inSameTable($selectionAnchor, $head)) {
       if (starting) {
         $head = $selectionAnchor;
@@ -198,109 +165,90 @@ export function handleMouseDown(view, event) {
         return false;
       }
     }
-
     const selection = new CellSelection($selectionAnchor, $head);
-
     if (starting || !view.state.selection.eq(selection)) {
       const tr = view.state.tr.setSelection(selection);
-
       if (starting) {
         tr.setMeta(tableEditingKey, $selectionAnchor.pos);
       }
-
       view.dispatch(tr);
     }
-  } // Stop listening to mouse motion events.
-
+  }
 
+  // Stop listening to mouse motion events.
   function stop() {
     view.root.removeEventListener('mouseup', stop);
     view.root.removeEventListener('dragstart', stop);
     view.root.removeEventListener('mousemove', move);
-
     if (tableEditingKey.getState(view.state) != null) {
       view.dispatch(view.state.tr.setMeta(tableEditingKey, -1));
     }
   }
-
   function move(event) {
     const anchor = tableEditingKey.getState(view.state);
     let $moveAnchor;
-
     if (anchor != null) {
       // Continuing an existing cross-cell selection
       $moveAnchor = view.state.doc.resolve(anchor);
     } else if (domInCell(view, event.target) !== startDOMCell) {
       // Moving out of the initial cell -- start a new cell selection
       $moveAnchor = cellUnderMouse(view, startEvent);
-
       if (!$moveAnchor) {
         stop();
         return;
       }
     }
-
     if ($moveAnchor) {
       setCellSelection($moveAnchor, event);
     }
   }
-
   view.root.addEventListener('mouseup', stop);
   view.root.addEventListener('dragstart', stop);
   view.root.addEventListener('mousemove', move);
   return false;
-} // Check whether the cursor is at the end of a cell (so that further
-// motion would move out of the cell)
+}
 
+// Check whether the cursor is at the end of a cell (so that further
+// motion would move out of the cell)
 function atEndOfCell(view, axis, dir) {
   if (!(view.state.selection instanceof TextSelection)) {
     return null;
   }
-
   const {
     $head
   } = view.state.selection;
-
   for (let d = $head.depth - 1; d >= 0; d--) {
     const parent = $head.node(d);
     const index = dir < 0 ? $head.index(d) : $head.indexAfter(d);
-
     if (index !== (dir < 0 ? 0 : parent.childCount)) {
       return null;
     }
-
     if (parent.type.spec.tableRole === 'cell' || parent.type.spec.tableRole === 'header_cell') {
       const cellPos = $head.before(d);
-      const dirStr = // eslint-disable-next-line no-nested-ternary
+      const dirStr =
+      // eslint-disable-next-line no-nested-ternary
       axis === 'vert' ? dir > 0 ? 'down' : 'up' : dir > 0 ? 'right' : 'left';
       return view.endOfTextblock(dirStr) ? cellPos : null;
     }
   }
-
   return null;
 }
-
 function domInCell(view, inputDom) {
   let dom = inputDom;
-
   for (; dom && dom !== view.dom; dom = dom.parentNode) {
     if (dom.nodeName === 'TD' || dom.nodeName === 'TH') {
       return dom;
     }
   }
-
   return null;
 }
-
 function cellUnderMouse(view, event) {
   const mousePos = view.posAtCoords({
     left: event.clientX,
     top: event.clientY
   });
-
   if (!mousePos) {
     return null;
   }
-
   return cellAround(view.state.doc.resolve(mousePos.pos));
 }