@atlaskit/editor-tables 2.2.4 → 2.2.6

package/dist/es2019/utils/is-selected.js

@@ -1,25 +1,24 @@
 import { TableMap } from '../table-map';
-import { isSelectionType } from './is-selection-type'; // Checks if a given CellSelection rect is selected
+import { isSelectionType } from './is-selection-type';
 
+// Checks if a given CellSelection rect is selected
 export const isRectSelected = rect => selection => {
   if (!isSelectionType(selection, 'cell')) {
     return false;
   }
-
   const map = TableMap.get(selection.$anchorCell.node(-1));
   const start = selection.$anchorCell.start(-1);
   const cells = map.cellsInRect(rect);
   const selectedCells = map.cellsInRect(map.rectBetween(selection.$anchorCell.pos - start, selection.$headCell.pos - start));
-
   for (let i = 0, count = cells.length; i < count; i++) {
     if (selectedCells.indexOf(cells[i]) === -1) {
       return false;
     }
   }
-
   return true;
-}; // Checks if entire column at index `columnIndex` is selected.
+};
 
+// Checks if entire column at index `columnIndex` is selected.
 export const isColumnSelected = columnIndex => selection => {
   if (isSelectionType(selection, 'cell')) {
     const map = TableMap.get(selection.$anchorCell.node(-1));
@@ -30,10 +29,10 @@ export const isColumnSelected = columnIndex => selection => {
       bottom: map.height
     })(selection);
   }
-
   return false;
-}; // Checks if entire row at index `rowIndex` is selected.
+};
 
+// Checks if entire row at index `rowIndex` is selected.
 export const isRowSelected = rowIndex => selection => {
   if (isSelectionType(selection, 'cell')) {
     const map = TableMap.get(selection.$anchorCell.node(-1));
@@ -44,10 +43,10 @@ export const isRowSelected = rowIndex => selection => {
       bottom: rowIndex + 1
     })(selection);
   }
-
   return false;
-}; // Checks if entire table is selected
+};
 
+// Checks if entire table is selected
 export const isTableSelected = selection => {
   if (isSelectionType(selection, 'cell')) {
     const map = TableMap.get(selection.$anchorCell.node(-1));
@@ -58,6 +57,5 @@ export const isTableSelected = selection => {
       bottom: map.height
     })(selection);
   }
-
   return false;
 };

package/dist/es2019/utils/is-selection-type.js

@@ -2,7 +2,6 @@ export function isSelectionType(selection, type) {
   if (!selection) {
     return false;
   }
-
   const serialized = selection.toJSON();
   return serialized.type === type;
 }

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

@@ -1,7 +1,9 @@
 import { cloneTr } from './clone-tr';
 import { findTable } from './find';
 import { getSelectionRangeInColumn } from './get-selection-range-in-column';
-import { isValidReorder, moveTableColumn } from './reorder-utils'; // :: (originColumnIndex: number, targetColumnIndex: targetColumnIndex, options?: MovementOptions) → (tr: Transaction) → Transaction
+import { isValidReorder, moveTableColumn } from './reorder-utils';
+
+// :: (originColumnIndex: number, targetColumnIndex: targetColumnIndex, options?: MovementOptions) → (tr: Transaction) → Transaction
 // Returns a new transaction that moves the origin column to the target index;
 //
 // by default "tryToFit" is false, that means if you try to move a column to a place
@@ -129,32 +131,25 @@ import { isValidReorder, moveTableColumn } from './reorder-utils'; // :: (origin
 //   moveColumn(x, y, options)(state.tr)
 // );
 // ```
-
 export const moveColumn = (originColumnIndex, targetColumnIndex, options = {
   tryToFit: false,
   direction: 0
 }) => tr => {
   var _originalColumnRanges, _targetColumnRanges$i;
-
   const table = findTable(tr.selection);
-
   if (!table) {
     return tr;
   }
-
   const originalColumnRanges = getSelectionRangeInColumn(originColumnIndex)(tr);
   const targetColumnRanges = getSelectionRangeInColumn(targetColumnIndex)(tr);
   const indexesOriginColumn = (_originalColumnRanges = originalColumnRanges === null || originalColumnRanges === void 0 ? void 0 : originalColumnRanges.indexes) !== null && _originalColumnRanges !== void 0 ? _originalColumnRanges : [];
   const indexesTargetColumn = (_targetColumnRanges$i = targetColumnRanges === null || targetColumnRanges === void 0 ? void 0 : targetColumnRanges.indexes) !== null && _targetColumnRanges$i !== void 0 ? _targetColumnRanges$i : [];
-
   if (indexesOriginColumn.includes(targetColumnIndex)) {
     return tr;
   }
-
   if (!options.tryToFit && indexesTargetColumn.length > 1) {
     isValidReorder(originColumnIndex, targetColumnIndex, indexesTargetColumn, 'column');
   }
-
   const newTable = moveTableColumn(table, indexesOriginColumn, indexesTargetColumn, options.direction);
   return cloneTr(tr).replaceWith(table.pos, table.pos + table.node.nodeSize, newTable);
 };

package/dist/es2019/utils/move-row.js

@@ -1,7 +1,9 @@
 import { cloneTr } from './clone-tr';
 import { findTable } from './find';
 import { getSelectionRangeInRow } from './get-selection-range-in-row';
-import { isValidReorder, moveTableRow } from './reorder-utils'; // :: (originRowIndex: number, targetRowIndex: targetColumnIndex, options?: MovementOptions) → (tr: Transaction) → Transaction
+import { isValidReorder, moveTableRow } from './reorder-utils';
+
+// :: (originRowIndex: number, targetRowIndex: targetColumnIndex, options?: MovementOptions) → (tr: Transaction) → Transaction
 // Returns a new transaction that moves the origin row to the target index;
 //
 // by default "tryToFit" is false, that means if you try to move a row to a place
@@ -144,30 +146,24 @@ import { isValidReorder, moveTableRow } from './reorder-utils'; // :: (originRow
 //   moveRow(x, y, options)(state.tr)
 // );
 // ```
-
 export const moveRow = (originRowIndex, targetRowIndex, options = {
   tryToFit: false,
   direction: 0
 }) => tr => {
   const table = findTable(tr.selection);
-
   if (!table) {
     return tr;
   }
-
   const originalRowRanges = getSelectionRangeInRow(originRowIndex)(tr);
   const targetRowRanges = getSelectionRangeInRow(targetRowIndex)(tr);
   const indexesOriginRow = (originalRowRanges === null || originalRowRanges === void 0 ? void 0 : originalRowRanges.indexes) || [];
   const indexesTargetRow = (targetRowRanges === null || targetRowRanges === void 0 ? void 0 : targetRowRanges.indexes) || [];
-
   if (indexesOriginRow.includes(targetRowIndex)) {
     return tr;
   }
-
   if (!options.tryToFit && indexesTargetRow.length > 1) {
     isValidReorder(originRowIndex, targetRowIndex, indexesTargetRow, 'row');
   }
-
   const newTable = moveTableRow(table, indexesOriginRow, indexesTargetRow, options.direction);
   return cloneTr(tr).replaceWith(table.pos, table.pos + table.node.nodeSize, newTable);
 };

package/dist/es2019/utils/normalize-selection.js

@@ -9,11 +9,9 @@ export function normalizeSelection(state, transaction, allowTableNodeSelection)
   } = tr || state;
   let normalize;
   let role;
-
   if (sel instanceof NodeSelection) {
     role = sel.node.type.spec.tableRole;
   }
-
   if (sel instanceof NodeSelection && role) {
     if (role === 'cell' || role === 'header_cell') {
       normalize = CellSelection.create(doc, sel.from);
@@ -31,14 +29,11 @@ export function normalizeSelection(state, transaction, allowTableNodeSelection)
   } else if (sel instanceof TextSelection && isTextSelectionAcrossCells(sel)) {
     normalize = TextSelection.create(doc, sel.$from.start(), sel.$from.end());
   }
-
   if (normalize) {
     (tr || (tr = state.tr)).setSelection(normalize);
   }
-
   return tr;
 }
-
 function isCellBoundarySelection({
   $from,
   $to
@@ -46,53 +41,42 @@ function isCellBoundarySelection({
   if ($from.pos === $to.pos || $from.pos < $from.pos - 6) {
     return false;
   } // Cheap elimination
-
-
   let afterFrom = $from.pos;
   let beforeTo = $to.pos;
   let {
     depth
   } = $from;
-
   for (; depth >= 0; depth--, afterFrom++) {
     if ($from.after(depth + 1) < $from.end(depth)) {
       break;
     }
   }
-
   for (let d = $to.depth; d >= 0; d--, beforeTo--) {
     if ($to.before(d + 1) > $to.start(d)) {
       break;
     }
   }
-
   return afterFrom === beforeTo && /row|table/.test($from.node(depth).type.spec.tableRole);
 }
-
 function isTextSelectionAcrossCells({
   $from,
   $to
 }) {
   let fromCellBoundaryNode;
   let toCellBoundaryNode;
-
   for (let i = $from.depth; i > 0; i--) {
     const node = $from.node(i);
-
     if (node.type.spec.tableRole === 'cell' || node.type.spec.tableRole === 'header_cell') {
       fromCellBoundaryNode = node;
       break;
     }
   }
-
   for (let i = $to.depth; i > 0; i--) {
     const node = $to.node(i);
-
     if (node.type.spec.tableRole === 'cell' || node.type.spec.tableRole === 'header_cell') {
       toCellBoundaryNode = node;
       break;
     }
   }
-
   return fromCellBoundaryNode !== toCellBoundaryNode && $to.parentOffset === 0;
 }

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

@@ -6,44 +6,37 @@ import { findCellRectClosestToPos, findTable } from './find';
 import { isTableSelected } from './is-selected';
 import { isSelectionType } from './is-selection-type';
 import { removeTable } from './remove-table';
-
 function removeColumn(tr, {
   map,
   table,
   tableStart
 }, columnIndex) {
   const mapStart = tr.mapping.maps.length;
-
   for (let row = 0; row < map.height;) {
     const index = row * map.width + columnIndex;
     const pos = map.map[index];
     const cell = table.nodeAt(pos);
-
     if (!cell) {
       continue;
-    } // If this is part of a col-spanning cell
-
+    }
 
+    // If this is part of a col-spanning cell
     if (columnIndex > 0 && map.map[index - 1] === pos || columnIndex < map.width - 1 && map.map[index + 1] === pos) {
       tr.setNodeMarkup(tr.mapping.slice(mapStart).map(tableStart + pos), undefined, removeColSpan(cell.attrs, columnIndex - map.colCount(pos)));
     } else {
       const start = tr.mapping.slice(mapStart).map(tableStart + pos);
       tr.delete(start, start + cell.nodeSize);
     }
-
     row += cell.attrs.rowspan;
   }
-
   return tr;
-} // Returns a new transaction that removes a column at index `columnIndex`. If there is only one column left, it will remove the entire table.
-
+}
 
+// Returns a new transaction that removes a column at index `columnIndex`. If there is only one column left, it will remove the entire table.
 export const removeColumnAt = columnIndex => tr => {
   const table = findTable(tr.selection);
-
   if (table) {
     const map = TableMap.get(table.node);
-
     if (columnIndex === 0 && map.width === 1) {
       return removeTable(tr);
     } else if (columnIndex >= 0 && columnIndex <= map.width) {
@@ -55,60 +48,50 @@ export const removeColumnAt = columnIndex => tr => {
       return cloneTr(tr);
     }
   }
-
   return tr;
-}; // Returns a new transaction that removes selected columns.
+};
 
+// Returns a new transaction that removes selected columns.
 export const removeSelectedColumns = tr => {
   const {
     selection
   } = tr;
-
   if (isTableSelected(selection)) {
     return removeTable(tr);
   }
-
   if (isSelectionType(selection, 'cell')) {
     const table = findTable(selection);
-
     if (table) {
       const map = TableMap.get(table.node);
       const rect = map.rectBetween(selection.$anchorCell.pos - table.start, selection.$headCell.pos - table.start);
-
       if (rect.left === 0 && rect.right === map.width) {
         return tr;
       }
-
-      const pmTableRect = { ...rect,
+      const pmTableRect = {
+        ...rect,
         map,
         table: table.node,
         tableStart: table.start
       };
-
       for (let i = pmTableRect.right - 1;; i--) {
         removeColumn(tr, pmTableRect, i);
-
         if (i === pmTableRect.left) {
           break;
         }
-
         pmTableRect.table = pmTableRect.tableStart ? tr.doc.nodeAt(pmTableRect.tableStart - 1) : tr.doc;
         pmTableRect.map = TableMap.get(pmTableRect.table);
       }
-
       return cloneTr(tr);
     }
   }
-
   return tr;
-}; // Returns a new transaction that removes a column closest to a given `$pos`.
+};
 
+// Returns a new transaction that removes a column closest to a given `$pos`.
 export const removeColumnClosestToPos = $pos => tr => {
   const rect = findCellRectClosestToPos($pos);
-
   if (rect) {
     return removeColumnAt(rect.left)(setTextSelection($pos.pos)(tr));
   }
-
   return tr;
 };

package/dist/es2019/utils/remove-row.js

@@ -5,47 +5,40 @@ import { findCellRectClosestToPos, findTable } from './find';
 import { isTableSelected } from './is-selected';
 import { isSelectionType } from './is-selection-type';
 import { removeTable } from './remove-table';
-
 function removeRow(tr, {
   map,
   table,
   tableStart
 }, rowIndex) {
   let rowPos = 0;
-
   for (let i = 0; i < rowIndex; i++) {
     rowPos += table.child(i).nodeSize;
   }
-
   let nextRow = rowPos + table.child(rowIndex).nodeSize;
   let mapFrom = tr.mapping.maps.length;
   tr.delete(rowPos + tableStart, nextRow + tableStart);
-
   for (let col = 0, index = rowIndex * map.width; col < map.width; col++, index++) {
     let pos = map.map[index];
-
     if (rowIndex > 0 && pos === map.map[index - map.width]) {
       // If this cell starts in the row above, simply reduce its rowspan
       const cell = table.nodeAt(pos);
-
       if (!cell) {
         continue;
       }
-
       const attrs = cell.attrs;
-      tr.setNodeMarkup(tr.mapping.slice(mapFrom).map(pos + tableStart), undefined, { ...attrs,
+      tr.setNodeMarkup(tr.mapping.slice(mapFrom).map(pos + tableStart), undefined, {
+        ...attrs,
         rowspan: attrs.rowspan - 1
       });
       col += attrs.colspan - 1;
     } else if (rowIndex < map.width && pos === map.map[index + map.width]) {
       // Else, if it continues in the row below, it has to be moved down
       const cell = table.nodeAt(pos);
-
       if (!cell) {
         continue;
       }
-
-      const copy = cell.type.create({ ...cell.attrs,
+      const copy = cell.type.create({
+        ...cell.attrs,
         rowspan: cell.attrs.rowspan - 1
       }, cell.content);
       const newPos = map.positionAt(rowIndex + 1, col, table);
@@ -53,17 +46,14 @@ function removeRow(tr, {
       col += cell.attrs.colspan - 1;
     }
   }
-
   return tr;
-} // Returns a new transaction that removes a row at index `rowIndex`. If there is only one row left, it will remove the entire table.
-
+}
 
+// Returns a new transaction that removes a row at index `rowIndex`. If there is only one row left, it will remove the entire table.
 export const removeRowAt = rowIndex => tr => {
   const table = findTable(tr.selection);
-
   if (table) {
     const map = TableMap.get(table.node);
-
     if (rowIndex === 0 && map.height === 1) {
       return removeTable(tr);
     } else if (rowIndex >= 0 && rowIndex <= map.height) {
@@ -75,60 +65,50 @@ export const removeRowAt = rowIndex => tr => {
       return cloneTr(tr);
     }
   }
-
   return tr;
-}; // Returns a new transaction that removes selected rows.
+};
 
+// Returns a new transaction that removes selected rows.
 export const removeSelectedRows = tr => {
   const {
     selection
   } = tr;
-
   if (isTableSelected(selection)) {
     return removeTable(tr);
   }
-
   if (isSelectionType(selection, 'cell')) {
     const table = findTable(selection);
-
     if (table) {
       const map = TableMap.get(table.node);
       const rect = map.rectBetween(selection.$anchorCell.pos - table.start, selection.$headCell.pos - table.start);
-
       if (rect.top === 0 && rect.bottom === map.height) {
         return tr;
       }
-
-      const pmTableRect = { ...rect,
+      const pmTableRect = {
+        ...rect,
         map,
         table: table.node,
         tableStart: table.start
       };
-
       for (let i = pmTableRect.bottom - 1;; i--) {
         removeRow(tr, pmTableRect, i);
-
         if (i === pmTableRect.top) {
           break;
         }
-
         pmTableRect.table = pmTableRect.tableStart ? tr.doc.nodeAt(pmTableRect.tableStart - 1) : tr.doc;
         pmTableRect.map = TableMap.get(pmTableRect.table);
       }
-
       return cloneTr(tr);
     }
   }
-
   return tr;
-}; // Returns a new transaction that removes a row closest to a given `$pos`.
+};
 
+// Returns a new transaction that removes a row closest to a given `$pos`.
 export const removeRowClosestToPos = $pos => tr => {
   const rect = findCellRectClosestToPos($pos);
-
   if (rect) {
     return removeRowAt(rect.top)(setTextSelection($pos.pos)(tr));
   }
-
   return tr;
 };

package/dist/es2019/utils/remove-table.js

@@ -1,17 +1,15 @@
-import { cloneTr } from './clone-tr'; // Returns a new transaction that removes a table node if the cursor is inside of it.
+import { cloneTr } from './clone-tr';
 
+// Returns a new transaction that removes a table node if the cursor is inside of it.
 export const removeTable = tr => {
   const {
     $from
   } = tr.selection;
-
   for (let depth = $from.depth; depth > 0; depth--) {
     let node = $from.node(depth);
-
     if (node.type.spec.tableRole === 'table') {
       return cloneTr(tr.delete($from.before(depth), $from.after(depth)));
     }
   }
-
   return tr;
 };

package/dist/es2019/utils/reorder-utils.js

@@ -1,9 +1,10 @@
-import { TableMap } from '../table-map'; // array = [
+import { TableMap } from '../table-map';
+
+// array = [
 //   [A1, B1, C1, null],
 //   [A2, B2, null, D1],
 //   [A3. B3, C2, null],
 // ]
-
 // This function transposes an array of array flipping the columns for rows,
 // transposition is a familiar algebra concept;
 // you can get more details here:
@@ -30,7 +31,9 @@ export const transpose = array => {
   return array[0].map((_, i) => {
     return array.map(column => column[i]);
   });
-}; // :: (tableNode: Node, tableArray: Array<Node>) -> Node
+};
+
+// :: (tableNode: Node, tableArray: Array<Node>) -> Node
 // This function will transform a matrix of nodes
 // into table node respecting merged cells and rows configurations,
 // for example this array will be convert to the table below:
@@ -56,57 +59,49 @@ export const transpose = array => {
 // |______|______|______|______|
 // ```
 //
-
 export const convertArrayOfRowsToTableNode = (tableNode, arrayOfNodes) => {
   const rowsPM = [];
   const map = TableMap.get(tableNode);
-
   for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
     const row = tableNode.child(rowIndex);
     const rowCells = [];
-
     for (let colIndex = 0; colIndex < map.width; colIndex++) {
       if (!arrayOfNodes[rowIndex][colIndex]) {
         continue;
       }
-
       const cellPos = map.map[rowIndex * map.width + colIndex];
       const cell = arrayOfNodes[rowIndex][colIndex];
       const oldCell = tableNode.nodeAt(cellPos);
-
       if (!cell || !oldCell) {
         continue;
       }
-
       const newCell = oldCell.type.createChecked(Object.assign({}, cell.attrs), cell.content, cell.marks);
       rowCells.push(newCell);
     }
-
     rowsPM.push(row.type.createChecked(row.attrs, rowCells, row.marks));
   }
-
   const newTable = tableNode.type.createChecked(tableNode.attrs, rowsPM, tableNode.marks);
   return newTable;
 };
-
 const moveRowInArrayOfRows = (arrayOfNodes, indexesOrigin, indexesTarget, directionOverride) => {
   let direction = indexesOrigin[0] > indexesTarget[0] ? -1 : 1;
   const rowsExtracted = arrayOfNodes.splice(indexesOrigin[0], indexesOrigin.length);
   const positionOffset = rowsExtracted.length % 2 === 0 ? 1 : 0;
   let target;
-
   if (directionOverride === -1 && direction === 1) {
     target = indexesTarget[0] - 1;
   } else if (directionOverride === 1 && direction === -1) {
     target = indexesTarget[indexesTarget.length - 1] - positionOffset + 1;
   } else {
     target = direction === -1 ? indexesTarget[0] : indexesTarget[indexesTarget.length - 1] - positionOffset;
-  } // @ts-ignore no idea what this line does
-
+  }
 
+  // @ts-ignore no idea what this line does
   arrayOfNodes.splice.apply(arrayOfNodes, [target, 0].concat(rowsExtracted));
   return arrayOfNodes;
-}; // :: (tableNode: Node) -> Array<Node>
+};
+
+// :: (tableNode: Node) -> Array<Node>
 // This function will transform the table node
 // into a matrix of rows and columns respecting merged cells,
 // for example this table will be convert to the below:
@@ -132,33 +127,25 @@ const moveRowInArrayOfRows = (arrayOfNodes, indexesOrigin, indexesTarget, direct
 //   [A3. B3, C2, null],
 // ]
 // ```
-
-
 export const convertTableNodeToArrayOfRows = tableNode => {
   const map = TableMap.get(tableNode);
   const rows = [];
-
   for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
     const rowCells = [];
     const seen = {};
-
     for (let colIndex = 0; colIndex < map.width; colIndex++) {
       const cellPos = map.map[rowIndex * map.width + colIndex];
       const cell = tableNode.nodeAt(cellPos);
       const rect = map.findCell(cellPos);
-
       if (!cell || seen[cellPos] || rect.top !== rowIndex) {
         rowCells.push(null);
         continue;
       }
-
       seen[cellPos] = true;
       rowCells.push(cell);
     }
-
     rows.push(rowCells);
   }
-
   return rows;
 };
 export const moveTableRow = (table, indexesOrigin, indexesTarget, direction) => {
@@ -175,7 +162,6 @@ export const moveTableColumn = (table, indexesOrigin, indexesTarget, direction)
 export const isValidReorder = (originIndex, targetIndex, targets, type) => {
   const direction = originIndex > targetIndex ? -1 : 1;
   const errorMessage = `Target position is invalid, you can't move the ${type} ${originIndex} to ${targetIndex}, the target can't be split. You could use tryToFit option.`;
-
   if (direction === 1) {
     if (targets.slice(0, targets.length - 1).indexOf(targetIndex) !== -1) {
       throw new Error(errorMessage);
@@ -185,6 +171,5 @@ export const isValidReorder = (originIndex, targetIndex, targets, type) => {
       throw new Error(errorMessage);
     }
   }
-
   return true;
 };

package/dist/es2019/utils/replace-table.js

@@ -5,7 +5,6 @@ import { isTableSelected } from './is-selected';
 export const replaceSelectedTable = (state, content) => {
   if (isTableSelected(state.selection)) {
     const table = findTable(state.selection);
-
     if (table) {
       const slice = typeof content === 'string' ? new Slice(Fragment.from(state.schema.text(content)), 0, 0) : content;
       let tr = state.tr.replace(table.pos, table.pos + table.node.nodeSize, slice);
@@ -13,6 +12,5 @@ export const replaceSelectedTable = (state, content) => {
       return tr;
     }
   }
-
   return state.tr;
 };