@atlaskit/adf-schema 25.1.0 → 25.2.0

package/dist/esm/steps/table/add-column.js

@@ -5,21 +5,13 @@ import _createClass from "@babel/runtime/helpers/createClass";
 import _inherits from "@babel/runtime/helpers/inherits";
 import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
 import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
-
 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; }
-
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
-
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
-
 import { Step, StepMap, StepResult, Transform } from 'prosemirror-transform';
 import { cellsAtColumn } from './utils/cells-at-column';
 import { findColumn } from './utils/find-column';
@@ -28,13 +20,10 @@ import { applyCellStep, createCellStep, getMapFromCellStep, invertCellStep } fro
 import { SideEffectsHandler } from './utils/side-effects/side-effects';
 import memoizeOne from 'memoize-one';
 var ADD_COLUMN_STEP = 'ak-add-column';
-
 function printColumnInfo(columnInfo) {
   var cellsFrom = [];
-
   var _iterator = _createForOfIteratorHelper(columnInfo.values()),
-      _step;
-
+    _step;
   try {
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
       var cellInfo = _step.value;
@@ -45,31 +34,27 @@ function printColumnInfo(columnInfo) {
   } finally {
     _iterator.f();
   }
-
   return "[".concat(cellsFrom.join(','), "]");
 }
-
 function createColumnInfo(cellsInfo) {
   return new Map(cellsInfo.map(function (cellInfo) {
     return [cellInfo.from, cellInfo];
   }));
 }
-
 var getTableRectAndColumnFactory = function getTableRectAndColumnFactory(doc, pos, columnInfo) {
   return memoizeOne(function () {
     var rect = getTableRectFromDoc(doc, pos);
     var column = findColumn(columnInfo, rect);
-
     if (column === null) {
       throw new Error('no column');
     }
-
     return {
       rect: rect,
       column: column
     };
   });
 };
+
 /**
  * Index and positions looks like
  * 0    1    2    3   -> Add Column Index
@@ -78,20 +63,13 @@ var getTableRectAndColumnFactory = function getTableRectAndColumnFactory(doc, po
  * 0    1    2    x   -> Remove Column Index
  *
  */
-
-
 export var AddColumnStep = /*#__PURE__*/function (_Step) {
   _inherits(AddColumnStep, _Step);
-
   var _super = _createSuper(AddColumnStep);
-
   function AddColumnStep(tablePos, addColumnStepInfo) {
     var _this;
-
     var isDelete = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-
     _classCallCheck(this, AddColumnStep);
-
     _this = _super.call(this);
     _this.tablePos = tablePos;
     _this.isDelete = isDelete;
@@ -99,6 +77,7 @@ export var AddColumnStep = /*#__PURE__*/function (_Step) {
     _this.columnInfo = createColumnInfo(addColumnStepInfo.cells);
     return _this;
   }
+
   /**
    * Detect the column based on all the cells step in column info.
    * Recreate columnInfo based on the current document. We might need to add new cells added by insert row or unmerge cells.
@@ -113,41 +92,34 @@ export var AddColumnStep = /*#__PURE__*/function (_Step) {
    *
    * @param doc Current document
    */
-
-
   _createClass(AddColumnStep, [{
     key: "apply",
     value: function apply(doc) {
-      var tablePos = this.tablePos; // Create transform base on the doc
-
+      var tablePos = this.tablePos;
+      // Create transform base on the doc
       var tr = new Transform(doc);
-
       if (this.sideEffectsHandler.table.handleAddTable(tr, this.isDelete)) {
         return StepResult.ok(tr.doc);
       }
-
       var tableRect;
-
       try {
         tableRect = getTableRectFromDoc(doc, tablePos);
       } catch (e) {
         return StepResult.fail(e.message);
       }
-
       var column = findColumn(this.columnInfo, tableRect);
-
       if (column === null) {
         return StepResult.fail("No column for this cells \"".concat(printColumnInfo(this.columnInfo), "\" in table at position \"").concat(tablePos, "\"."));
       }
-
       if (this.sideEffectsHandler.table.handleRemoveTable(tr, this.tablePos, tableRect, column, this.isDelete)) {
         return StepResult.ok(tr.doc);
       }
+      this.columnInfo = this.applyCellSteps(tr, tableRect, column, this.isDelete);
 
-      this.columnInfo = this.applyCellSteps(tr, tableRect, column, this.isDelete); // Return the document modified.
-
+      // Return the document modified.
       return StepResult.ok(tr.doc);
     }
+
     /**
      * Update tablePos with the new position. If tablePos doesnt exist any more remove the step
      * Update all the cellStep inside columnInfo. If cellStep.from position gets deleted removed it from column info
@@ -155,41 +127,32 @@ export var AddColumnStep = /*#__PURE__*/function (_Step) {
      * Create a new step with all the position updated
      * @param mapping
      */
-
   }, {
     key: "map",
     value: function map(mapping) {
       var tablePosResult = mapping.mapResult(this.tablePos);
-
       if (tablePosResult.deleted) {
         // If table was deleted remove the step
         return null;
       }
-
       var cellSteps = [];
-
       var _iterator2 = _createForOfIteratorHelper(this.columnInfo.values()),
-          _step2;
-
+        _step2;
       try {
         for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
           var oldCellStep = _step2.value;
           var fromResult = mapping.mapResult(oldCellStep.from);
           var toResult = mapping.mapResult(oldCellStep.to);
-
           if (fromResult.deleted && toResult.deleted) {
             continue;
           }
-
           var cellStep = _objectSpread(_objectSpread({}, oldCellStep), {}, {
             from: fromResult.pos,
             to: toResult.pos
           });
-
           if (oldCellStep.mergeWith !== undefined) {
             cellStep.mergeWith = mapping.map(oldCellStep.mergeWith);
           }
-
           cellSteps.push(cellStep);
         }
       } catch (err) {
@@ -197,17 +160,16 @@ export var AddColumnStep = /*#__PURE__*/function (_Step) {
       } finally {
         _iterator2.f();
       }
-
       if (cellSteps.length === 0) {
         return null;
       }
-
       var sideEffects = this.sideEffectsHandler.map(mapping);
       return new AddColumnStep(tablePosResult.pos, {
         cells: cellSteps,
         sideEffects: sideEffects
       }, this.isDelete);
     }
+
     /**
      * if isDelete
      *    Get the original cell node at columnInfo.cellStep[].from to columnInfo.cellStep[].to
@@ -219,16 +181,15 @@ export var AddColumnStep = /*#__PURE__*/function (_Step) {
      *    return new step inverted
      * @param originalDoc
      */
-
   }, {
     key: "invert",
     value: function invert(originalDoc) {
       var _this2 = this;
+      var stepMap = this.getMap();
 
-      var stepMap = this.getMap(); // Memoize function to be called only on delete scenarios
-
-      var getTableRectAndColumn = getTableRectAndColumnFactory(originalDoc, this.tablePos, this.columnInfo); // This is needed because the real pos of the cell in the generated document is affected by the previous operations.
-
+      // Memoize function to be called only on delete scenarios
+      var getTableRectAndColumn = getTableRectAndColumnFactory(originalDoc, this.tablePos, this.columnInfo);
+      // This is needed because the real pos of the cell in the generated document is affected by the previous operations.
       var newCellSteps = Array.from(this.columnInfo.values(), function (oldCellStep) {
         var newCellStep = invertCellStep(originalDoc, getTableRectAndColumn, oldCellStep, _this2.isDelete, stepMap);
         return newCellStep;
@@ -239,6 +200,7 @@ export var AddColumnStep = /*#__PURE__*/function (_Step) {
         sideEffects: sideEffects
       }, !this.isDelete);
     }
+
     /**
      * StepMap is created based on columnInfo.
      * ColumnInfo is created on constructor and once is applied (the document could have new cells that weren't part of the original set)
@@ -253,27 +215,20 @@ export var AddColumnStep = /*#__PURE__*/function (_Step) {
      * currentSize: Represent the affected range, this will be pos + currentSize
      * newSize: Represent the new values, pos + newSize
      */
-
   }, {
     key: "getMap",
     value: function getMap() {
       var tableMap = this.sideEffectsHandler.getTableMap(this.isDelete);
-
       if (tableMap) {
         return tableMap;
       }
-
       var ranges = [];
-
       var _iterator3 = _createForOfIteratorHelper(this.columnInfo.values()),
-          _step3;
-
+        _step3;
       try {
         for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
           var _ranges;
-
           var cellStep = _step3.value;
-
           (_ranges = ranges).push.apply(_ranges, _toConsumableArray(getMapFromCellStep(cellStep, this.isDelete)));
         }
       } catch (err) {
@@ -281,30 +236,30 @@ export var AddColumnStep = /*#__PURE__*/function (_Step) {
       } finally {
         _iterator3.f();
       }
+      ranges = this.sideEffectsHandler.rows.addRowRanges(ranges, this.isDelete);
 
-      ranges = this.sideEffectsHandler.rows.addRowRanges(ranges, this.isDelete); // If no steps, I create am empty stepMap
-
+      // If no steps, I create am empty stepMap
       return new StepMap(ranges);
     }
+
     /**
      * Try to merge this step with another one, to be applied directly
      * after it. Returns the merged step when possible, null if the
      * steps can't be merged.
      */
-
   }, {
     key: "merge",
     value: function merge(other) {
       // We cannot merge add column step at the moment
       return null;
     }
+
     /**
      * Create a JSON-serializeable representation of this step. When
      * defining this for a custom subclass, make sure the result object
      * includes the step type's [JSON id](#transform.Step^jsonID) under
      * the `stepType` property.
      */
-
   }, {
     key: "toJSON",
     value: function toJSON() {
@@ -316,62 +271,56 @@ export var AddColumnStep = /*#__PURE__*/function (_Step) {
             from: cellStep.from,
             to: cellStep.to
           };
-
           if (cellStep.mergeWith !== undefined) {
             cellStepJson.mergeWith = cellStep.mergeWith;
           }
-
           if (cellStep.newCell !== undefined) {
             cellStepJson.newCell = cellStep.newCell.toJSON();
           }
-
           return cellStepJson;
         }),
         isDelete: this.isDelete
       };
       var sideEffectsJSON = this.sideEffectsHandler.toJSON();
-
       if (sideEffectsJSON) {
         addColumnStepJson.sideEffects = sideEffectsJSON;
       }
-
       return addColumnStepJson;
     }
+
     /**
      * Deserialize a step from its JSON representation. Will call
      * through to the step class' own implementation of this method.
      */
-
   }, {
     key: "applyCellSteps",
     value: function applyCellSteps(tr, tableRect, column, isDelete) {
       var newColumnInfo = new Map();
       var rowsHandler = this.sideEffectsHandler.rows.start(this.isDelete);
       var iter = cellsAtColumn(tableRect, column);
-      var next = iter.next(); // Iterate for all the cells in the current document
-
+      var next = iter.next();
+      // Iterate for all the cells in the current document
       while (!next.done) {
         var cell = next.value;
         var previousCellStep = this.columnInfo.get(cell.from);
-        var newCellStep = createCellStep(cell, column, isDelete, previousCellStep); // If is the last cell in the row and doesnt have colspan I need to remove the whole row.
+        var newCellStep = createCellStep(cell, column, isDelete, previousCellStep);
 
+        // If is the last cell in the row and doesnt have colspan I need to remove the whole row.
         var removeRowResult = rowsHandler.handle(tr, tableRect, cell.row, column, cell);
-
         if (removeRowResult.handled) {
           next = iter.next(removeRowResult.skipRows);
           continue;
-        } // Apply the step, to the pseudo document, get rows to skip, and the cellstep (might be modified, for example, a merge cell that remove the cell instead)
-
+        }
 
+        // Apply the step, to the pseudo document, get rows to skip, and the cellstep (might be modified, for example, a merge cell that remove the cell instead)
         var _applyCellStep = applyCellStep(tr, tableRect, cell, newCellStep, isDelete, column),
-            skipRows = _applyCellStep.skipRows,
-            cellStep = _applyCellStep.cellStep; // Store the new cell step. This could be an existing one or a new cell.
-
+          skipRows = _applyCellStep.skipRows,
+          cellStep = _applyCellStep.cellStep;
 
+        // Store the new cell step. This could be an existing one or a new cell.
         newColumnInfo.set(newCellStep.from, cellStep);
         next = iter.next(skipRows);
       }
-
       rowsHandler.end(tr, tableRect, column);
       return newColumnInfo;
     }
@@ -383,15 +332,12 @@ export var AddColumnStep = /*#__PURE__*/function (_Step) {
         var cell = _objectSpread(_objectSpread({}, cellsJson), {}, {
           newCell: cellsJson.newCell ? schema.nodeFromJSON(cellsJson.newCell) : undefined
         });
-
         return cell;
       });
       var sideEffects;
-
       if (json.sideEffects) {
         sideEffects = SideEffectsHandler.fromJSON(schema, json.sideEffects);
       }
-
       return new AddColumnStep(json.tablePos, {
         cells: cells,
         sideEffects: sideEffects
@@ -401,31 +347,27 @@ export var AddColumnStep = /*#__PURE__*/function (_Step) {
     key: "create",
     value: function create(doc, tablePos, column) {
       var isDelete = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-      var tableRect = getTableRectFromDoc(doc, tablePos); // By default add column will rely on default behaviour (add empty cell).
-      // There is no need to add content
+      var tableRect = getTableRectFromDoc(doc, tablePos);
 
+      // By default add column will rely on default behaviour (add empty cell).
+      // There is no need to add content
       var cells = [];
       var iter = cellsAtColumn(tableRect, column);
       var next = iter.next();
-
       while (!next.done) {
         var cell = next.value;
         cells.push(createCellStep(cell, column, isDelete));
         var skipRows = 0;
-
         if (cell.attrs && cell.attrs.rowspan) {
           skipRows = cell.attrs.rowspan - 1;
         }
-
         next = iter.next(skipRows);
       }
-
       return new AddColumnStep(tablePos, {
         cells: cells
       }, isDelete);
     }
   }]);
-
   return AddColumnStep;
 }(Step);
 Step.jsonID(ADD_COLUMN_STEP, AddColumnStep);

package/dist/esm/steps/table/constants.js

@@ -1,5 +1,4 @@
 export var SortOrder;
-
 (function (SortOrder) {
   SortOrder["ASC"] = "asc";
   SortOrder["DESC"] = "desc";

package/dist/esm/steps/table/sort-column.js

@@ -3,31 +3,23 @@ import _createClass from "@babel/runtime/helpers/createClass";
 import _inherits from "@babel/runtime/helpers/inherits";
 import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
 import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
-
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
 import { Slice } from 'prosemirror-model';
 import { ReplaceStep, Step, StepMap, StepResult } from 'prosemirror-transform';
 export var tableSortingStepType = 'atlaskit-table-sorting-ordering';
 export var TableSortStep = /*#__PURE__*/function (_Step) {
   _inherits(TableSortStep, _Step);
-
   var _super = _createSuper(TableSortStep);
-
   function TableSortStep(pos, prev, next) {
     var _this;
-
     _classCallCheck(this, TableSortStep);
-
     _this = _super.call(this);
     _this.prev = prev;
     _this.next = next;
     _this.pos = pos;
     return _this;
   }
-
   _createClass(TableSortStep, [{
     key: "invert",
     value: function invert() {
@@ -61,9 +53,8 @@ export var TableSortStep = /*#__PURE__*/function (_Step) {
       return new ReplaceStep(0, 0, Slice.empty);
     }
   }]);
-
   return TableSortStep;
 }(Step);
-/** Register this step with Prosemirror */
 
+/** Register this step with Prosemirror */
 Step.jsonID(tableSortingStepType, TableSortStep);

package/dist/esm/steps/table/utils/cell-step.js

@@ -1,20 +1,16 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-
 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 { addColSpan, removeColSpan } from '@atlaskit/editor-tables/utils';
 var EmptyCellNodeSize = 4;
-
 function calculateRowsToSkip(attrs) {
   if (attrs && attrs.rowspan) {
     return attrs.rowspan - 1;
   }
-
   return 0;
 }
+
 /**
  * Given a cell step, this function has to do the specific transformation to executed that step.
  * It returns the applied cellStep and rows that needs to skip (because it was already handled).
@@ -25,15 +21,12 @@ function calculateRowsToSkip(attrs) {
  * @param isDelete
  * @param column
  */
-
-
 export function applyCellStep(tr, tableRect, cell, cellStep, isDelete, column) {
   // Apply the merge actions,
   if (cellStep.mergeWith !== undefined) {
     var cellNode = tr.doc.nodeAt(tr.mapping.map(cellStep.mergeWith));
     var columns = column - tableRect.map.colCount(cellStep.mergeWith - tableRect.tableStart);
     var cellAttrs = isDelete ? removeColSpan(cellNode.attrs, columns) : addColSpan(cellNode.attrs, columns);
-
     if (cellAttrs.colspan > 0) {
       // When colspan is 0 should remove the cell
       tr.setNodeMarkup(tr.mapping.map(cellStep.mergeWith), undefined, cellAttrs);
@@ -42,20 +35,18 @@ export function applyCellStep(tr, tableRect, cell, cellStep, isDelete, column) {
         skipRows: calculateRowsToSkip(cellAttrs),
         cellStep: cellStep
       };
-    } // When the new colspan is 0, I need to change the operation to a delete operation
-    // Update cellStep with the proper data
-
+    }
 
+    // When the new colspan is 0, I need to change the operation to a delete operation
+    // Update cellStep with the proper data
     cellStep.from = cellStep.mergeWith;
     cellStep.to = cellStep.from + cellNode.nodeSize;
     cellStep.mergeWith = undefined;
   }
-
-  var skipRows = 0; // Modify temporary document
-
+  var skipRows = 0;
+  // Modify temporary document
   if (isDelete) {
     var _cellNode = tr.doc.nodeAt(tr.mapping.map(cellStep.from));
-
     skipRows = calculateRowsToSkip(_cellNode.attrs);
     tr.delete(tr.mapping.map(cellStep.from), tr.mapping.map(cellStep.to));
   } else {
@@ -66,35 +57,33 @@ export function applyCellStep(tr, tableRect, cell, cellStep, isDelete, column) {
       tr.insert(tr.mapping.map(cellStep.from), cell.type.createAndFill());
     }
   }
-
   return {
     tr: tr,
     skipRows: skipRows,
     cellStep: cellStep
   };
 }
+
 /**
  * Given a cell step, this functions return un StepMap representing this action.
  * [position, oldSize, newSize]
  * @param cellStep
  * @param isDelete
  */
-
 export function getMapFromCellStep(cellStep, isDelete) {
   if (cellStep.mergeWith !== undefined) {
     return [cellStep.mergeWith, 1, 1];
   }
-
   if (isDelete) {
     return [cellStep.from, cellStep.to - cellStep.from, 0];
   } else {
     if (cellStep.newCell) {
       return [cellStep.from, 0, cellStep.newCell.nodeSize];
     }
-
     return [cellStep.from, 0, EmptyCellNodeSize];
   }
 }
+
 /**
  * Helper to calculate the offset of the inverted cells.
  * When you delete consecutive rows in a single step, the position in the generated document
@@ -103,19 +92,17 @@ export function getMapFromCellStep(cellStep, isDelete) {
  * @param cellStep
  * @param isDelete
  */
-
 function getOffset(map, cellStep, isDelete) {
   if (isDelete) {
     return map.map(cellStep.from) - cellStep.from;
   }
-
   var _getMapFromCellStep = getMapFromCellStep(cellStep, isDelete),
-      _getMapFromCellStep2 = _slicedToArray(_getMapFromCellStep, 3),
-      oldSize = _getMapFromCellStep2[1],
-      newSize = _getMapFromCellStep2[2];
-
+    _getMapFromCellStep2 = _slicedToArray(_getMapFromCellStep, 3),
+    oldSize = _getMapFromCellStep2[1],
+    newSize = _getMapFromCellStep2[2];
   return map.map(cellStep.from) - cellStep.from - (newSize - oldSize);
 }
+
 /**
  * Given a cell step, this function invert that step.
  * @param doc
@@ -124,8 +111,6 @@ function getOffset(map, cellStep, isDelete) {
  * @param isDelete
  * @param stepMap
  */
-
-
 export function invertCellStep(doc, getTableRectAndColumn, cellStep, isDelete, stepMap) {
   /**
    * We need a correct map when a cell is added
@@ -147,40 +132,36 @@ export function invertCellStep(doc, getTableRectAndColumn, cellStep, isDelete, s
    *  For a delete action this not happen, it will always return the right value
    */
   var offset = getOffset(stepMap, cellStep, isDelete);
-
   var newCellStepInfo = _objectSpread(_objectSpread({}, cellStep), {}, {
     // Map the position to position of the generated document
     from: cellStep.from + offset,
     to: cellStep.to + offset
   });
-
   if (cellStep.mergeWith !== undefined) {
     newCellStepInfo.mergeWith = cellStep.mergeWith + offset;
   }
-
   if (isDelete) {
     // Add the removed cell as the new cell of the inverted step
     var removedCell = doc.nodeAt(cellStep.from);
-    newCellStepInfo.newCell = removedCell.copy(removedCell.content); // When we delete a column we can end in a position that doesnt represent the right column.
+    newCellStepInfo.newCell = removedCell.copy(removedCell.content);
+
+    // When we delete a column we can end in a position that doesnt represent the right column.
     // This only happens on merged cell that ends in the deleted column.
     // We need to remap this position to the "next" cell (AKA cellStep.to)
-
     var _getTableRectAndColum = getTableRectAndColumn(),
-        column = _getTableRectAndColum.column,
-        rect = _getTableRectAndColum.rect;
-
+      column = _getTableRectAndColum.column,
+      rect = _getTableRectAndColum.rect;
     if (column < rect.map.width) {
       var isAtTheEnd = rect.map.colCount(cellStep.from - rect.tableStart) + removedCell.attrs.colspan - 1 === column;
-
       if (cellStep.mergeWith !== undefined && isAtTheEnd) {
         newCellStepInfo.mergeWith = newCellStepInfo.from;
         newCellStepInfo.from = newCellStepInfo.to;
       }
     }
   }
-
   return newCellStepInfo;
 }
+
 /**
  * Create a cell step based on the current cell and operation (add/delete)
  * @param cell
@@ -188,29 +169,24 @@ export function invertCellStep(doc, getTableRectAndColumn, cellStep, isDelete, s
  * @param isDelete
  * @param previousCellStep
  */
-
 export function createCellStep(cell, column, isDelete, previousCellStep) {
   var newCellStepInfo = {
     from: cell.from,
     to: cell.to
   };
-
   if (cell.hasMergedCells) {
     // Check what column has to merge
     if (column !== cell.col || isDelete) {
       newCellStepInfo.mergeWith = cell.from;
     }
   }
-
   if (previousCellStep) {
     if (previousCellStep.mergeWith !== undefined) {
       newCellStepInfo.mergeWith = previousCellStep.mergeWith;
     }
-
     if (previousCellStep.newCell) {
       newCellStepInfo.newCell = previousCellStep.newCell;
     }
   }
-
   return newCellStepInfo;
 }