@atlaskit/editor-tables 2.2.4 → 2.2.6

package/dist/esm/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:
@@ -32,7 +33,9 @@ export var transpose = function transpose(array) {
       return 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:
@@ -58,57 +61,49 @@ export var transpose = function transpose(array) {
 // |______|______|______|______|
 // ```
 //
-
 export var convertArrayOfRowsToTableNode = function convertArrayOfRowsToTableNode(tableNode, arrayOfNodes) {
   var rowsPM = [];
   var map = TableMap.get(tableNode);
-
   for (var rowIndex = 0; rowIndex < map.height; rowIndex++) {
     var row = tableNode.child(rowIndex);
     var rowCells = [];
-
     for (var colIndex = 0; colIndex < map.width; colIndex++) {
       if (!arrayOfNodes[rowIndex][colIndex]) {
         continue;
       }
-
       var cellPos = map.map[rowIndex * map.width + colIndex];
       var cell = arrayOfNodes[rowIndex][colIndex];
       var oldCell = tableNode.nodeAt(cellPos);
-
       if (!cell || !oldCell) {
         continue;
       }
-
       var 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));
   }
-
   var newTable = tableNode.type.createChecked(tableNode.attrs, rowsPM, tableNode.marks);
   return newTable;
 };
-
 var moveRowInArrayOfRows = function moveRowInArrayOfRows(arrayOfNodes, indexesOrigin, indexesTarget, directionOverride) {
   var direction = indexesOrigin[0] > indexesTarget[0] ? -1 : 1;
   var rowsExtracted = arrayOfNodes.splice(indexesOrigin[0], indexesOrigin.length);
   var positionOffset = rowsExtracted.length % 2 === 0 ? 1 : 0;
   var 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:
@@ -134,33 +129,25 @@ var moveRowInArrayOfRows = function moveRowInArrayOfRows(arrayOfNodes, indexesOr
 //   [A3. B3, C2, null],
 // ]
 // ```
-
-
 export var convertTableNodeToArrayOfRows = function convertTableNodeToArrayOfRows(tableNode) {
   var map = TableMap.get(tableNode);
   var rows = [];
-
   for (var rowIndex = 0; rowIndex < map.height; rowIndex++) {
     var rowCells = [];
     var seen = {};
-
     for (var colIndex = 0; colIndex < map.width; colIndex++) {
       var cellPos = map.map[rowIndex * map.width + colIndex];
       var cell = tableNode.nodeAt(cellPos);
       var 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 var moveTableRow = function moveTableRow(table, indexesOrigin, indexesTarget, direction) {
@@ -177,7 +164,6 @@ export var moveTableColumn = function moveTableColumn(table, indexesOrigin, inde
 export var isValidReorder = function isValidReorder(originIndex, targetIndex, targets, type) {
   var direction = originIndex > targetIndex ? -1 : 1;
   var errorMessage = "Target position is invalid, you can't move the ".concat(type, " ").concat(originIndex, " to ").concat(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);
@@ -187,6 +173,5 @@ export var isValidReorder = function isValidReorder(originIndex, targetIndex, ta
       throw new Error(errorMessage);
     }
   }
-
   return true;
 };

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

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

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

@@ -2,31 +2,26 @@ import { CellSelection } from '../cell-selection';
 import { TableMap } from '../table-map';
 import { cloneTr } from './clone-tr';
 import { findCellClosestToPos, findTable, findTableClosestToPos } from './find';
-
 var select = function select(type) {
   return function (index, expand) {
     return function (tr) {
       var table = findTable(tr.selection);
       var isRowSelection = type === 'row';
-
       if (table) {
-        var map = TableMap.get(table.node); // Check if the index is valid
+        var map = TableMap.get(table.node);
 
+        // Check if the index is valid
         if (index >= 0 && index < (isRowSelection ? map.height : map.width)) {
           var left = isRowSelection ? 0 : index;
           var top = isRowSelection ? index : 0;
           var right = isRowSelection ? map.width : index + 1;
           var bottom = isRowSelection ? index + 1 : map.height;
-
           if (expand) {
             var cell = findCellClosestToPos(tr.selection.$from);
-
             if (!cell) {
               return tr;
             }
-
             var selRect = map.findCell(cell.pos - table.start);
-
             if (isRowSelection) {
               top = Math.min(top, selRect.top);
               bottom = Math.max(bottom, selRect.bottom);
@@ -35,7 +30,6 @@ var select = function select(type) {
               right = Math.max(right, selRect.right);
             }
           }
-
           var cellsInFirstRow = map.cellsInRect({
             left: left,
             top: top,
@@ -55,26 +49,25 @@ var select = function select(type) {
           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 var 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 var selectColumn = select('column');
 
-export var 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 var selectRow = select('row');
 
+// Returns a new transaction that selects a table.
 export var selectTable = function selectTable(tr) {
   var table = findTable(tr.selection);
-
   if (table) {
     var _TableMap$get = TableMap.get(table.node),
-        map = _TableMap$get.map;
-
+      map = _TableMap$get.map;
     if (map && map.length) {
       var head = table.start + map[0];
       var anchor = table.start + map[map.length - 1];
@@ -83,16 +76,13 @@ export var selectTable = function selectTable(tr) {
       return cloneTr(tr.setSelection(new CellSelection($anchor, $head)));
     }
   }
-
   return tr;
 };
 export var selectTableClosestToPos = function selectTableClosestToPos(tr, $pos) {
   var table = findTableClosestToPos($pos);
-
   if (table) {
     var _TableMap$get2 = TableMap.get(table.node),
-        map = _TableMap$get2.map;
-
+      map = _TableMap$get2.map;
     if (map && map.length) {
       var head = table.start + map[0];
       var anchor = table.start + map[map.length - 1];
@@ -101,6 +91,5 @@ export var selectTableClosestToPos = function selectTableClosestToPos(tr, $pos)
       return cloneTr(tr.setSelection(new CellSelection($anchor, $head)));
     }
   }
-
   return tr;
 };

package/dist/esm/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/esm/utils/selection-rect.js

@@ -7,22 +7,18 @@ import { selectionCell } from './selection-cell';
 export function selectedRect(state) {
   var sel = state.selection;
   var $pos = selectionCell(sel);
-
   if (!$pos) {
     throw new Error("selectedRect: invalid $pos for selection");
   }
-
   var table = $pos.node(-1);
   var tableStart = $pos.start(-1);
   var map = TableMap.get(table);
   var 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/esm/utils/set-cell-attrs.js

@@ -1,12 +1,12 @@
-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 var setCellAttrs = function setCellAttrs(cell, attrs) {
   return function (tr) {
     if (cell) {
       tr.setNodeMarkup(cell.pos, undefined, Object.assign({}, cell.node.attrs, attrs));
       return cloneTr(tr);
     }
-
     return tr;
   };
 };

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

@@ -1,9 +1,6 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
 import { ResolvedPos } from 'prosemirror-model';
 import { CellSelection } from '../cell-selection';
 import { cellAround } from './cells';
@@ -12,12 +9,10 @@ export function cellWrapping($pos) {
   for (var d = $pos.depth; d > 0; d--) {
     // Sometimes the cell can be in the same depth.
     var 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,
@@ -26,81 +21,64 @@ export function splitCellWithType(getCellType) {
   return function (state, dispatch) {
     var sel = state.selection;
     var cellNode, cellPos;
-
     if (!(sel instanceof CellSelection)) {
       cellNode = cellWrapping(sel.$from);
-
       if (!cellNode) {
         return false;
       }
-
       var 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) {
       var cellAttrs = cellNode.attrs,
-          attrs = [],
-          colwidth = cellAttrs.colwidth;
-
+        attrs = [],
+        colwidth = cellAttrs.colwidth;
       if (cellAttrs.rowspan && cellAttrs.rowspan > 1) {
         cellAttrs = _objectSpread(_objectSpread({}, cellAttrs), {}, {
           rowspan: 1
         });
       }
-
       if (cellAttrs.colspan && cellAttrs.colspan > 1) {
         cellAttrs = _objectSpread(_objectSpread({}, cellAttrs), {}, {
           colspan: 1
         });
       }
-
       var rect = selectedRect(state);
       var tr = state.tr;
-
       for (var i = 0; i < rect.right - rect.left; i++) {
         attrs.push(colwidth ? _objectSpread(_objectSpread({}, cellAttrs), {}, {
           colwidth: colwidth && colwidth[i] ? [colwidth[i]] : null
         }) : cellAttrs);
       }
-
       var lastCell = null;
-
       for (var row = rect.top; row < rect.bottom; row++) {
         var pos = rect.map.positionAt(row, rect.left, rect.table);
-
         if (row === rect.top) {
           pos += cellNode.nodeSize;
         }
-
         for (var col = rect.left, _i = 0; col < rect.right; col++, _i++) {
           if (col === rect.left && row === rect.top) {
             continue;
           }
-
           var cellType = getCellType({
             node: cellNode,
             row: row,
             col: 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,
@@ -108,16 +86,12 @@ export function splitCellWithType(getCellType) {
           col: rect.left
         }), attrs[0]);
       }
-
       var $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/esm/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 var splitCell = function splitCell(state, dispatch) {
   var nodeTypes = tableNodeTypes(state.schema);
   return splitCellWithType(function (_ref) {

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

@@ -1,20 +1,17 @@
 export function tableNodeTypes(schema) {
   var 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 (var name in schema.nodes) {
       var type = schema.nodes[name];
       var role = type.spec.tableRole;
-
       if (role) {
         result[role] = type;
       }
     }
   }
-
   return result;
 }

package/dist/esm/utils/tables.js

@@ -1,12 +1,10 @@
 export function isInTable(state) {
   var $head = state.selection.$head;
-
   for (var 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/esm/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 var addRowBefore = function addRowBefore(state, dispatch) {
   if (!isInTable(state)) {
     return false;
   }
-
   if (dispatch) {
     var 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 var addRowAfter = function addRowAfter(state, dispatch) {
   if (!isInTable(state)) {
     return false;
   }
-
   if (dispatch) {
     var 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 var addColumnBefore = function addColumnBefore(state, dispatch) {
   if (!isInTable(state)) {
     return false;
   }
-
   if (dispatch) {
     var 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 var addColumnAfter = function addColumnAfter(state, dispatch) {
   if (!isInTable(state)) {
     return false;
   }
-
   if (dispatch) {
     var rect = selectedRect(state);
     dispatch(addColumn(state.tr, rect, rect.right));
   }
-
   return true;
 };

package/dist/esm/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 (var i = 0; i < cellPositions.length; i++) {
     var 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) {
       var types = tableNodeTypes(state.schema);
       var rect = selectedRect(state),
-          tr = state.tr;
+        tr = state.tr;
       var isHeaderRowEnabled = isHeaderEnabledByType('row', rect, types);
       var isHeaderColumnEnabled = isHeaderEnabledByType('column', rect, types);
       var isHeaderEnabled = type === 'column' ? isHeaderRowEnabled : type === 'row' ? isHeaderColumnEnabled : false;
       var selectionStartsAt = isHeaderEnabled ? 1 : 0;
       var cellsRect = type === 'column' ? new Rect(0, selectionStartsAt, 1, rect.map.height) : type === 'row' ? new Rect(selectionStartsAt, 0, rect.map.width, 1) : rect;
       var 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(function (relativeCellPos) {
         var cellPos = relativeCellPos + rect.tableStart;
         var cell = tr.doc.nodeAt(cellPos);
-
         if (cell) {
           tr.setNodeMarkup(cellPos, newType, cell.attrs);
         }
       });
       dispatch(tr);
     }
-
     return true;
   };
 }

package/dist/esm/version.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/editor-tables",
-  "version": "2.2.4",
+  "version": "2.2.6",
   "description": "A package that contains common classes and utility functions for editor tables",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
@@ -29,8 +29,8 @@
     "prosemirror-view": "1.23.2"
   },
   "devDependencies": {
-    "@atlaskit/adf-schema": "^25.1.0",
-    "@atlaskit/editor-test-helpers": "^18.0.0",
+    "@atlaskit/adf-schema": "^25.5.0",
+    "@atlaskit/editor-test-helpers": "^18.2.0",
     "@atlassian/atlassian-frontend-prettier-config-1.0.1": "npm:@atlassian/atlassian-frontend-prettier-config@1.0.1"
   },
   "techstack": {
@@ -42,7 +42,9 @@
     },
     "@repo/internal": {
       "deprecation": "no-deprecated-imports",
-      "theming": "tokens",
+      "design-tokens": [
+        "color"
+      ],
       "styling": [
         "emotion"
       ]