@atlaskit/adf-schema 29.2.0 → 30.0.1

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

@@ -1,306 +0,0 @@
-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';
-const ADD_COLUMN_STEP = 'ak-add-column';
-function printColumnInfo(columnInfo) {
-  let cellsFrom = [];
-  for (const cellInfo of columnInfo.values()) {
-    cellsFrom.push(cellInfo.from);
-  }
-  return `[${cellsFrom.join(',')}]`;
-}
-function createColumnInfo(cellsInfo) {
-  return new Map(cellsInfo.map(cellInfo => [cellInfo.from, cellInfo]));
-}
-const getTableRectAndColumnFactory = (doc, pos, columnInfo) => {
-  return memoizeOne(() => {
-    const rect = getTableRectFromDoc(doc, pos);
-    const column = findColumn(columnInfo, rect);
-    if (column === null) {
-      throw new Error('no column');
-    }
-    return {
-      rect,
-      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 class AddColumnStep extends Step {
-  constructor(tablePos, addColumnStepInfo, isDelete = false) {
-    super();
-    this.tablePos = tablePos;
-    this.isDelete = isDelete;
-    this.sideEffectsHandler = new SideEffectsHandler(addColumnStepInfo.sideEffects);
-    this.columnInfo = createColumnInfo(addColumnStepInfo.cells);
-  }
-
-  /**
-   * 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
-   */
-  apply(doc) {
-    const {
-      tablePos
-    } = this;
-    // Create transform base on the doc
-    const tr = new Transform(doc);
-    if (this.sideEffectsHandler.table.handleAddTable(tr, this.isDelete)) {
-      return StepResult.ok(tr.doc);
-    }
-    let tableRect;
-    try {
-      tableRect = getTableRectFromDoc(doc, tablePos);
-    } catch (e) {
-      return StepResult.fail(e.message);
-    }
-    const column = findColumn(this.columnInfo, tableRect);
-    if (column === null) {
-      return StepResult.fail(`No column for this cells "${printColumnInfo(this.columnInfo)}" in table at position "${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
-   */
-  map(mapping) {
-    const tablePosResult = mapping.mapResult(this.tablePos);
-    if (tablePosResult.deleted) {
-      // If table was deleted remove the step
-      return null;
-    }
-    const cellSteps = [];
-    for (const oldCellStep of this.columnInfo.values()) {
-      const fromResult = mapping.mapResult(oldCellStep.from);
-      const toResult = mapping.mapResult(oldCellStep.to);
-      if (fromResult.deleted && toResult.deleted) {
-        continue;
-      }
-      const cellStep = {
-        ...oldCellStep,
-        from: fromResult.pos,
-        to: toResult.pos
-      };
-      if (oldCellStep.mergeWith !== undefined) {
-        cellStep.mergeWith = mapping.map(oldCellStep.mergeWith);
-      }
-      cellSteps.push(cellStep);
-    }
-    if (cellSteps.length === 0) {
-      return null;
-    }
-    const sideEffects = this.sideEffectsHandler.map(mapping);
-    return new AddColumnStep(tablePosResult.pos, {
-      cells: cellSteps,
-      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
-   */
-  invert(originalDoc) {
-    const stepMap = this.getMap();
-
-    // Memoize function to be called only on delete scenarios
-    const 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.
-    const newCellSteps = Array.from(this.columnInfo.values(), oldCellStep => {
-      const newCellStep = invertCellStep(originalDoc, getTableRectAndColumn, oldCellStep, this.isDelete, stepMap);
-      return newCellStep;
-    });
-    const sideEffects = this.sideEffectsHandler.invert(originalDoc, this.isDelete, stepMap);
-    return new AddColumnStep(this.tablePos, {
-      cells: newCellSteps,
-      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
-   */
-  getMap() {
-    const tableMap = this.sideEffectsHandler.getTableMap(this.isDelete);
-    if (tableMap) {
-      return tableMap;
-    }
-    let ranges = [];
-    for (const cellStep of this.columnInfo.values()) {
-      ranges.push(...getMapFromCellStep(cellStep, this.isDelete));
-    }
-    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.
-   */
-  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.
-   */
-  toJSON() {
-    const addColumnStepJson = {
-      stepType: ADD_COLUMN_STEP,
-      tablePos: this.tablePos,
-      cells: Array.from(this.columnInfo.values(), cellStep => {
-        const 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
-    };
-    const 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.
-   */
-  static fromJSON(schema, json) {
-    // TODO: Add validation. Return null if it is invalid. Check in review if this is necessary
-    const cells = json.cells.map(cellsJson => {
-      const cell = {
-        ...cellsJson,
-        newCell: cellsJson.newCell ? schema.nodeFromJSON(cellsJson.newCell) : undefined
-      };
-      return cell;
-    });
-    let sideEffects;
-    if (json.sideEffects) {
-      sideEffects = SideEffectsHandler.fromJSON(schema, json.sideEffects);
-    }
-    return new AddColumnStep(json.tablePos, {
-      cells,
-      sideEffects
-    }, json.isDelete);
-  }
-  static create(doc, tablePos, column, isDelete = false) {
-    const tableRect = getTableRectFromDoc(doc, tablePos);
-
-    // By default add column will rely on default behaviour (add empty cell).
-    // There is no need to add content
-    const cells = [];
-    const iter = cellsAtColumn(tableRect, column);
-    let next = iter.next();
-    while (!next.done) {
-      const cell = next.value;
-      cells.push(createCellStep(cell, column, isDelete));
-      let skipRows = 0;
-      if (cell.attrs && cell.attrs.rowspan) {
-        skipRows = cell.attrs.rowspan - 1;
-      }
-      next = iter.next(skipRows);
-    }
-    return new AddColumnStep(tablePos, {
-      cells
-    }, isDelete);
-  }
-  applyCellSteps(tr, tableRect, column, isDelete) {
-    const newColumnInfo = new Map();
-    const rowsHandler = this.sideEffectsHandler.rows.start(this.isDelete);
-    const iter = cellsAtColumn(tableRect, column);
-    let next = iter.next();
-    // Iterate for all the cells in the current document
-    while (!next.done) {
-      const cell = next.value;
-      const previousCellStep = this.columnInfo.get(cell.from);
-      const 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.
-      const 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)
-      const {
-        skipRows,
-        cellStep
-      } = applyCellStep(tr, tableRect, cell, newCellStep, isDelete, column);
-
-      // 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;
-  }
-}
-Step.jsonID(ADD_COLUMN_STEP, AddColumnStep);

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

@@ -1,5 +0,0 @@
-export let SortOrder = /*#__PURE__*/function (SortOrder) {
-  SortOrder["ASC"] = "asc";
-  SortOrder["DESC"] = "desc";
-  return SortOrder;
-}({});

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

@@ -1,34 +0,0 @@
-import { Slice } from '@atlaskit/editor-prosemirror/model';
-import { ReplaceStep, Step, StepMap, StepResult } from '@atlaskit/editor-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

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

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

@@ -1,187 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,83 +0,0 @@
-/**
- * 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;
-}