@atlaskit/adf-schema 25.1.0 → 25.2.0

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

@@ -29,34 +29,34 @@ export function findColumn(columnInfo, rect) {
    *      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
+  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
-
-
+    }
+    // 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
+      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
-
+          }
 
+          // merged columns
           end = start + j - i; // Update the end column with the new position
         }
 
@@ -64,23 +64,20 @@ export function findColumn(columnInfo, rect) {
           // 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).
+      }
+
+      // 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

@@ -1,21 +1,22 @@
 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
+  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
-
+  }
 
+  // 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 $table = doc.resolve(tablePos);
+  // Nested tables start position might differ from the original position
   const start = $table.start($table.depth + 1);
   return {
     map,

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

@@ -1,13 +1,11 @@
 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]);
@@ -17,36 +15,31 @@ function mergedRanges(first, second) {
       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,
+    tr.setNodeMarkup(mappedPos, undefined, {
+      ...attrs,
       rowspan: attrs.rowspan + 1
     });
     col += attrs.colspan - 1;
   }
 }
-
 function decreaseRowspan(tr, rect, row, colToRemove) {
   let skipRows = 0;
   const {
@@ -54,16 +47,15 @@ function decreaseRowspan(tr, rect, row, colToRemove) {
     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,
+      tr.setNodeMarkup(mappedPos, undefined, {
+        ...attrs,
         rowspan: attrs.rowspan - 1
       });
       col += attrs.colspan - 1;
@@ -71,34 +63,29 @@ function decreaseRowspan(tr, rect, row, 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
+  let to = from + rowNode.nodeSize;
 
-  tr.delete(tr.mapping.map(from), tr.mapping.map(to)); // Change rowspan of all cells except current col and get the rows to skip
+  // 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,
@@ -109,14 +96,12 @@ function removeRowWithLastCell(tr, rect, row, _col) {
     }
   };
 }
-
 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", () => {
@@ -128,7 +113,6 @@ export class RowsSideEffectHandler {
               handled: false
             };
           }
-
           const {
             row: rowSideEffect,
             skipRows
@@ -148,7 +132,6 @@ export class RowsSideEffectHandler {
         }
       };
     });
-
     _defineProperty(this, "addHandler", () => {
       let lastCellFrom = 0;
       let i = 0;
@@ -159,26 +142,22 @@ export class RowsSideEffectHandler {
             return {
               handled: false
             };
-          } // Next row to add;
-
+          }
 
+          // 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
@@ -187,11 +166,10 @@ export class RowsSideEffectHandler {
         end: (tr, rect, col) => {
           if (!this.rows || i >= this.rows.length) {
             return;
-          } // Add rows at the end of the table
-
+          }
 
+          // Add rows at the end of the table
           let nextRow;
-
           while (nextRow = this.rows[i]) {
             addRow(tr, rect, rect.map.height - 1, nextRow);
             i++;
@@ -199,76 +177,63 @@ export class RowsSideEffectHandler {
         }
       };
     });
-
     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
-
+    }
 
+    // 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,
+        invertedRows.push({
+          ...row,
           from: row.from + offset,
           to: row.from + offset
         });
-      } else {// Moving from add to delete keep
+      } 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,
@@ -276,13 +241,10 @@ export class RowsSideEffectHandler {
         rowNode: row.rowNode.toJSON()
       });
     }
-
     return rowsInJson;
   }
-
   static fromJSON(schema, json) {
     const rowSideEffects = [];
-
     for (const row of json) {
       rowSideEffects.push({
         from: row.from,
@@ -290,8 +252,6 @@ export class RowsSideEffectHandler {
         rowNode: schema.nodeFromJSON(row.rowNode)
       });
     }
-
     return rowSideEffects;
   }
-
 }

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

@@ -5,77 +5,56 @@ export class SideEffectsHandler {
     this.table = new TableSideEffectHandler(sideEffects && sideEffects.table);
     this.rows = new RowsSideEffectHandler(sideEffects && sideEffects.rows);
   }
-
   getTableMap(isDelete) {
     return this.table.getTableMap(isDelete);
   }
-
   map(mapping) {
     const sideEffects = {};
     const tableSideEffect = this.table.map(mapping);
     const rowsSideEffect = this.rows.map(mapping);
-
     if (tableSideEffect) {
       sideEffects.table = tableSideEffect;
     }
-
     if (rowsSideEffect) {
       sideEffects.rows = rowsSideEffect;
     }
-
     return sideEffects;
   }
-
   invert(originalDoc, isDelete, map) {
     const sideEffects = {};
     const tableSideEffect = this.table.invert(originalDoc);
-
     if (tableSideEffect) {
       sideEffects.table = tableSideEffect;
     }
-
     const rowsSideEffect = this.rows.invert(originalDoc, isDelete, map);
-
     if (rowsSideEffect) {
       sideEffects.rows = rowsSideEffect;
     }
-
     return sideEffects;
   }
-
   toJSON() {
     const tableSideEffectJson = this.table.toJSON();
     const rowsSideEffectJson = this.rows.toJSON();
-
     if (!tableSideEffectJson && !rowsSideEffectJson) {
       return;
     }
-
     const sideEffectsJSON = {};
-
     if (tableSideEffectJson) {
       sideEffectsJSON.table = tableSideEffectJson;
     }
-
     if (rowsSideEffectJson) {
       sideEffectsJSON.rows = rowsSideEffectJson;
     }
-
     return sideEffectsJSON;
   }
-
   static fromJSON(schema, json) {
     const sideEffects = {};
-
     if (json.table) {
       sideEffects.table = TableSideEffectHandler.fromJSON(schema, json.table);
     }
-
     if (json.rows) {
       sideEffects.rows = RowsSideEffectHandler.fromJSON(schema, json.rows);
     }
-
     return sideEffects;
   }
-
 }

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

@@ -5,7 +5,6 @@ export class TableSideEffectHandler {
       this.table = tableSideEffect;
     }
   }
-
   addTableSideEffect(from, to, node) {
     this.table = {
       from,
@@ -13,16 +12,13 @@ export class TableSideEffectHandler {
       node
     };
   }
-
   handleAddTable(tr, isDelete) {
     if (isDelete || !this.table) {
       return false;
     }
-
     tr.insert(this.table.from, this.table.node);
     return true;
   }
-
   handleRemoveTable(tr, tablePos, tableRect, column, isDelete) {
     if (isDelete && tableRect.map.width === 1 && column === 0) {
       // Add side effect
@@ -30,44 +26,35 @@ export class TableSideEffectHandler {
       tr.delete(tablePos, tablePos + tableRect.table.nodeSize);
       return true;
     }
-
     return false;
   }
-
   getTableMap(isDelete) {
     if (!this.table) {
       return;
     }
-
     const {
       from,
       to
     } = this.table;
-
     if (isDelete) {
       return new StepMap([from, to - from, 0]);
     }
-
     return new StepMap([from, 0, to - from]);
   }
-
   map(mapping) {
     if (!this.table) {
       return;
     }
-
     return {
       from: mapping.map(this.table.from),
       to: mapping.map(this.table.to),
       node: this.table.node
     };
   }
-
   invert(doc) {
     if (!this.table) {
       return;
     }
-
     const tableNode = doc.nodeAt(this.table.from);
     return {
       from: this.table.from,
@@ -75,19 +62,16 @@ export class TableSideEffectHandler {
       node: tableNode.copy(tableNode.content)
     };
   }
-
   toJSON() {
     if (!this.table) {
       return;
     }
-
     return {
       from: this.table.from,
       to: this.table.to,
       node: this.table.node.toJSON()
     };
   }
-
   static fromJSON(schema, json) {
     return {
       from: json.from,
@@ -95,5 +79,4 @@ export class TableSideEffectHandler {
       node: schema.nodeFromJSON(json.node)
     };
   }
-
 }

package/dist/es2019/steps/type-ahead.js

@@ -2,12 +2,10 @@ import { Slice } from 'prosemirror-model';
 import { ReplaceStep, Step, StepMap, StepResult } from 'prosemirror-transform';
 export const insertTypeAheadStepType = 'atlaskit-insert-type-ahead';
 export let InsertTypeAheadStages;
-
 (function (InsertTypeAheadStages) {
   InsertTypeAheadStages["DELETING_RAW_QUERY"] = "DELETING_RAW_QUERY";
   InsertTypeAheadStages["INSERTING_ITEM"] = "INSERTING_ITEM";
 })(InsertTypeAheadStages || (InsertTypeAheadStages = {}));
-
 export class InsertTypeAheadStep extends Step {
   constructor({
     stage,
@@ -22,7 +20,6 @@ export class InsertTypeAheadStep extends Step {
     this.trigger = trigger;
     this.selectedIndex = selectedIndex;
   }
-
   invert() {
     const config = {
       stage: this.stage,
@@ -32,38 +29,31 @@ export class InsertTypeAheadStep extends Step {
     };
     return new InsertTypeAheadStep(config, !this.isInvertStep);
   }
-
   apply(doc) {
     return StepResult.ok(doc);
   }
-
   merge() {
     return null;
   }
-
   isInsertionStep() {
     return !this.isInvertStep;
   }
-
   isUndoingStep() {
     return this.isInvertStep;
   }
-
   map(mapping) {
     const config = {
       stage: this.stage,
       query: this.query,
       trigger: this.trigger,
       selectedIndex: this.selectedIndex
-    }; // Return the same events, this step will never be removed
-
+    };
+    // Return the same events, this step will never be removed
     return new InsertTypeAheadStep(config, this.isInvertStep);
   }
-
   getMap() {
     return new StepMap([0, 0, 0]);
   }
-
   toJSON() {
     // When serialized we should create a noop Replace step
     return {
@@ -72,14 +62,12 @@ export class InsertTypeAheadStep extends Step {
       to: 0
     };
   }
-
   static fromJSON() {
     // This is a "local custom step" once serialized
     // we need to transform it in a no-operation action
     return new ReplaceStep(0, 0, Slice.empty);
   }
-
 }
-/** Register this step with Prosemirror */
 
+/** Register this step with Prosemirror */
 Step.jsonID(insertTypeAheadStepType, InsertTypeAheadStep);