@atlaskit/editor-tables 2.2.4 → 2.2.6

package/dist/es2019/utils/select-nodes.js

@@ -2,29 +2,24 @@ import { CellSelection } from '../cell-selection';
 import { TableMap } from '../table-map';
 import { cloneTr } from './clone-tr';
 import { findCellClosestToPos, findTable, findTableClosestToPos } from './find';
-
 const select = type => (index, expand) => tr => {
   const table = findTable(tr.selection);
   const isRowSelection = type === 'row';
-
   if (table) {
-    const map = TableMap.get(table.node); // Check if the index is valid
+    const map = TableMap.get(table.node);
 
+    // Check if the index is valid
     if (index >= 0 && index < (isRowSelection ? map.height : map.width)) {
       let left = isRowSelection ? 0 : index;
       let top = isRowSelection ? index : 0;
       let right = isRowSelection ? map.width : index + 1;
       let bottom = isRowSelection ? index + 1 : map.height;
-
       if (expand) {
         const cell = findCellClosestToPos(tr.selection.$from);
-
         if (!cell) {
           return tr;
         }
-
         const selRect = map.findCell(cell.pos - table.start);
-
         if (isRowSelection) {
           top = Math.min(top, selRect.top);
           bottom = Math.max(bottom, selRect.bottom);
@@ -33,7 +28,6 @@ const select = type => (index, expand) => tr => {
           right = Math.max(right, selRect.right);
         }
       }
-
       const cellsInFirstRow = map.cellsInRect({
         left,
         top,
@@ -53,25 +47,24 @@ const select = type => (index, expand) => tr => {
       return cloneTr(tr.setSelection(new CellSelection($anchor, $head)));
     }
   }
-
   return tr;
-}; // Returns a new transaction that selects a column at index `columnIndex`.
-// Use the optional `expand` param to extend from current selection.
-
+};
 
-export const selectColumn = select('column'); // Returns a new transaction that selects a row at index `rowIndex`.
+// Returns a new transaction that selects a column at index `columnIndex`.
 // Use the optional `expand` param to extend from current selection.
+export const selectColumn = select('column');
 
-export const selectRow = select('row'); // Returns a new transaction that selects a table.
+// Returns a new transaction that selects a row at index `rowIndex`.
+// Use the optional `expand` param to extend from current selection.
+export const selectRow = select('row');
 
+// Returns a new transaction that selects a table.
 export const selectTable = tr => {
   const table = findTable(tr.selection);
-
   if (table) {
     const {
       map
     } = TableMap.get(table.node);
-
     if (map && map.length) {
       const head = table.start + map[0];
       const anchor = table.start + map[map.length - 1];
@@ -80,17 +73,14 @@ export const selectTable = tr => {
       return cloneTr(tr.setSelection(new CellSelection($anchor, $head)));
     }
   }
-
   return tr;
 };
 export const selectTableClosestToPos = (tr, $pos) => {
   const table = findTableClosestToPos($pos);
-
   if (table) {
     const {
       map
     } = TableMap.get(table.node);
-
     if (map && map.length) {
       const head = table.start + map[0];
       const anchor = table.start + map[map.length - 1];
@@ -99,6 +89,5 @@ export const selectTableClosestToPos = (tr, $pos) => {
       return cloneTr(tr.setSelection(new CellSelection($anchor, $head)));
     }
   }
-
   return tr;
 };

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

@@ -4,10 +4,8 @@ export function selectionCell(selection) {
   if (isSelectionType(selection, 'cell')) {
     return selection.$anchorCell.pos > selection.$headCell.pos ? selection.$anchorCell : selection.$headCell;
   }
-
   if (isSelectionType(selection, 'node') && selection.node.type.spec.tableRole === 'cell') {
     return selection.$anchor;
   }
-
   return cellAround(selection.$head) || cellNear(selection.$head);
 }

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

@@ -7,22 +7,18 @@ import { selectionCell } from './selection-cell';
 export function selectedRect(state) {
   const sel = state.selection;
   const $pos = selectionCell(sel);
-
   if (!$pos) {
     throw new Error(`selectedRect: invalid $pos for selection`);
   }
-
   const table = $pos.node(-1);
   const tableStart = $pos.start(-1);
   const map = TableMap.get(table);
   let rect;
-
   if (sel instanceof CellSelection) {
     rect = map.rectBetween(sel.$anchorCell.pos - tableStart, sel.$headCell.pos - tableStart);
   } else {
     rect = map.findCell($pos.pos - tableStart);
   }
-
   rect.tableStart = tableStart;
   rect.map = map;
   rect.table = table;

package/dist/es2019/utils/set-cell-attrs.js

@@ -1,10 +1,10 @@
-import { cloneTr } from './clone-tr'; // Returns a new transaction that sets given `attrs` to a given `cell`.
+import { cloneTr } from './clone-tr';
 
+// Returns a new transaction that sets given `attrs` to a given `cell`.
 export const setCellAttrs = (cell, attrs) => tr => {
   if (cell) {
     tr.setNodeMarkup(cell.pos, undefined, Object.assign({}, cell.node.attrs, attrs));
     return cloneTr(tr);
   }
-
   return tr;
 };

package/dist/es2019/utils/split-cell-with-type.js

@@ -6,12 +6,10 @@ export function cellWrapping($pos) {
   for (let d = $pos.depth; d > 0; d--) {
     // Sometimes the cell can be in the same depth.
     const role = $pos.node(d).type.spec.tableRole;
-
     if (role === 'cell' || role === 'header_cell') {
       return $pos.node(d);
     }
   }
-
   return null;
 }
 // Split a selected cell, whose rowpan or colspan is greater than one,
@@ -20,81 +18,67 @@ export function splitCellWithType(getCellType) {
   return (state, dispatch) => {
     let sel = state.selection;
     let cellNode, cellPos;
-
     if (!(sel instanceof CellSelection)) {
       cellNode = cellWrapping(sel.$from);
-
       if (!cellNode) {
         return false;
       }
-
       const cellNodeAround = cellAround(sel.$from);
       cellPos = cellNodeAround && cellNodeAround.pos;
     } else {
       if (sel.$anchorCell.pos !== sel.$headCell.pos) {
         return false;
       }
-
       cellNode = sel.$anchorCell.nodeAfter;
       cellPos = sel.$anchorCell.pos;
     }
-
     if (cellNode && cellNode.attrs.colspan === 1 && cellNode.attrs.rowspan === 1) {
       return false;
     }
-
     if (cellNode && dispatch) {
       let cellAttrs = cellNode.attrs,
-          attrs = [],
-          colwidth = cellAttrs.colwidth;
-
+        attrs = [],
+        colwidth = cellAttrs.colwidth;
       if (cellAttrs.rowspan && cellAttrs.rowspan > 1) {
-        cellAttrs = { ...cellAttrs,
+        cellAttrs = {
+          ...cellAttrs,
           rowspan: 1
         };
       }
-
       if (cellAttrs.colspan && cellAttrs.colspan > 1) {
-        cellAttrs = { ...cellAttrs,
+        cellAttrs = {
+          ...cellAttrs,
           colspan: 1
         };
       }
-
       let rect = selectedRect(state);
       let tr = state.tr;
-
       for (let i = 0; i < rect.right - rect.left; i++) {
-        attrs.push(colwidth ? { ...cellAttrs,
+        attrs.push(colwidth ? {
+          ...cellAttrs,
           colwidth: colwidth && colwidth[i] ? [colwidth[i]] : null
         } : cellAttrs);
       }
-
       let lastCell = null;
-
       for (let row = rect.top; row < rect.bottom; row++) {
         let pos = rect.map.positionAt(row, rect.left, rect.table);
-
         if (row === rect.top) {
           pos += cellNode.nodeSize;
         }
-
         for (let col = rect.left, i = 0; col < rect.right; col++, i++) {
           if (col === rect.left && row === rect.top) {
             continue;
           }
-
           const cellType = getCellType({
             node: cellNode,
             row,
             col
           }).createAndFill(attrs[i]);
-
           if (cellType) {
             tr.insert(lastCell = tr.mapping.map(pos + rect.tableStart, 1), cellType);
           }
         }
       }
-
       if (typeof cellPos === 'number') {
         tr.setNodeMarkup(cellPos, getCellType({
           node: cellNode,
@@ -102,16 +86,12 @@ export function splitCellWithType(getCellType) {
           col: rect.left
         }), attrs[0]);
       }
-
       const $lastCellPosition = lastCell && tr.doc.resolve(lastCell);
-
       if (sel instanceof CellSelection && $lastCellPosition instanceof ResolvedPos) {
         tr.setSelection(new CellSelection(tr.doc.resolve(sel.$anchorCell.pos), $lastCellPosition));
       }
-
       dispatch(tr);
     }
-
     return true;
   };
 }

package/dist/es2019/utils/split-cell.js

@@ -1,7 +1,8 @@
 import { splitCellWithType } from './split-cell-with-type';
-import { tableNodeTypes } from './table-node-types'; // Split a selected cell, whose rowpan or colspan is greater than one,
-// into smaller cells. Use the first cell type for the new cells.
+import { tableNodeTypes } from './table-node-types';
 
+// Split a selected cell, whose rowpan or colspan is greater than one,
+// into smaller cells. Use the first cell type for the new cells.
 export const splitCell = (state, dispatch) => {
   const nodeTypes = tableNodeTypes(state.schema);
   return splitCellWithType(({

package/dist/es2019/utils/table-node-types.js

@@ -1,20 +1,17 @@
 export function tableNodeTypes(schema) {
   let result = schema.cached.tableNodeTypes;
-
   if (!result) {
-    result = {}; // eslint-disable-next-line no-param-reassign
-
-    schema.cached.tableNodeTypes = result; // eslint-disable-next-line guard-for-in
-
+    result = {};
+    // eslint-disable-next-line no-param-reassign
+    schema.cached.tableNodeTypes = result;
+    // eslint-disable-next-line guard-for-in
     for (const name in schema.nodes) {
       const type = schema.nodes[name];
       const role = type.spec.tableRole;
-
       if (role) {
         result[role] = type;
       }
     }
   }
-
   return result;
 }

package/dist/es2019/utils/tables.js

@@ -2,13 +2,11 @@ export function isInTable(state) {
   const {
     $head
   } = state.selection;
-
   for (let d = $head.depth; d > 0; d--) {
     if ($head.node(d).type.spec.tableRole === 'row') {
       return true;
     }
   }
-
   return false;
 }
 export function inSameTable($a, $b) {

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

@@ -1,60 +1,56 @@
 import { addColumn } from './add-column';
 import { addRow } from './add-row';
 import { selectedRect } from './selection-rect';
-import { isInTable } from './tables'; // :: (EditorState, dispatch: ?(tr: Transaction)) → bool
-// Add a table row before the selection.
+import { isInTable } from './tables';
 
+// :: (EditorState, dispatch: ?(tr: Transaction)) → bool
+// Add a table row before the selection.
 export const addRowBefore = (state, dispatch) => {
   if (!isInTable(state)) {
     return false;
   }
-
   if (dispatch) {
     const rect = selectedRect(state);
     dispatch(addRow(state.tr, rect, rect.top));
   }
-
   return true;
-}; // :: (EditorState, dispatch: ?(tr: Transaction)) → bool
-// Add a table row after the selection.
+};
 
+// :: (EditorState, dispatch: ?(tr: Transaction)) → bool
+// Add a table row after the selection.
 export const addRowAfter = (state, dispatch) => {
   if (!isInTable(state)) {
     return false;
   }
-
   if (dispatch) {
     const rect = selectedRect(state);
     dispatch(addRow(state.tr, rect, rect.bottom));
   }
-
   return true;
-}; // :: (EditorState, dispatch: ?(tr: Transaction)) → bool
-// Command to add a column before the column with the selection.
+};
 
+// :: (EditorState, dispatch: ?(tr: Transaction)) → bool
+// Command to add a column before the column with the selection.
 export const addColumnBefore = (state, dispatch) => {
   if (!isInTable(state)) {
     return false;
   }
-
   if (dispatch) {
     const rect = selectedRect(state);
     dispatch(addColumn(state.tr, rect, rect.left));
   }
-
   return true;
-}; // :: (EditorState, dispatch: ?(tr: Transaction)) → bool
-// Command to add a column after the column with the selection.
+};
 
+// :: (EditorState, dispatch: ?(tr: Transaction)) → bool
+// Command to add a column after the column with the selection.
 export const addColumnAfter = (state, dispatch) => {
   if (!isInTable(state)) {
     return false;
   }
-
   if (dispatch) {
     const rect = selectedRect(state);
     dispatch(addColumn(state.tr, rect, rect.right));
   }
-
   return true;
 };

package/dist/es2019/utils/toggle-header.js

@@ -10,35 +10,31 @@ export function isHeaderEnabledByType(type, rect, types) {
     right: type === 'row' ? rect.map.width : 1,
     bottom: type === 'column' ? rect.map.height : 1
   });
-
   for (let i = 0; i < cellPositions.length; i++) {
     const cell = rect.table.nodeAt(cellPositions[i]);
-
     if (cell && cell.type !== types.header_cell) {
       return false;
     }
   }
-
   return true;
-} // Toggles between row/column header and normal cells (Only applies to first row/column).
+}
 
+// Toggles between row/column header and normal cells (Only applies to first row/column).
 export function toggleHeader(type) {
   return function (state, dispatch) {
     if (!isInTable(state)) {
       return false;
     }
-
     if (dispatch) {
       let types = tableNodeTypes(state.schema);
       let rect = selectedRect(state),
-          tr = state.tr;
+        tr = state.tr;
       let isHeaderRowEnabled = isHeaderEnabledByType('row', rect, types);
       let isHeaderColumnEnabled = isHeaderEnabledByType('column', rect, types);
       let isHeaderEnabled = type === 'column' ? isHeaderRowEnabled : type === 'row' ? isHeaderColumnEnabled : false;
       let selectionStartsAt = isHeaderEnabled ? 1 : 0;
       const cellsRect = type === 'column' ? new Rect(0, selectionStartsAt, 1, rect.map.height) : type === 'row' ? new Rect(selectionStartsAt, 0, rect.map.width, 1) : rect;
       let newType;
-
       if (type === 'column') {
         newType = isHeaderColumnEnabled ? types.cell : types.header_cell;
       } else if (type === 'row') {
@@ -46,18 +42,15 @@ export function toggleHeader(type) {
       } else {
         newType = types.cell;
       }
-
       rect.map.cellsInRect(cellsRect).forEach(relativeCellPos => {
         const cellPos = relativeCellPos + rect.tableStart;
         const cell = tr.doc.nodeAt(cellPos);
-
         if (cell) {
           tr.setNodeMarkup(cellPos, newType, cell.attrs);
         }
       });
       dispatch(tr);
     }
-
     return true;
   };
 }

package/dist/es2019/utils/uuid.js

@@ -15,9 +15,7 @@ export const uuid = {
   setStatic(value) {
     staticValue = value;
   },
-
   generate() {
     return staticValue || generateUuid();
   }
-
 };

package/dist/es2019/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/editor-tables",
-	"version": "2.2.4",
+	"version": "2.2.6",
 	"sideEffects": false
 }

package/dist/esm/cell-bookmark.js

@@ -5,11 +5,9 @@ import { inSameTable } from './utils/tables';
 export var CellBookmark = /*#__PURE__*/function () {
   function CellBookmark(anchor, head) {
     _classCallCheck(this, CellBookmark);
-
     this.anchor = anchor;
     this.head = head;
   }
-
   _createClass(CellBookmark, [{
     key: "map",
     value: function map(mapping) {
@@ -20,7 +18,6 @@ export var CellBookmark = /*#__PURE__*/function () {
     value: function resolve(doc) {
       var $anchorCell = doc.resolve(this.anchor);
       var $headCell = doc.resolve(this.head);
-
       if ($anchorCell.parent.type.spec.tableRole === 'row' && $headCell.parent.type.spec.tableRole === 'row' && $anchorCell.index() < $anchorCell.parent.childCount && $headCell.index() < $headCell.parent.childCount && inSameTable($anchorCell, $headCell)) {
         var data = {
           type: 'cell',
@@ -29,10 +26,8 @@ export var CellBookmark = /*#__PURE__*/function () {
         };
         return Selection.fromJSON(doc, data);
       }
-
       return Selection.near($headCell, 1);
     }
   }]);
-
   return CellBookmark;
 }();