@atlaskit/adf-schema 19.2.0

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

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

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

@@ -0,0 +1,41 @@
+import { Slice } from 'prosemirror-model';
+import { ReplaceStep, Step, StepMap, StepResult } from 'prosemirror-transform';
+export const tableSortingStepType = 'atlaskit-table-sorting-ordering';
+export class TableSortStep extends Step {
+  constructor(pos, prev, next) {
+    super();
+    this.prev = prev;
+    this.next = next;
+    this.pos = pos;
+  }
+
+  invert() {
+    return new TableSortStep(this.pos, this.next, this.prev);
+  }
+
+  apply(doc) {
+    return StepResult.ok(doc);
+  }
+
+  map() {
+    return null;
+  }
+
+  getMap() {
+    return new StepMap([0, 0, 0]);
+  }
+
+  toJSON() {
+    return {
+      stepType: tableSortingStepType
+    };
+  }
+
+  static fromJSON() {
+    return new ReplaceStep(0, 0, Slice.empty);
+  }
+
+}
+/** Register this step with Prosemirror */
+
+Step.jsonID(tableSortingStepType, TableSortStep);

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

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

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

@@ -0,0 +1,204 @@
+import { addColSpan, removeColSpan } from '@atlaskit/editor-tables/utils';
+const 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) {
+    let cellNode = tr.doc.nodeAt(tr.mapping.map(cellStep.mergeWith));
+    const columns = column - tableRect.map.colCount(cellStep.mergeWith - tableRect.tableStart);
+    const 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,
+        skipRows: calculateRowsToSkip(cellAttrs),
+        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;
+  }
+
+  let skipRows = 0; // Modify temporary document
+
+  if (isDelete) {
+    let 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,
+    skipRows,
+    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;
+  }
+
+  const [, oldSize, newSize] = getMapFromCellStep(cellStep, isDelete);
+  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
+   */
+  const offset = getOffset(stepMap, cellStep, isDelete);
+  const newCellStepInfo = { ...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
+    const 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)
+
+    const {
+      column,
+      rect
+    } = getTableRectAndColumn();
+
+    if (column < rect.map.width) {
+      const 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) {
+  const 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/es2019/steps/table/utils/cells-at-column.js

@@ -0,0 +1,57 @@
+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) {
+  const {
+    map,
+    tableStart,
+    table
+  } = rect;
+  let refColumn = col > 0 ? -1 : 0;
+
+  if (columnIsHeader(map, table, col + refColumn)) {
+    refColumn = col === 0 || col === map.width ? null : 0;
+  }
+
+  for (let row = 0; row < map.height; row++) {
+    let index = getCellIndex(rect.map, row, col);
+    let pos = map.map[index]; // We only consider to has merged cell to the first cell in a rowspan.
+
+    const hasMergedCells = hasMergedColumns(rect.map, row, col) && isRootRow(rect.map, row, col); // If this position falls inside a col-spanning cell
+
+    let type = refColumn == null ? tableNodeTypes(table.type.schema).cell : table.nodeAt(map.map[index + refColumn]).type;
+
+    if (!hasMergedCells) {
+      pos = map.positionAt(row, col, table);
+    }
+
+    let cell = table.nodeAt(pos);
+    const cellInfo = {
+      from: tableStart + pos,
+      to: tableStart + pos,
+      row,
+      col: hasMergedCells ? map.colCount(pos) : col,
+      type,
+      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
+
+
+    const skippedRows = yield cellInfo;
+
+    if (skippedRows && skippedRows > 0) {
+      row += skippedRows;
+    }
+  }
+}

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

@@ -0,0 +1,86 @@
+/**
+ * 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
+  let [start, end] = [0, rect.map.width - 1];
+  const iter = columnInfo.values();
+  let next = iter.next(); // Iterate for each row
+
+  for (let row = 0; row < rect.map.height; row++) {
+    if (next.done) {
+      break;
+    } // Iterate for the column. Starting with the current start range
+
+
+    for (let col = start; col <= end; col++) {
+      const i = row * rect.map.width + col;
+      const cell = rect.map.map[i];
+      const 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.
+
+        const endIndex = end - start + i;
+
+        for (let 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) {
+        const cellNode = rect.table.nodeAt(cell);
+
+        if (cell + cellNode.nodeSize === cellInfo) {
+          return rect.map.width;
+        }
+      }
+    }
+  }
+
+  return null;
+}

package/dist/es2019/steps/table/utils/get-table-rect-from-doc.js

@@ -0,0 +1,30 @@
+import { TableMap } from '@atlaskit/editor-tables/table-map';
+/**
+ * Util to get the table rect from the docs
+ * @param doc
+ * @param tablePos
+ */
+
+export function getTableRectFromDoc(doc, tablePos) {
+  const table = doc.nodeAt(tablePos); // Check for table existence
+
+  if (!table || table.type.name !== 'table') {
+    throw new Error(`No table at position "${tablePos}".`);
+  } // Create transform base on the doc
+
+
+  const map = TableMap.get(table);
+  const $table = doc.resolve(tablePos); // Nested tables start position might differ from the original position
+
+  const start = $table.start($table.depth + 1);
+  return {
+    map,
+    table: table,
+    tableStart: start,
+    // Default to zero
+    bottom: 0,
+    left: 0,
+    right: 0,
+    top: 0
+  };
+}

package/dist/es2019/steps/table/utils/side-effects/rows.js

@@ -0,0 +1,297 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { hasMergedColumns } from '../table-map';
+
+function mergedRanges(first, second) {
+  const newRanges = [];
+  const firstLength = first.length;
+  const secondLength = second.length;
+  let i = 0;
+  let j = 0;
+
+  while (i < firstLength && j < secondLength) {
+    if (first[i] < second[j]) {
+      newRanges.push(first[i], first[i + 1], first[i + 2]);
+      i += 3;
+    } else {
+      newRanges.push(second[j], second[j + 1], second[j + 2]);
+      j += 3;
+    }
+  }
+
+  if (i < firstLength) {
+    newRanges.push(...first.slice(i));
+  }
+
+  if (j < secondLength) {
+    newRanges.push(...second.slice(i));
+  }
+
+  return newRanges;
+}
+
+function increaseRowSpan(tr, rect, row) {
+  const {
+    map,
+    tableStart
+  } = rect;
+
+  for (let col = 0; col < map.width; col++) {
+    let index = row * map.width + col;
+    let pos = map.map[index];
+    const mappedPos = tr.mapping.map(pos + tableStart);
+    let attrs = tr.doc.nodeAt(mappedPos).attrs;
+    tr.setNodeMarkup(mappedPos, undefined, { ...attrs,
+      rowspan: attrs.rowspan + 1
+    });
+    col += attrs.colspan - 1;
+  }
+}
+
+function decreaseRowspan(tr, rect, row, colToRemove) {
+  let skipRows = 0;
+  const {
+    map,
+    table,
+    tableStart
+  } = rect;
+
+  for (let col = 0; col < map.width; col++) {
+    let index = row * map.width + col;
+    let pos = map.map[index];
+
+    if (row > 0 && pos === map.map[index - map.width]) {
+      // If this cell starts in the row above, simply reduce its rowspan
+      const mappedPos = tr.mapping.map(pos + tableStart);
+      let attrs = tr.doc.nodeAt(mappedPos).attrs;
+      tr.setNodeMarkup(mappedPos, undefined, { ...attrs,
+        rowspan: attrs.rowspan - 1
+      });
+      col += attrs.colspan - 1;
+    } else if (col === colToRemove) {
+      skipRows = table.nodeAt(pos).attrs.rowspan - 1;
+    }
+  }
+
+  return skipRows;
+}
+
+function isLastCellInRow(rect, row, col) {
+  const rowNode = rect.table.child(row);
+
+  if (!rowNode) {
+    return false;
+  }
+
+  return rowNode.childCount === 1 && !hasMergedColumns(rect.map, row, col);
+}
+
+function removeRowWithLastCell(tr, rect, row, _col) {
+  // Get row pos
+  let from = rect.tableStart;
+
+  for (let i = 0; i < row; i++) {
+    from += rect.table.child(i).nodeSize;
+  }
+
+  const rowNode = rect.table.child(row);
+  let to = from + rowNode.nodeSize; // Create sideEffect and delete the row
+  // We store original row position before modifications
+
+  tr.delete(tr.mapping.map(from), tr.mapping.map(to)); // Change rowspan of all cells except current col and get the rows to skip
+
+  const skipRows = decreaseRowspan(tr, rect, row, _col);
+  return {
+    skipRows,
+    row: {
+      from,
+      to,
+      rowNode: rowNode.copy(rowNode.content)
+    }
+  };
+}
+
+function addRow(tr, rect, prevRow, rowSideEffect) {
+  const cellNode = rowSideEffect.rowNode.child(0);
+  tr.insert(tr.mapping.map(rowSideEffect.from), rowSideEffect.rowNode);
+  increaseRowSpan(tr, rect, prevRow);
+  return cellNode.attrs.rowspan - 1;
+}
+
+export class RowsSideEffectHandler {
+  constructor(rowsSideEffect) {
+    _defineProperty(this, "deleteHandler", () => {
+      const newRows = [];
+      return {
+        handle: (tr, rect, row, col, cell) => {
+          if (!isLastCellInRow(rect, row, col)) {
+            return {
+              handled: false
+            };
+          }
+
+          const {
+            row: rowSideEffect,
+            skipRows
+          } = removeRowWithLastCell(tr, rect, row, col);
+          newRows.push(rowSideEffect);
+          return {
+            handled: true,
+            skipRows: skipRows
+          };
+        },
+        end: () => {
+          if (newRows.length > 0) {
+            this.rows = newRows;
+          } else {
+            this.rows = undefined;
+          }
+        }
+      };
+    });
+
+    _defineProperty(this, "addHandler", () => {
+      let lastCellFrom = 0;
+      let i = 0;
+      return {
+        handle: (tr, rect, row, col, cell) => {
+          // // If not sideEffects stored return;
+          if (!this.rows || i >= this.rows.length) {
+            return {
+              handled: false
+            };
+          } // Next row to add;
+
+
+          let skipRows;
+          let nextRow;
+
+          while ((nextRow = this.rows[i]) && nextRow.from > lastCellFrom && nextRow.from < cell.from) {
+            // I am in between of the previous and next row in the table;
+            skipRows = addRow(tr, rect, row - 1, nextRow);
+            i++;
+          }
+
+          lastCellFrom = cell.from;
+
+          if (!skipRows || skipRows === 0) {
+            return {
+              handled: false
+            };
+          }
+
+          return {
+            handled: true,
+            skipRows: skipRows - 1
+          };
+        },
+        end: (tr, rect, col) => {
+          if (!this.rows || i >= this.rows.length) {
+            return;
+          } // Add rows at the end of the table
+
+
+          let nextRow;
+
+          while (nextRow = this.rows[i]) {
+            addRow(tr, rect, rect.map.height - 1, nextRow);
+            i++;
+          }
+        }
+      };
+    });
+
+    this.rows = rowsSideEffect;
+  }
+
+  start(isDelete) {
+    if (isDelete) {
+      return this.deleteHandler();
+    }
+
+    return this.addHandler();
+  }
+
+  addRowRanges(ranges, isDelete) {
+    if (!this.rows) {
+      return ranges;
+    }
+
+    const rowRanges = [];
+
+    for (const row of this.rows) {
+      const {
+        from,
+        to
+      } = row;
+
+      if (isDelete) {
+        rowRanges.push(from, to - from, 0);
+      } else {
+        rowRanges.push(from, 0, to - from);
+      }
+    } // Merged ranges
+
+
+    return mergedRanges(ranges, rowRanges);
+  }
+
+  map(mapping) {
+    return [];
+  }
+
+  invert(originalDoc, isDelete, map) {
+    if (!this.rows) {
+      return;
+    }
+
+    const invertedRows = [];
+
+    for (const row of this.rows) {
+      if (isDelete) {
+        // Moving from delete to add keep the inverted rows + offset
+        let offset = map.map(row.from) - row.from;
+        invertedRows.push({ ...row,
+          from: row.from + offset,
+          to: row.from + offset
+        });
+      } else {// Moving from add to delete keep
+        // TODO: I think we need to add the respective cell into the cellSteps...... not sure....
+      }
+    }
+
+    return invertedRows;
+  }
+
+  toJSON() {
+    if (!this.rows) {
+      return;
+    }
+
+    const rowsInJson = [];
+
+    for (const row of this.rows) {
+      rowsInJson.push({
+        from: row.from,
+        to: row.to,
+        rowNode: row.rowNode.toJSON()
+      });
+    }
+
+    return rowsInJson;
+  }
+
+  static fromJSON(schema, json) {
+    const rowSideEffects = [];
+
+    for (const row of json) {
+      rowSideEffects.push({
+        from: row.from,
+        to: row.to,
+        rowNode: schema.nodeFromJSON(row.rowNode)
+      });
+    }
+
+    return rowSideEffects;
+  }
+
+}