@atlaskit/adf-schema 29.2.0 → 30.0.1

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

@@ -1,373 +0,0 @@
-import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-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(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-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 '@atlaskit/editor-prosemirror/transform';
-import { cellsAtColumn } from './utils/cells-at-column';
-import { findColumn } from './utils/find-column';
-import { getTableRectFromDoc } from './utils/get-table-rect-from-doc';
-import { applyCellStep, createCellStep, getMapFromCellStep, invertCellStep } from './utils/cell-step';
-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;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var cellInfo = _step.value;
-      cellsFrom.push(cellInfo.from);
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } 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
- * | 5  | 10 | 15 |   -> Table with Positions
- * | 20 | 25 | 30 |
- * 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;
-    _this.sideEffectsHandler = new SideEffectsHandler(addColumnStepInfo.sideEffects);
-    _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.
-   * If isDelete
-   *    Decrease colspan if one row has merged cell
-   *    Remove all the cells using columnInfo.cellStep[].from
-   * else
-   *    Increase colspan if one row had merged cell
-   *    Add all new cells at columnInfo.cellStep[].from,
-   *      if there is columnInfo.cellStep[].newCell use it
-   *      else create an empty cell
-   *
-   * @param doc Current document
-   */
-  _createClass(AddColumnStep, [{
-    key: "apply",
-    value: function apply(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);
-
-      // 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
-     * if cellStep.length === 0 remove the 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;
-      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) {
-        _iterator2.e(err);
-      } 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
-     *    Create a copy of the node
-     *    Create a new cellStep with the same positions but with the clone node as a content
-     *    return new step inverted
-     * else
-     *    Remove the content from each columnInfo.cellStep[].content
-     *    return new step inverted
-     * @param originalDoc
-     */
-  }, {
-    key: "invert",
-    value: function invert(originalDoc) {
-      var _this2 = this;
-      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.
-      var newCellSteps = Array.from(this.columnInfo.values(), function (oldCellStep) {
-        var newCellStep = invertCellStep(originalDoc, getTableRectAndColumn, oldCellStep, _this2.isDelete, stepMap);
-        return newCellStep;
-      });
-      var sideEffects = this.sideEffectsHandler.invert(originalDoc, this.isDelete, stepMap);
-      return new AddColumnStep(this.tablePos, {
-        cells: newCellSteps,
-        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)
-     * if isDelete
-     *    Create range array based on cell info where each range is [cellStep.from, cellStep.from - cellStep.to, 0]
-     * else
-     *    Create range array base on cell info where each range is [cellStep.from, 0, cellStep.content ? cellStep.content.nodeSize : defaultEmptyCellNodeSize]
-     *
-     * Ranges in ProseMirror are represented by each 3 elements in an array.
-     * As [pos, currentSize, newSize, pos2, currentSize2, newSize2] where:
-     * pos: Position in the document
-     * 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;
-      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) {
-        _iterator3.e(err);
-      } finally {
-        _iterator3.f();
-      }
-      ranges = this.sideEffectsHandler.rows.addRowRanges(ranges, this.isDelete);
-
-      // 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() {
-      var addColumnStepJson = {
-        stepType: ADD_COLUMN_STEP,
-        tablePos: this.tablePos,
-        cells: Array.from(this.columnInfo.values(), function (cellStep) {
-          var cellStepJson = {
-            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
-      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 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)
-        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.
-        newColumnInfo.set(newCellStep.from, cellStep);
-        next = iter.next(skipRows);
-      }
-      rowsHandler.end(tr, tableRect, column);
-      return newColumnInfo;
-    }
-  }], [{
-    key: "fromJSON",
-    value: function fromJSON(schema, json) {
-      // TODO: Add validation. Return null if it is invalid. Check in review if this is necessary
-      var cells = json.cells.map(function (cellsJson) {
-        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
-      }, json.isDelete);
-    }
-  }, {
-    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 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 +0,0 @@
-export var SortOrder = /*#__PURE__*/function (SortOrder) {
-  SortOrder["ASC"] = "asc";
-  SortOrder["DESC"] = "desc";
-  return SortOrder;
-}({});

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

@@ -1,60 +0,0 @@
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-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 '@atlaskit/editor-prosemirror/model';
-import { ReplaceStep, Step, StepMap, StepResult } from '@atlaskit/editor-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() {
-      return new TableSortStep(this.pos, this.next, this.prev);
-    }
-  }, {
-    key: "apply",
-    value: function apply(doc) {
-      return StepResult.ok(doc);
-    }
-  }, {
-    key: "map",
-    value: function map() {
-      return null;
-    }
-  }, {
-    key: "getMap",
-    value: function getMap() {
-      return new StepMap([0, 0, 0]);
-    }
-  }, {
-    key: "toJSON",
-    value: function toJSON() {
-      return {
-        stepType: tableSortingStepType
-      };
-    }
-  }], [{
-    key: "fromJSON",
-    value: function fromJSON() {
-      return new ReplaceStep(0, 0, Slice.empty);
-    }
-  }]);
-  return TableSortStep;
-}(Step);
-
-/** Register this step with Prosemirror */
-Step.jsonID(tableSortingStepType, TableSortStep);

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

@@ -1 +0,0 @@
-export {};

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

@@ -1,192 +0,0 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-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).
- * @param tr
- * @param tableRect
- * @param cell
- * @param cellStep
- * @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);
-      return {
-        tr: tr,
-        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
-    cellStep.from = cellStep.mergeWith;
-    cellStep.to = cellStep.from + cellNode.nodeSize;
-    cellStep.mergeWith = undefined;
-  }
-  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 {
-    if (cellStep.newCell) {
-      tr.insert(tr.mapping.map(cellStep.from), cellStep.newCell);
-      skipRows = calculateRowsToSkip(cellStep.newCell.attrs);
-    } else {
-      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
- *  are skipped by the all the changes except your own. (StepMap.map is not valid)
- * @param map
- * @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];
-  return map.map(cellStep.from) - cellStep.from - (newSize - oldSize);
-}
-
-/**
- * Given a cell step, this function invert that step.
- * @param doc
- * @param getTableRectAndColumn
- * @param cellStep
- * @param isDelete
- * @param stepMap
- */
-export function invertCellStep(doc, getTableRectAndColumn, cellStep, isDelete, stepMap) {
-  /**
-   * We need a correct map when a cell is added
-   * We need the normal map position minus the size of the cell you added it. Why?
-   * Having a table 3x3 and we add a new column at 2 creates this ranges
-   * [
-   *  10, 0, 4,
-   *  20, 0, 4,
-   *  30, 0, 4,
-   *  ]
-   *  Where:
-   *    * [10, 20, 30] are the original cell positions where we add the cells
-   *    * [0, 0, 0] are the old size. We are adding new cells, so it's always zero
-   *    * [4, 4, 4] are the new size. In this case, we are adding empty cell and has size 4, this will be different for prefill cells.
-   *  In the document generated the cells that I want to delete (if I invert this step) are [10, 24, 38]
-   *  this is calculated in the given way
-   *    * Map the position using this step mapping function, this will return the cell in the next column
-   *    * Remove the diff (4 - 0 in this case) of the current position.
-   *  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.
-    // 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;
-    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
- * @param column
- * @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;
-}