@atlaskit/adf-schema 19.2.0

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

@@ -0,0 +1,6 @@
+export var SortOrder;
+
+(function (SortOrder) {
+  SortOrder["ASC"] = "asc";
+  SortOrder["DESC"] = "desc";
+})(SortOrder || (SortOrder = {}));

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

@@ -0,0 +1,69 @@
+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 '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() {
+      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

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

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

@@ -0,0 +1,216 @@
+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); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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).
+ * @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;
+}

package/dist/esm/steps/table/utils/cells-at-column.js

@@ -0,0 +1,84 @@
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+
+var _marked = /*#__PURE__*/_regeneratorRuntime.mark(cellsAtColumn);
+
+import { columnIsHeader, tableNodeTypes } from '@atlaskit/editor-tables/utils';
+import { getCellIndex, hasMergedColumns, isRootRow } from './table-map';
+
+/**
+ * Helper to have a consistent way to iterate for all the cells in a column.
+ * You can skip rows by passing the rows to skipped in the next arguments.
+ * For example: `iter.next(1)` to skip the next row
+ * @param rect
+ * @param col
+ */
+export function cellsAtColumn(rect, col) {
+  var map, tableStart, table, refColumn, row, index, pos, hasMergedCells, type, cell, cellInfo, skippedRows;
+  return _regeneratorRuntime.wrap(function cellsAtColumn$(_context) {
+    while (1) {
+      switch (_context.prev = _context.next) {
+        case 0:
+          map = rect.map, tableStart = rect.tableStart, table = rect.table;
+          refColumn = col > 0 ? -1 : 0;
+
+          if (columnIsHeader(map, table, col + refColumn)) {
+            refColumn = col === 0 || col === map.width ? null : 0;
+          }
+
+          row = 0;
+
+        case 4:
+          if (!(row < map.height)) {
+            _context.next = 20;
+            break;
+          }
+
+          index = getCellIndex(rect.map, row, col);
+          pos = map.map[index]; // We only consider to has merged cell to the first cell in a rowspan.
+
+          hasMergedCells = hasMergedColumns(rect.map, row, col) && isRootRow(rect.map, row, col); // If this position falls inside a col-spanning cell
+
+          type = refColumn == null ? tableNodeTypes(table.type.schema).cell : table.nodeAt(map.map[index + refColumn]).type;
+
+          if (!hasMergedCells) {
+            pos = map.positionAt(row, col, table);
+          }
+
+          cell = table.nodeAt(pos);
+          cellInfo = {
+            from: tableStart + pos,
+            to: tableStart + pos,
+            row: row,
+            col: hasMergedCells ? map.colCount(pos) : col,
+            type: type,
+            hasMergedCells: hasMergedCells
+          };
+
+          if (cell) {
+            cellInfo.attrs = cell.attrs;
+            cellInfo.to = tableStart + pos + cell.nodeSize;
+          } // We let the consumer to pass the rows that we want to skip
+
+
+          _context.next = 15;
+          return cellInfo;
+
+        case 15:
+          skippedRows = _context.sent;
+
+          if (skippedRows && skippedRows > 0) {
+            row += skippedRows;
+          }
+
+        case 17:
+          row++;
+          _context.next = 4;
+          break;
+
+        case 20:
+        case "end":
+          return _context.stop();
+      }
+    }
+  }, _marked);
+}

package/dist/esm/steps/table/utils/find-column.js

@@ -0,0 +1,87 @@
+/**
+ * Try to find the right column based on the cell steps in column info..
+ * @param columnInfo  - Map of cell positions sorted from lower to greather
+ * @param rect - map rect
+ */
+export function findColumn(columnInfo, rect) {
+  /**
+   * Algorithm explained
+   * Given a table like this:
+   *    | 5  | 10      |
+   *    | 15      | 20 |
+   *    | 25 | 30 | 35 |
+   * Represented by a table map like this:
+   *   rect.map = [5, 10, 10,
+   *              15, 15, 20,
+   *              25, 30, 35]
+   * And a have this inputs:
+   *   columnInfo[].from = [10, 15, 30]
+   *
+   * Algorithm:
+   *    * Initial state
+   *      start = 0;
+   *      end = 2 (rect.width - 1 === 3 - 1)
+   *    * Iterate until find first cell position
+   *      start = 1
+   *      end = 2 (min(start column + colspan - 1, start column + end column))
+   *    * Iterate until find second cell position
+   *      start = 1
+   *      end = 1
+   *    * Start === end return 1
+   */
+  // Initial range (start and end column) to search for each row
+  var start = 0,
+      end = rect.map.width - 1;
+  var iter = columnInfo.values();
+  var next = iter.next(); // Iterate for each row
+
+  for (var row = 0; row < rect.map.height; row++) {
+    if (next.done) {
+      break;
+    } // Iterate for the column. Starting with the current start range
+
+
+    for (var col = start; col <= end; col++) {
+      var i = row * rect.map.width + col;
+      var cell = rect.map.map[i];
+      var cellInfo = next.value.from - rect.tableStart; // When cell is found update range with the new values
+
+      if (cell === cellInfo) {
+        start = col; // Start column will be the current column
+        // Try to find the end column. End column will be different that start when has merged cells.
+
+        var endIndex = end - start + i;
+
+        for (var j = i; j <= endIndex; j++) {
+          if (rect.map.map[j] !== cell) {
+            break;
+          } // merged columns
+
+
+          end = start + j - i; // Update the end column with the new position
+        }
+
+        if (start === end) {
+          // We found the right column only when start and end columns are the same.
+          return start;
+        }
+
+        next = iter.next();
+        break;
+      } // Sometimes I want to find a column at the end of the table (It doesn't exist, but we can add a new cell there).
+      // This is represented by the end position of the last cell in the column.
+      // In this case return, table width
+
+
+      if (col === rect.map.width - 1) {
+        var cellNode = rect.table.nodeAt(cell);
+
+        if (cell + cellNode.nodeSize === cellInfo) {
+          return rect.map.width;
+        }
+      }
+    }
+  }
+
+  return null;
+}