@atlaskit/editor-tables 2.2.4 → 2.2.6

package/dist/es2019/utils/fix-tables.js

@@ -2,7 +2,6 @@ import { fixTablesKey } from '../pm-plugins/plugin-key';
 import { TableMap, TableProblemTypes } from '../table-map';
 import { removeColSpan } from './colspan';
 import { tableNodeTypes } from './table-node-types';
-
 // Helper for iterating through the nodes in a document that changed
 // compared to the given previous document. Useful for avoiding
 // duplicate work on each transaction.
@@ -10,80 +9,68 @@ function changedDescendants(old, cur, offsetStart, f) {
   let offset = offsetStart;
   const oldSize = old.childCount;
   const curSize = cur.childCount;
-
   outer: for (let i = 0, j = 0; i < curSize; i++) {
     const child = cur.child(i);
-
     for (let scan = j, e = Math.min(oldSize, i + 3); scan < e; scan++) {
       if (old.child(scan) === child) {
         j = scan + 1;
-        offset += child.nodeSize; // eslint-disable-next-line no-continue
-
+        offset += child.nodeSize;
+        // eslint-disable-next-line no-continue
         continue outer;
       }
     }
-
     f(child, offset);
-
     if (j < oldSize && old.child(j).sameMarkup(child)) {
       changedDescendants(old.child(j), child, offset + 1, f);
     } else {
       child.nodesBetween(0, child.content.size, f, offset + 1);
     }
-
     offset += child.nodeSize;
   }
-} // :: (EditorState, ?EditorState) → ?Transaction
+}
+
+// :: (EditorState, ?EditorState) → ?Transaction
 // Inspect all tables in the given state's document and return a
 // transaction that fixes them, if necessary. If `oldState` was
 // provided, that is assumed to hold a previous, known-good state,
 // which will be used to avoid re-scanning unchanged parts of the
 // document.
-
-
 export function fixTables(state, oldState, reportFixedTable) {
   let tr;
-
   const check = (node, pos) => {
     if (node.type.spec.tableRole === 'table') {
       tr = fixTable(state, node, pos, tr, reportFixedTable);
     }
   };
-
   if (!oldState) {
     state.doc.descendants(check);
   } else if (oldState.doc !== state.doc) {
     changedDescendants(oldState.doc, state.doc, 0, check);
   }
-
   return tr;
-} // : (EditorState, Node, number, ?Transaction) → ?Transaction
+}
+
+// : (EditorState, Node, number, ?Transaction) → ?Transaction
 // Fix the given table, if necessary. Will append to the transaction
 // it was given, if non-null, or create a new one if necessary.
-
 export function fixTable(state, table, tablePos, transaction, reportFixedTable) {
   let tr = transaction;
   const map = TableMap.get(table);
-
   if (!map.problems) {
     return tr;
   }
-
   if (!tr) {
     tr = state.tr;
-  } // Track which rows we must add cells to, so that we can adjust that
-  // when fixing collisions.
-
+  }
 
+  // Track which rows we must add cells to, so that we can adjust that
+  // when fixing collisions.
   const mustAdd = [];
-
   for (let i = 0; i < map.height; i++) {
     mustAdd.push(0);
   }
-
   for (let i = 0; i < map.problems.length; i++) {
     const prob = map.problems[i];
-
     if (reportFixedTable) {
       reportFixedTable({
         state,
@@ -91,19 +78,15 @@ export function fixTable(state, table, tablePos, transaction, reportFixedTable)
         reason: prob.type || 'unknown'
       });
     }
-
     if (prob.type === TableProblemTypes.COLLISION) {
       const collision = prob;
       const cell = table.nodeAt(prob.pos);
-
       if (!cell) {
         throw new Error(`fixTable: unable to find cell at pos ${prob.pos}`);
       }
-
       for (let j = 0; j < cell.attrs.rowspan; j++) {
         mustAdd[collision.row + j] += collision.n;
       }
-
       tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + prob.pos), undefined, removeColSpan(cell.attrs, cell.attrs.colspan - collision.n, collision.n));
     } else if (prob.type === TableProblemTypes.MISSING) {
       const missing = prob;
@@ -111,69 +94,56 @@ export function fixTable(state, table, tablePos, transaction, reportFixedTable)
     } else if (prob.type === TableProblemTypes.OVERLONG_ROWSPAN) {
       const overlong = prob;
       const cell = table.nodeAt(overlong.pos);
-
       if (!cell) {
         throw new Error(`fixTable: unable to find cell at pos ${prob.pos}`);
       }
-
-      tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + overlong.pos), undefined, { ...cell.attrs,
+      tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + overlong.pos), undefined, {
+        ...cell.attrs,
         rowspan: cell.attrs.rowspan - overlong.n
       });
     } else if (prob.type === TableProblemTypes.COLWIDTH_MISMATCH) {
       const cell = table.nodeAt(prob.pos);
-
       if (!cell) {
         throw new Error(`fixTable: unable to find cell at pos ${prob.pos}`);
       }
-
-      tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + prob.pos), undefined, { ...cell.attrs,
+      tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + prob.pos), undefined, {
+        ...cell.attrs,
         colwidth: prob.colwidth
       });
     }
   }
-
   let first;
   let last;
-
   for (let i = 0; i < mustAdd.length; i++) {
     if (mustAdd[i]) {
       if (first == null) {
         first = i;
       }
-
       last = i;
     }
-  } // Add the necessary cells, using a heuristic for whether to add the
+  }
+  // Add the necessary cells, using a heuristic for whether to add the
   // cells at the start or end of the rows (if it looks like a 'bite'
   // was taken out of the table, add cells at the start of the row
   // after the bite. Otherwise add them at the end).
-
-
   for (let i = 0, pos = tablePos + 1; i < map.height; i++) {
     const row = table.child(i);
     const end = pos + row.nodeSize;
     const add = mustAdd[i];
-
     if (add > 0) {
       let tableNodeType = 'cell';
-
       if (row.firstChild) {
         tableNodeType = row.firstChild.type.spec.tableRole;
       }
-
       const nodes = [];
-
       for (let j = 0; j < add; j++) {
         nodes.push(tableNodeTypes(state.schema)[tableNodeType].createAndFill());
       }
-
       const side = (i === 0 || first === i - 1) && last === i ? pos + 1 : end - 1;
       tr.insert(tr.mapping.map(side), nodes);
     }
-
     pos = end;
   }
-
   return tr.setMeta(fixTablesKey, {
     fixTables: true
   });

package/dist/es2019/utils/for-each-cell.js

@@ -1,42 +1,37 @@
 import { Selection } from 'prosemirror-state';
 import { cloneTr } from './clone-tr';
 import { getCellsInColumn } from './get-cells-in-column';
-import { getCellsInRow } from './get-cells-in-row'; // Returns a new transaction that maps a given `cellTransform` function to each cell in a column at a given `columnIndex`.
-// It will set the selection into the last cell of the column if `setCursorToLastCell` param is set to `true`.
+import { getCellsInRow } from './get-cells-in-row';
 
+// Returns a new transaction that maps a given `cellTransform` function to each cell in a column at a given `columnIndex`.
+// It will set the selection into the last cell of the column if `setCursorToLastCell` param is set to `true`.
 export const forEachCellInColumn = (columnIndex, cellTransform, setCursorToLastCell) => tr => {
   const cells = getCellsInColumn(columnIndex)(tr.selection);
-
   if (cells) {
     for (let i = cells.length - 1; i >= 0; i--) {
       tr = cellTransform(cells[i], tr);
     }
-
     if (setCursorToLastCell) {
       const $pos = tr.doc.resolve(tr.mapping.map(cells[cells.length - 1].pos));
       tr.setSelection(Selection.near($pos));
     }
-
     return cloneTr(tr);
   }
-
   return tr;
-}; // Returns a new transaction that maps a given `cellTransform` function to each cell in a row at a given `rowIndex`.
-// It will set the selection into the last cell of the row if `setCursorToLastCell` param is set to `true`.
+};
 
+// Returns a new transaction that maps a given `cellTransform` function to each cell in a row at a given `rowIndex`.
+// It will set the selection into the last cell of the row if `setCursorToLastCell` param is set to `true`.
 export const forEachCellInRow = (rowIndex, cellTransform, setCursorToLastCell) => tr => {
   const cells = getCellsInRow(rowIndex)(tr.selection);
-
   if (cells) {
     for (let i = cells.length - 1; i >= 0; i--) {
       tr = cellTransform(cells[i], tr);
     }
-
     if (setCursorToLastCell) {
       const $pos = tr.doc.resolve(tr.mapping.map(cells[cells.length - 1].pos));
       tr.setSelection(Selection.near($pos));
     }
   }
-
   return tr;
 };

package/dist/es2019/utils/get-cell-selection-ranges.js

@@ -6,17 +6,15 @@ export function getCellSelectionRanges($anchorCell, $headCell) {
   const start = $anchorCell.start(-1);
   const rect = map.rectBetween($anchorCell.pos - start, $headCell.pos - start);
   const doc = $anchorCell.node(0);
-  const cells = map.cellsInRect(rect).filter(p => p !== $headCell.pos - start); // Make the head cell the first range, so that it counts as the
+  const cells = map.cellsInRect(rect).filter(p => p !== $headCell.pos - start);
+  // Make the head cell the first range, so that it counts as the
   // primary part of the selection
-
   cells.unshift($headCell.pos - start);
   return cells.map(pos => {
     const cell = table.nodeAt(pos);
-
     if (cell === null) {
       throw new Error(`No cell at position ${pos}`);
     }
-
     const from = pos + start + 1;
     return new SelectionRange(doc.resolve(from), doc.resolve(from + cell.content.size));
   });

package/dist/es2019/utils/get-cells-in-column.js

@@ -1,13 +1,12 @@
 import { TableMap } from '../table-map';
-import { findTable } from './find'; // Returns an array of cells in a column(s), where `columnIndex` could be a column index or an array of column indexes.
+import { findTable } from './find';
 
+// Returns an array of cells in a column(s), where `columnIndex` could be a column index or an array of column indexes.
 export const getCellsInColumn = columnIndexes => selection => {
   const table = findTable(selection);
-
   if (!table) {
     return;
   }
-
   const map = TableMap.get(table.node);
   const indexes = Array.isArray(columnIndexes) ? columnIndexes : [columnIndexes];
   return indexes.filter(index => index >= 0 && index <= map.width - 1).reduce((acc, index) => {

package/dist/es2019/utils/get-cells-in-row.js

@@ -1,13 +1,12 @@
 import { TableMap } from '../table-map';
-import { findTable } from './find'; // Returns an array of cells in a row(s), where `rowIndex` could be a row index or an array of row indexes.
+import { findTable } from './find';
 
+// Returns an array of cells in a row(s), where `rowIndex` could be a row index or an array of row indexes.
 export const getCellsInRow = rowIndex => selection => {
   const table = findTable(selection);
-
   if (!table) {
     return;
   }
-
   const map = TableMap.get(table.node);
   const indexes = Array.isArray(rowIndex) ? rowIndex : [rowIndex];
   return indexes.filter(index => index >= 0 && index <= map.height - 1).reduce((acc, index) => {

package/dist/es2019/utils/get-cells-in-table.js

@@ -1,13 +1,12 @@
 import { TableMap } from '../table-map';
-import { findTable } from './find'; // Returns an array of all cells in a table.
+import { findTable } from './find';
 
+// Returns an array of all cells in a table.
 export const getCellsInTable = selection => {
   const table = findTable(selection);
-
   if (!table) {
     return;
   }
-
   const map = TableMap.get(table.node);
   const positions = map.cellsInRect({
     left: 0,
@@ -17,7 +16,6 @@ export const getCellsInTable = selection => {
   });
   return positions.map(cellPos => {
     const node = table.node.nodeAt(cellPos);
-
     if (node) {
       const pos = cellPos + table.start;
       return {

package/dist/es2019/utils/get-selection-range-in-column.js

@@ -1,69 +1,58 @@
 import { getCellsInColumn } from './get-cells-in-column';
-import { getCellsInRow } from './get-cells-in-row'; // Returns a range of rectangular selection spanning all merged cells around a column at index `columnIndex`.
+import { getCellsInRow } from './get-cells-in-row';
 
+// Returns a range of rectangular selection spanning all merged cells around a column at index `columnIndex`.
 export const getSelectionRangeInColumn = columnIndex => tr => {
   let startIndex = columnIndex;
-  let endIndex = columnIndex; // looking for selection start column (startIndex)
+  let endIndex = columnIndex;
 
+  // looking for selection start column (startIndex)
   for (let i = columnIndex; i >= 0; i--) {
     const cells = getCellsInColumn(i)(tr.selection);
-
     if (cells) {
       cells.forEach(cell => {
         let maybeEndIndex = cell.node.attrs.colspan + i - 1;
-
         if (maybeEndIndex >= startIndex) {
           startIndex = i;
         }
-
         if (maybeEndIndex > endIndex) {
           endIndex = maybeEndIndex;
         }
       });
     }
-  } // looking for selection end column (endIndex)
-
-
+  }
+  // looking for selection end column (endIndex)
   for (let i = columnIndex; i <= endIndex; i++) {
     const cells = getCellsInColumn(i)(tr.selection);
-
     if (cells) {
       cells.forEach(cell => {
         let maybeEndIndex = cell.node.attrs.colspan + i - 1;
-
         if (cell.node.attrs.colspan > 1 && maybeEndIndex > endIndex) {
           endIndex = maybeEndIndex;
         }
       });
     }
-  } // filter out columns without cells (where all rows have colspan > 1 in the same column)
-
+  }
 
+  // filter out columns without cells (where all rows have colspan > 1 in the same column)
   const indexes = [];
-
   for (let i = startIndex; i <= endIndex; i++) {
     const maybeCells = getCellsInColumn(i)(tr.selection);
-
     if (maybeCells && maybeCells.length) {
       indexes.push(i);
     }
   }
-
   startIndex = indexes[0];
   endIndex = indexes[indexes.length - 1];
   const firstSelectedColumnCells = getCellsInColumn(startIndex)(tr.selection);
   const firstRowCells = getCellsInRow(0)(tr.selection);
-
   if (!firstSelectedColumnCells || !firstRowCells) {
     return;
   }
-
   const $anchor = tr.doc.resolve(firstSelectedColumnCells[firstSelectedColumnCells.length - 1].pos);
   let headCell;
-
   for (let i = endIndex; i >= startIndex; i--) {
     const columnCells = getCellsInColumn(i)(tr.selection);
-
     if (columnCells && columnCells.length) {
       for (let j = firstRowCells.length - 1; j >= 0; j--) {
         if (firstRowCells[j].pos === columnCells[0].pos) {
@@ -71,17 +60,14 @@ export const getSelectionRangeInColumn = columnIndex => tr => {
           break;
         }
       }
-
       if (headCell) {
         break;
       }
     }
   }
-
   if (!headCell) {
     return;
   }
-
   const $head = tr.doc.resolve(headCell.pos);
   return {
     $anchor,

package/dist/es2019/utils/get-selection-range-in-row.js

@@ -1,69 +1,58 @@
 import { getCellsInColumn } from './get-cells-in-column';
-import { getCellsInRow } from './get-cells-in-row'; // Returns a range of rectangular selection spanning all merged cells around a row at index `rowIndex`.
+import { getCellsInRow } from './get-cells-in-row';
 
+// Returns a range of rectangular selection spanning all merged cells around a row at index `rowIndex`.
 export const getSelectionRangeInRow = rowIndex => tr => {
   let startIndex = rowIndex;
-  let endIndex = rowIndex; // looking for selection start row (startIndex)
+  let endIndex = rowIndex;
 
+  // looking for selection start row (startIndex)
   for (let i = rowIndex; i >= 0; i--) {
     const cells = getCellsInRow(i)(tr.selection);
-
     if (cells) {
       cells.forEach(cell => {
         let maybeEndIndex = cell.node.attrs.rowspan + i - 1;
-
         if (maybeEndIndex >= startIndex) {
           startIndex = i;
         }
-
         if (maybeEndIndex > endIndex) {
           endIndex = maybeEndIndex;
         }
       });
     }
-  } // looking for selection end row (endIndex)
-
-
+  }
+  // looking for selection end row (endIndex)
   for (let i = rowIndex; i <= endIndex; i++) {
     const cells = getCellsInRow(i)(tr.selection);
-
     if (cells) {
       cells.forEach(cell => {
         let maybeEndIndex = cell.node.attrs.rowspan + i - 1;
-
         if (cell.node.attrs.rowspan > 1 && maybeEndIndex > endIndex) {
           endIndex = maybeEndIndex;
         }
       });
     }
-  } // filter out rows without cells (where all columns have rowspan > 1 in the same row)
-
+  }
 
+  // filter out rows without cells (where all columns have rowspan > 1 in the same row)
   const indexes = [];
-
   for (let i = startIndex; i <= endIndex; i++) {
     const maybeCells = getCellsInRow(i)(tr.selection);
-
     if (maybeCells && maybeCells.length) {
       indexes.push(i);
     }
   }
-
   startIndex = indexes[0];
   endIndex = indexes[indexes.length - 1];
   const firstSelectedRowCells = getCellsInRow(startIndex)(tr.selection);
   const firstColumnCells = getCellsInColumn(0)(tr.selection);
-
   if (!firstSelectedRowCells || !firstColumnCells) {
     return;
   }
-
   const $anchor = tr.doc.resolve(firstSelectedRowCells[firstSelectedRowCells.length - 1].pos);
   let headCell;
-
   for (let i = endIndex; i >= startIndex; i--) {
     const rowCells = getCellsInRow(i)(tr.selection);
-
     if (rowCells && rowCells.length) {
       for (let j = firstColumnCells.length - 1; j >= 0; j--) {
         if (firstColumnCells[j].pos === rowCells[0].pos) {
@@ -71,17 +60,14 @@ export const getSelectionRangeInRow = rowIndex => tr => {
           break;
         }
       }
-
       if (headCell) {
         break;
       }
     }
   }
-
   if (!headCell) {
     return;
   }
-
   const $head = tr.doc.resolve(headCell.pos);
   return {
     $anchor,

package/dist/es2019/utils/get-selection-rect.js

@@ -1,11 +1,11 @@
 import { TableMap } from '../table-map';
-import { isSelectionType } from './is-selection-type'; // Get the selection rectangle. Returns `undefined` if selection is not a CellSelection.
+import { isSelectionType } from './is-selection-type';
 
+// Get the selection rectangle. Returns `undefined` if selection is not a CellSelection.
 export const getSelectionRect = selection => {
   if (!isSelectionType(selection, 'cell')) {
     return;
   }
-
   const start = selection.$anchorCell.start(-1);
   const map = TableMap.get(selection.$anchorCell.node(-1));
   return map.rectBetween(selection.$anchorCell.pos - start, selection.$headCell.pos - start);

package/dist/es2019/utils/go-to-next-cell.js

@@ -1,72 +1,56 @@
 import { TextSelection } from 'prosemirror-state';
 import { selectionCell } from './selection-cell';
 import { isInTable } from './tables';
-
 function moveCellForward($pos) {
   const nextNodeSize = $pos.nodeAfter ? $pos.nodeAfter.nodeSize : 0;
   return $pos.node(0).resolve($pos.pos + nextNodeSize);
-} // Returns a command for selecting the next (direction=1) or previous
-// (direction=-1) cell in a table.
-
+}
 
+// Returns a command for selecting the next (direction=1) or previous
+// (direction=-1) cell in a table.
 export function goToNextCell(direction) {
   return function (state, dispatch) {
     if (!isInTable(state)) {
       return false;
     }
-
     const cellSelection = selectionCell(state.selection);
-
     if (!cellSelection) {
       return false;
     }
-
     const cell = findNextCell(cellSelection, direction);
-
     if (cell === undefined) {
       return false;
     }
-
     if (dispatch) {
       const $cell = state.doc.resolve(cell);
       dispatch(state.tr.setSelection(TextSelection.between($cell, moveCellForward($cell))).scrollIntoView());
     }
-
     return true;
   };
 }
-
 function findNextCell($cell, direction) {
   if (direction === -1) {
     const before = $cell.nodeBefore;
-
     if (before) {
       return $cell.pos - before.nodeSize;
     }
-
     for (let row = $cell.index(-1) - 1, rowEnd = $cell.before(); row >= 0; row--) {
       const rowNode = $cell.node(-1).child(row);
-
       if (rowNode.childCount && rowNode.lastChild) {
         return rowEnd - 1 - rowNode.lastChild.nodeSize;
       }
-
       rowEnd -= rowNode.nodeSize;
     }
   } else {
     if ($cell.index() < $cell.parent.childCount - 1 && $cell.nodeAfter) {
       return $cell.pos + $cell.nodeAfter.nodeSize;
     }
-
     const table = $cell.node(-1);
-
     for (let row = $cell.indexAfter(-1), rowStart = $cell.after(); row < table.childCount; row++) {
       const rowNode = table.child(row);
-
       if (rowNode.childCount) {
         return rowStart + 1;
       }
-
       rowStart += rowNode.nodeSize;
     }
   }

package/dist/es2019/utils/handle-paste.js

@@ -9,10 +9,8 @@ export function handlePaste(view, event, slice) {
   if (!isInTable(view.state)) {
     return false;
   }
-
   let cells = pastedCells(slice);
   const sel = view.state.selection;
-
   if (sel instanceof CellSelection) {
     if (!cells) {
       cells = {
@@ -21,7 +19,6 @@ export function handlePaste(view, event, slice) {
         rows: [Fragment.from(fitSlice(tableNodeTypes(view.state.schema).cell, slice))]
       };
     }
-
     const table = sel.$anchorCell.node(-1);
     const start = sel.$anchorCell.start(-1);
     const tableMap = TableMap.get(table);
@@ -30,37 +27,31 @@ export function handlePaste(view, event, slice) {
     insertCells(view.state, view.dispatch, start, rect, clearColumnWidthOfCells(cells, rect, tableMap));
     return true;
   }
-
   if (cells) {
     const $cell = selectionCell(sel);
-
     if (!$cell) {
       throw new Error(`handlePaste: no cell found`);
     }
-
     const start = $cell.start(-1);
     const rect = TableMap.get($cell.node(-1)).findCell($cell.pos - start);
     const tableMap = TableMap.get($cell.node(-1));
     insertCells(view.state, view.dispatch, start, rect, clearColumnWidthOfCells(cells, rect, tableMap));
     return true;
   }
-
   return false;
-} // Clear the pasted cells column widths so that it maintains
+}
+
+// Clear the pasted cells column widths so that it maintains
 // the column widths of the destination table only if the pasted
 // cells overlap with existing cells in the destination table.
 // If the table grows on paste, keep the column widhts of the
 // original table.
-
 const clearColumnWidthOfCells = (cells, rect, table) => {
   const overlappingCells = [];
-
   for (const row of cells.rows) {
     let colNum = rect.left;
-
     for (let index = 0; index < row.childCount; index++) {
       const cell = row.child(index);
-
       if (colNum + cell.attrs.colspan <= table.width) {
         overlappingCells.push(cell);
         colNum += cell.attrs.colspan;
@@ -69,10 +60,8 @@ const clearColumnWidthOfCells = (cells, rect, table) => {
       }
     }
   }
-
   for (const cell of overlappingCells) {
     cell.attrs.colwidth = null;
   }
-
   return cells;
 };