@atlaskit/adf-schema 28.1.6 → 28.1.8

package/src/steps/table/utils/cell-step.ts

@@ -0,0 +1,239 @@
+import { Node as ProseMirrorNode } from '@atlaskit/editor-prosemirror/model';
+import { Cell } from './cells-at-column';
+import { CellStep } from '../types';
+import { Transform, StepMap } from '@atlaskit/editor-prosemirror/transform';
+import { TableRect } from '@atlaskit/editor-tables/table-map';
+import { addColSpan, removeColSpan } from '@atlaskit/editor-tables/utils';
+import { CellAttributesWithColSpan } from '@atlaskit/editor-tables/types';
+import { CellAttributes } from '../../../schema/nodes/tableNodes';
+
+const EmptyCellNodeSize = 4;
+
+function calculateRowsToSkip(attrs?: CellAttributes) {
+  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: Transform,
+  tableRect: TableRect,
+  cell: Cell,
+  cellStep: CellStep,
+  isDelete: boolean,
+  column: number,
+): { tr: Transform; skipRows: number; cellStep: CellStep } {
+  // Apply the merge actions,
+  if (cellStep.mergeWith !== undefined) {
+    let cellNode: ProseMirrorNode = tr.doc.nodeAt(
+      tr.mapping.map(cellStep.mergeWith),
+    )!;
+
+    const columns =
+      column -
+      tableRect.map.colCount(cellStep.mergeWith - tableRect.tableStart);
+    const cellAttrs = isDelete
+      ? removeColSpan(cellNode.attrs as CellAttributesWithColSpan, columns)
+      : addColSpan(cellNode.attrs as CellAttributesWithColSpan, 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: ProseMirrorNode = 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: CellStep,
+  isDelete: boolean,
+): [number, number, number] {
+  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: StepMap,
+  cellStep: CellStep,
+  isDelete: boolean,
+): number {
+  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: ProseMirrorNode,
+  getTableRectAndColumn: () => { rect: TableRect; column: number },
+  cellStep: CellStep,
+  isDelete: boolean,
+  stepMap: StepMap,
+): CellStep {
+  /**
+   * 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 = {
+    ...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: Cell,
+  column: number,
+  isDelete: boolean,
+  previousCellStep?: CellStep,
+): CellStep {
+  const newCellStepInfo: CellStep = {
+    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/src/steps/table/utils/cells-at-column.ts

@@ -0,0 +1,72 @@
+import { TableRect } from '@atlaskit/editor-tables/table-map';
+import { columnIsHeader, tableNodeTypes } from '@atlaskit/editor-tables/utils';
+import { NodeType, Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import { CellAttributes } from '../../../schema/nodes/tableNodes';
+import { getCellIndex, hasMergedColumns, isRootRow } from './table-map';
+
+export interface Cell {
+  from: number;
+  to: number;
+  row: number;
+  col: number;
+  attrs?: CellAttributes;
+  hasMergedCells: boolean;
+  type: NodeType;
+}
+
+/**
+ * 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: TableRect, col: number): Generator<Cell, void, number | undefined> {
+  const { map, tableStart, table } = rect;
+
+  let refColumn: number | null = 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) as PMNode;
+
+    const cellInfo: Cell = {
+      from: tableStart + pos,
+      to: tableStart + pos,
+      row,
+      col: hasMergedCells ? map.colCount(pos) : col,
+      type,
+      hasMergedCells,
+    };
+
+    if (cell) {
+      cellInfo.attrs = cell.attrs as CellAttributes;
+      cellInfo.to = tableStart + pos + cell!.nodeSize;
+    }
+
+    // We let the consumer to pass the rows that we want to skip
+    const skippedRows: number | undefined = yield cellInfo;
+
+    if (skippedRows && skippedRows > 0) {
+      row += skippedRows;
+    }
+  }
+}

package/src/steps/table/utils/find-column.ts

@@ -0,0 +1,90 @@
+import { TableRect } from '@atlaskit/editor-tables/table-map';
+import { CellStep, ColumnInfo } from '../types';
+
+/**
+ * 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: ColumnInfo,
+  rect: TableRect,
+): number | null {
+  /**
+   * 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 as CellStep).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/src/steps/table/utils/get-table-rect-from-doc.ts

@@ -0,0 +1,37 @@
+import { Node as ProseMirrorNode } from '@atlaskit/editor-prosemirror/model';
+import { TableRect, TableMap } from '@atlaskit/editor-tables/table-map';
+
+/**
+ * Util to get the table rect from the docs
+ * @param doc
+ * @param tablePos
+ */
+export function getTableRectFromDoc(
+  doc: ProseMirrorNode,
+  tablePos: number,
+): TableRect {
+  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,
+  };
+}