@atlaskit/adf-schema 25.1.0 → 25.2.0

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

@@ -6,36 +6,30 @@ import { applyCellStep, createCellStep, getMapFromCellStep, invertCellStep } fro
 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
@@ -44,8 +38,6 @@ const getTableRectAndColumnFactory = (doc, pos, columnInfo) => {
  * 0    1    2    x   -> Remove Column Index
  *
  */
-
-
 export class AddColumnStep extends Step {
   constructor(tablePos, addColumnStepInfo, isDelete = false) {
     super();
@@ -54,6 +46,7 @@ export class AddColumnStep extends Step {
     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.
@@ -68,41 +61,34 @@ export class AddColumnStep extends Step {
    *
    * @param doc Current document
    */
-
-
   apply(doc) {
     const {
       tablePos
-    } = this; // Create transform base on the doc
-
+    } = 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);
 
-    this.columnInfo = this.applyCellSteps(tr, tableRect, column, this.isDelete); // Return the document modified.
-
+    // 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
@@ -110,48 +96,39 @@ export class AddColumnStep extends 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,
+      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
@@ -163,13 +140,12 @@ export class AddColumnStep extends Step {
    *    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 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;
@@ -180,6 +156,7 @@ export class AddColumnStep extends Step {
       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)
@@ -194,44 +171,37 @@ export class AddColumnStep extends Step {
    * 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);
 
-    ranges = this.sideEffectsHandler.rows.addRowRanges(ranges, this.isDelete); // If no steps, I create am empty stepMap
-
+    // 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,
@@ -241,109 +211,96 @@ export class AddColumnStep extends Step {
           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,
+      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 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
-
+    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 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)
-
+      }
 
+      // 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.
+      } = 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 +1,4 @@
 export let SortOrder;
-
 (function (SortOrder) {
   SortOrder["ASC"] = "asc";
   SortOrder["DESC"] = "desc";

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

@@ -8,34 +8,27 @@ export class TableSortStep extends Step {
     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 */
 
+/** Register this step with Prosemirror */
 Step.jsonID(tableSortingStepType, TableSortStep);

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

@@ -1,13 +1,12 @@
 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).
@@ -18,15 +17,12 @@ function calculateRowsToSkip(attrs) {
  * @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);
@@ -35,17 +31,16 @@ export function applyCellStep(tr, tableRect, cell, cellStep, isDelete, column) {
         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
-
+    }
 
+    // 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
-
+  let skipRows = 0;
+  // Modify temporary document
   if (isDelete) {
     let cellNode = tr.doc.nodeAt(tr.mapping.map(cellStep.from));
     skipRows = calculateRowsToSkip(cellNode.attrs);
@@ -58,35 +53,33 @@ export function applyCellStep(tr, tableRect, cell, cellStep, isDelete, column) {
       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
@@ -95,15 +88,14 @@ export function getMapFromCellStep(cellStep, isDelete) {
  * @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
@@ -112,8 +104,6 @@ function getOffset(map, cellStep, isDelete) {
  * @param isDelete
  * @param stepMap
  */
-
-
 export function invertCellStep(doc, getTableRectAndColumn, cellStep, isDelete, stepMap) {
   /**
    * We need a correct map when a cell is added
@@ -135,40 +125,38 @@ export function invertCellStep(doc, getTableRectAndColumn, cellStep, isDelete, s
    *  For a delete action this not happen, it will always return the right value
    */
   const offset = getOffset(stepMap, cellStep, isDelete);
-  const newCellStepInfo = { ...cellStep,
+  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.
+    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
@@ -176,29 +164,24 @@ export function invertCellStep(doc, getTableRectAndColumn, cellStep, isDelete, s
  * @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,6 +1,5 @@
 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.
@@ -15,23 +14,21 @@ export function* cellsAtColumn(rect, col) {
     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.
+    let pos = map.map[index];
 
-    const hasMergedCells = hasMergedColumns(rect.map, row, col) && isRootRow(rect.map, row, col); // If this position falls inside a col-spanning cell
+    // 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,
@@ -41,15 +38,13 @@ export function* cellsAtColumn(rect, 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
-
+    }
 
+    // We let the consumer to pass the rows that we want to skip
     const skippedRows = yield cellInfo;
-
     if (skippedRows && skippedRows > 0) {
       row += skippedRows;
     }