@atlaskit/editor-plugin-table 1.1.0 → 1.1.2

package/dist/es2019/plugins/table/toolbar.js

@@ -88,15 +88,15 @@ export const getToolbarMenuConfig = (config, state, {
     hidden: options.every(option => option.hidden),
     options
   };
-}; // Added these options for mobile. Mobile bridge translates this menu and
+};
+
+// Added these options for mobile. Mobile bridge translates this menu and
 // relay it to the native mobile. Native mobile displays the menu
 // with native widgets. It's enabled via a plugin config.
-
 export const getToolbarCellOptionsConfig = (editorState, editorView, initialSelectionRect, {
   formatMessage
 }, getEditorContainerWidth, editorAnalyticsAPI) => {
   var _pluginState$pluginCo, _pluginState$pluginCo2;
-
   const {
     top,
     bottom,
@@ -112,11 +112,9 @@ export const getToolbarCellOptionsConfig = (editorState, editorView, initialSele
     onClick: (state, dispatch, view) => {
       const selectionRect = getClosestSelectionRect(state);
       const index = selectionRect === null || selectionRect === void 0 ? void 0 : selectionRect.right;
-
       if (index) {
         insertColumnWithAnalytics(getEditorContainerWidth, editorAnalyticsAPI)(INPUT_METHOD.FLOATING_TB, index)(state, dispatch, view);
       }
-
       return true;
     },
     selected: false,
@@ -130,14 +128,12 @@ export const getToolbarCellOptionsConfig = (editorState, editorView, initialSele
     onClick: (state, dispatch) => {
       const selectionRect = getClosestSelectionRect(state);
       const index = selectionRect === null || selectionRect === void 0 ? void 0 : selectionRect.bottom;
-
       if (index) {
         insertRowWithAnalytics(editorAnalyticsAPI)(INPUT_METHOD.FLOATING_TB, {
           index,
           moveCursorToInsertedRow: true
         })(state, dispatch);
       }
-
       return true;
     },
     selected: false,
@@ -152,11 +148,9 @@ export const getToolbarCellOptionsConfig = (editorState, editorView, initialSele
     }),
     onClick: (state, dispatch, view) => {
       const selectionRect = getClosestSelectionRect(state);
-
       if (selectionRect) {
         deleteColumnsWithAnalytics(editorAnalyticsAPI)(INPUT_METHOD.FLOATING_TB, selectionRect)(state, dispatch, view);
       }
-
       return true;
     },
     onFocus: highlightColumnsHandler,
@@ -172,11 +166,9 @@ export const getToolbarCellOptionsConfig = (editorState, editorView, initialSele
     }),
     onClick: (state, dispatch) => {
       const selectionRect = getClosestSelectionRect(state);
-
       if (selectionRect) {
         deleteRowsWithAnalytics(editorAnalyticsAPI)(INPUT_METHOD.FLOATING_TB, selectionRect, false)(state, dispatch);
       }
-
       return true;
     },
     onFocus: highlightRowsHandler,
@@ -198,22 +190,17 @@ export const getToolbarCellOptionsConfig = (editorState, editorView, initialSele
     selected: false,
     disabled: !splitCell(editorState)
   }];
-
   if (pluginState !== null && pluginState !== void 0 && (_pluginState$pluginCo = pluginState.pluginConfig) !== null && _pluginState$pluginCo !== void 0 && _pluginState$pluginCo.allowDistributeColumns) {
     var _newResizeStateWithAn;
-
     const newResizeStateWithAnalytics = editorView ? getNewResizeStateFromSelectedColumns(initialSelectionRect, editorState, editorView.domAtPos.bind(editorView), getEditorContainerWidth) : undefined;
     const wouldChange = (_newResizeStateWithAn = newResizeStateWithAnalytics === null || newResizeStateWithAnalytics === void 0 ? void 0 : newResizeStateWithAnalytics.changed) !== null && _newResizeStateWithAn !== void 0 ? _newResizeStateWithAn : false;
-
     const distributeColumnWidths = (state, dispatch) => {
       if (newResizeStateWithAnalytics) {
         distributeColumnsWidthsWithAnalytics(editorAnalyticsAPI)(INPUT_METHOD.FLOATING_TB, newResizeStateWithAnalytics)(state, dispatch);
         return true;
       }
-
       return false;
     };
-
     options.push({
       id: 'editor.table.distributeColumns',
       title: formatMessage(ContextualMenuMessages.distributeColumns),
@@ -222,7 +209,6 @@ export const getToolbarCellOptionsConfig = (editorState, editorView, initialSele
       disabled: !wouldChange
     });
   }
-
   if (pluginState !== null && pluginState !== void 0 && (_pluginState$pluginCo2 = pluginState.pluginConfig) !== null && _pluginState$pluginCo2 !== void 0 && _pluginState$pluginCo2.allowColumnSorting) {
     const hasMergedCellsInTable = getMergedCellsPositions(editorState.tr).length > 0;
     const warning = hasMergedCellsInTable ? formatMessage(ContextualMenuMessages.canNotSortTable) : undefined;
@@ -234,7 +220,6 @@ export const getToolbarCellOptionsConfig = (editorState, editorView, initialSele
           hoverMergedCells()(state, dispatch);
           return true;
         }
-
         return false;
       },
       onMouseOut: (state, dispatch) => {
@@ -257,7 +242,6 @@ export const getToolbarCellOptionsConfig = (editorState, editorView, initialSele
           hoverMergedCells()(state, dispatch);
           return true;
         }
-
         return false;
       },
       onMouseOut: (state, dispatch) => {
@@ -273,7 +257,6 @@ export const getToolbarCellOptionsConfig = (editorState, editorView, initialSele
       tooltip: warning
     });
   }
-
   options.push({
     id: 'editor.table.clearCells',
     title: formatMessage(ContextualMenuMessages.clearCells, {
@@ -303,17 +286,14 @@ export const getToolbarCellOptionsConfig = (editorState, editorView, initialSele
     showSelected: false
   };
 };
-
 const getClosestSelectionRect = state => {
   const selection = state.selection;
   return isSelectionType(selection, 'cell') ? getSelectionRect(selection) : findCellRectClosestToPos(selection.$from);
 };
-
 export const getToolbarConfig = (getEditorContainerWidth, editorAnalyticsAPI, getEditorFeatureFlags, getEditorView) => config => (state, intl) => {
   const tableObject = findTable(state.selection);
   const pluginState = getPluginState(state);
   const resizeState = tableResizingPluginKey.getState(state);
-
   if (tableObject && pluginState.editorHasFocus) {
     const nodeType = state.schema.nodes.table;
     const menu = getToolbarMenuConfig(config, pluginState, intl, editorAnalyticsAPI);
@@ -321,10 +301,10 @@ export const getToolbarConfig = (getEditorContainerWidth, editorAnalyticsAPI, ge
       tableCellOptionsInFloatingToolbar
     } = getEditorFeatureFlags() || {};
     const cellItems = getCellItems(config, state, getEditorView(), intl, getEditorContainerWidth, editorAnalyticsAPI, tableCellOptionsInFloatingToolbar);
-    const colorPicker = getColorPicker(state, menu, intl, getEditorContainerWidth, editorAnalyticsAPI, tableCellOptionsInFloatingToolbar); // Check if we need to show confirm dialog for delete button
+    const colorPicker = getColorPicker(state, menu, intl, getEditorContainerWidth, editorAnalyticsAPI, tableCellOptionsInFloatingToolbar);
 
+    // Check if we need to show confirm dialog for delete button
     let confirmDialog;
-
     if (isReferencedSource(state, tableObject.node)) {
       confirmDialog = () => ({
         title: intl.formatMessage(tableMessages.deleteElementTitle),
@@ -339,23 +319,18 @@ export const getToolbarConfig = (getEditorContainerWidth, editorAnalyticsAPI, ge
         onConfirm: (isChecked = false) => clickWithCheckboxHandler(isChecked, tableObject.node)
       });
     }
-
     const getDomRef = editorView => {
       let element;
       const domAtPos = editorView.domAtPos.bind(editorView);
       const parent = findParentDomRefOfType(nodeType, domAtPos)(state.selection);
-
       if (parent) {
         const tableRef = parent.querySelector('table') || undefined;
-
         if (tableRef) {
           element = closestElement(tableRef, `.${TableCssClassName.TABLE_NODE_WRAPPER}`) || undefined;
         }
       }
-
       return element;
     };
-
     return {
       title: 'Table floating controls',
       getDomRef,
@@ -397,23 +372,19 @@ export const getToolbarConfig = (getEditorContainerWidth, editorAnalyticsAPI, ge
       scrollable: true
     };
   }
-
   return;
 };
-
 const separator = hidden => {
   return {
     type: 'separator',
     hidden: hidden
   };
 };
-
 const getCellItems = (pluginConfig, state, view, {
   formatMessage
 }, getEditorContainerWidth, editorAnalyticsAPI, tableCellOptionsInFloatingToolbar) => {
   if (pluginConfig.allowCellOptionsInFloatingToolbar || tableCellOptionsInFloatingToolbar) {
     const initialSelectionRect = getClosestSelectionRect(state);
-
     if (initialSelectionRect) {
       const cellOptions = getToolbarCellOptionsConfig(state, view, initialSelectionRect, {
         formatMessage
@@ -421,24 +392,19 @@ const getCellItems = (pluginConfig, state, view, {
       return [cellOptions, separator(cellOptions.hidden)];
     }
   }
-
   return [];
 };
-
 const getColorPicker = (state, menu, {
   formatMessage
 }, getEditorContainerWidth, editorAnalyticsAPI, tableCellOptionsInFloatingToolbar) => {
   var _node$attrs;
-
   const {
     targetCellPosition,
     pluginConfig
   } = getPluginState(state);
-
   if (!pluginConfig.allowBackgroundColor || !tableCellOptionsInFloatingToolbar) {
     return [];
   }
-
   const node = targetCellPosition ? state.doc.nodeAt(targetCellPosition) : undefined;
   const currentBackground = (node === null || node === void 0 ? void 0 : (_node$attrs = node.attrs) === null || _node$attrs === void 0 ? void 0 : _node$attrs.background) || '#ffffff';
   const defaultPalette = cellBackgroundColorPalette.find(item => item.value === currentBackground) || {
@@ -456,39 +422,30 @@ const getColorPicker = (state, menu, {
     onChange: option => setColorWithAnalytics(editorAnalyticsAPI)(INPUT_METHOD.FLOATING_TB, option.value, targetCellPosition)
   }, separator(menu.hidden)];
 };
-
 const clickWithCheckboxHandler = (isChecked, node, editorAnalyticsAPI) => (state, dispatch) => {
   if (!node) {
     return false;
   }
-
   if (!isChecked) {
     return deleteTableWithAnalytics(editorAnalyticsAPI)(state, dispatch);
   } else {
     removeDescendantNodes(node)(state, dispatch);
   }
-
   return true;
 };
-
 const highlightRowsHandler = (state, dispatch) => {
   const selectionRect = getClosestSelectionRect(state);
-
   if (selectionRect) {
     hoverRows(getSelectedRowIndexes(selectionRect), true)(state, dispatch);
     return true;
   }
-
   return false;
 };
-
 const highlightColumnsHandler = (state, dispatch) => {
   const selectionRect = getClosestSelectionRect(state);
-
   if (selectionRect) {
     hoverColumns(getSelectedColumnIndexes(selectionRect), true)(state, dispatch);
     return true;
   }
-
   return false;
 };

package/dist/es2019/plugins/table/transforms/column-width.js

@@ -8,8 +8,9 @@ import { tableCellMinWidth } from '@atlaskit/editor-common/styles';
 import { scaleTableTo } from '../pm-plugins/table-resizing/utils/scale-table';
 export const updateColumnWidths = (resizeState, table, start) => tr => {
   const map = TableMap.get(table);
-  const updatedCellsAttrs = {}; // calculating new attributes for each cell
+  const updatedCellsAttrs = {};
 
+  // calculating new attributes for each cell
   for (let columnIndex = 0; columnIndex < map.width; columnIndex++) {
     for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
       const {
@@ -17,10 +18,10 @@ export const updateColumnWidths = (resizeState, table, start) => tr => {
       } = resizeState.cols[columnIndex];
       const mapIndex = rowIndex * map.width + columnIndex;
       const cellPos = map.map[mapIndex];
-      const attrs = updatedCellsAttrs[cellPos] || { ...table.nodeAt(cellPos).attrs
+      const attrs = updatedCellsAttrs[cellPos] || {
+        ...table.nodeAt(cellPos).attrs
       };
       const colspan = attrs.colspan || 1;
-
       if (attrs.colwidth && attrs.colwidth.length > colspan) {
         tr = setMeta({
           type: 'UPDATE_COLUMN_WIDTHS',
@@ -31,24 +32,20 @@ export const updateColumnWidths = (resizeState, table, start) => tr => {
           }
         })(tr);
         attrs.colwidth = attrs.colwidth.slice(0, colspan);
-      } // Rowspanning cell that has already been handled
-
+      }
 
+      // Rowspanning cell that has already been handled
       if (rowIndex && map.map[mapIndex] === map.map[mapIndex - map.width]) {
         continue;
       }
-
       const colspanIndex = colspan === 1 ? 0 : columnIndex - map.colCount(cellPos);
-
       if (attrs.colwidth && attrs.colwidth[colspanIndex] === width) {
         continue;
       }
-
       let colwidths = attrs.colwidth ? attrs.colwidth.slice() : Array.from({
         length: colspan
       }, _ => 0);
       colwidths[colspanIndex] = width;
-
       if (colwidths.length > colspan) {
         tr = setMeta({
           type: 'UPDATE_COLUMN_WIDTHS',
@@ -60,35 +57,30 @@ export const updateColumnWidths = (resizeState, table, start) => tr => {
         })(tr);
         colwidths = colwidths.slice(0, colspan);
       }
-
-      updatedCellsAttrs[cellPos] = { ...attrs,
+      updatedCellsAttrs[cellPos] = {
+        ...attrs,
         colwidth: colwidths.includes(0) ? undefined : colwidths
       };
     }
-  } // updating all cells with new attributes
-
+  }
 
+  // updating all cells with new attributes
   const rows = [];
   const seen = {};
-
   for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
     const row = table.child(rowIndex);
     const cells = [];
-
     for (let columnIndex = 0; columnIndex < map.width; columnIndex++) {
       const mapIndex = rowIndex * map.width + columnIndex;
       const pos = map.map[mapIndex];
       const cell = table.nodeAt(pos);
-
       if (!seen[pos] && cell) {
         cells.push(cell.type.createChecked(updatedCellsAttrs[pos] || cell.attrs, cell.content, cell.marks));
         seen[pos] = true;
       }
     }
-
     rows.push(row.type.createChecked(row.attrs, cells, row.marks));
   }
-
   const tablePos = start - 1;
   const selectionBookmark = tr.selection.getBookmark();
   tr.replaceWith(tablePos, tablePos + table.nodeSize, table.type.createChecked(table.attrs, rows, table.marks));
@@ -102,9 +94,9 @@ export const updateColumnWidths = (resizeState, table, start) => tr => {
    *
    * @see https://github.com/ProseMirror/prosemirror/issues/645
    */
-
   return tr.setSelection(selectionBookmark.resolve(tr.doc));
 };
+
 /**
  * This function is called when user inserts/deletes a column in a table to;
  * - rescale all columns (if the table did not overflow before the insertion)
@@ -115,27 +107,23 @@ export const updateColumnWidths = (resizeState, table, start) => tr => {
  * @param view
  * @returns Updated transaction with rescaled columns for a given table
  */
-
 export const rescaleColumns = getEditorContainerWidth => (table, view) => tr => {
   // If the table has been not been resized we skip updating the size
   // of columns here.
   if (!view || !hasTableBeenResized(table.node)) {
     return tr;
   }
-
   const {
     state
   } = view;
   const domAtPos = view.domAtPos.bind(view);
   const maybeTable = domAtPos(table.start).node;
   const tableRef = maybeTable.closest('table');
-
   if (!tableRef) {
     return tr;
   }
-
-  const layout = normaliseTableLayout(tableRef === null || tableRef === void 0 ? void 0 : tableRef.dataset.layout); // The is the width the table can reach before overflowing
-
+  const layout = normaliseTableLayout(tableRef === null || tableRef === void 0 ? void 0 : tableRef.dataset.layout);
+  // The is the width the table can reach before overflowing
   const maxSize = getTableMaxWidth({
     table: table.node,
     tableStart: table.start,
@@ -152,12 +140,12 @@ export const rescaleColumns = getEditorContainerWidth => (table, view) => tr =>
     maxSize
   });
   const previousTableWidth = resizeState.tableWidth - tableNewColumnMinWidth;
-  const tableDidntPreviouslyOverflow = previousTableWidth <= maxSize; // If the new table width will result in the table going into an overflow state
-  // we resize the cells to avoid the overflow occuring
+  const tableDidntPreviouslyOverflow = previousTableWidth <= maxSize;
 
+  // If the new table width will result in the table going into an overflow state
+  // we resize the cells to avoid the overflow occuring
   if (tableDidntPreviouslyOverflow && resizeState.overflow) {
     resizeState = scaleTableTo(resizeState, maxSize);
   }
-
   return updateColumnWidths(resizeState, table.node, table.start)(tr);
 };

package/dist/es2019/plugins/table/transforms/delete-columns.js

@@ -4,87 +4,70 @@ import { findTable } from '@atlaskit/editor-tables/utils';
 import { AddColumnStep } from '@atlaskit/adf-schema/steps';
 import { setMeta } from './metadata';
 import { splitCellsInColumns } from './split';
-
 const deleteColumnsCustomStep = rect => tr => {
   const table = findTable(tr.selection);
-
   if (!table) {
     return tr;
-  } // Need to split all the merge in the ranges (this is the current behaviour)
+  }
+
+  // Need to split all the merge in the ranges (this is the current behaviour)
   // Maybe is better to split only the last column?
   // TODO: After talking with Roto about this behaviour, he likes when we dont split the columns, I am keeping this for consistency of the current implementation.
+  splitCellsInColumns(tr, table.pos, rect.left, rect.right);
 
-
-  splitCellsInColumns(tr, table.pos, rect.left, rect.right); // Delete the columns
-
+  // Delete the columns
   let mapStart = tr.mapping.maps.length;
   const originalDoc = tr.doc;
   const deletedColumns = [];
-
   for (let i = rect.left; i < rect.right; i++) {
     const step = AddColumnStep.create(originalDoc, table.pos, i, true);
     deletedColumns.push(i);
     tr.step(step.map(tr.mapping.slice(mapStart)));
   }
-
   const tablePosResult = tr.mapping.mapResult(table.pos);
-
   if (tablePosResult.deleted) {
     const pos = Math.min(tablePosResult.pos, tr.doc.nodeSize - 1);
     tr.setSelection(Selection.near(tr.doc.resolve(pos)));
   } else {
     const newTable = tr.doc.nodeAt(tablePosResult.pos);
-
     if (newTable) {
       const cursorPos = getNextCursorPos(newTable, deletedColumns);
       tr.setSelection(Selection.near(tr.doc.resolve(table.pos + cursorPos)));
     }
   }
-
   return tr;
 };
-
 const deleteColumnsLegacy = rect => tr => {
   const table = findTable(tr.selection);
-
   if (!table) {
     return tr;
   }
-
   const columnsToDelete = [];
-
   for (let i = rect.left; i < rect.right; i++) {
     columnsToDelete.push(i);
   }
-
   if (!columnsToDelete.length) {
     return tr;
   }
-
   const map = TableMap.get(table.node);
   const rows = [];
   const seen = {};
   const deletedCells = {};
-
   for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
     const rowCells = [];
     const row = table.node.child(rowIndex);
-
     for (let colIndex = 0; colIndex < map.width; colIndex++) {
       const cellPos = map.map[rowIndex * map.width + colIndex];
       const cell = table.node.nodeAt(cellPos);
-
       if (!cell) {
         continue;
       }
-
       const cellsInColumn = map.cellsInRect({
         left: colIndex,
         top: 0,
         right: colIndex + 1,
         bottom: map.height
       });
-
       if (columnsToDelete.indexOf(colIndex) === -1) {
         // decrement colspans for col-spanning cells that overlap deleted columns
         if (cellsInColumn.indexOf(cellPos) > -1 && !seen[cellPos]) {
@@ -94,12 +77,11 @@ const deleteColumnsLegacy = rect => tr => {
               overlappingCols += 1;
             }
           });
-
           if (overlappingCols > 0) {
-            const attrs = { ...cell.attrs,
+            const attrs = {
+              ...cell.attrs,
               colspan: cell.attrs.colspan - overlappingCols
             };
-
             if (cell.attrs.colwidth) {
               const minColIndex = Math.min(...columnsToDelete);
               const pos = minColIndex > 0 ? minColIndex - map.colCount(cellPos) : 0;
@@ -107,7 +89,6 @@ const deleteColumnsLegacy = rect => tr => {
               colwidth.splice(pos, overlappingCols);
               attrs.colwidth = colwidth;
             }
-
             const newCell = cell.type.createChecked(attrs, cell.content, cell.marks);
             rowCells.push(newCell);
             seen[cellPos] = true;
@@ -115,22 +96,21 @@ const deleteColumnsLegacy = rect => tr => {
           }
         } else if (deletedCells[cellPos]) {
           // if we're removing a col-spanning cell, we need to add missing cells to columns to the right
-          const attrs = { ...cell.attrs,
+          const attrs = {
+            ...cell.attrs,
             colspan: 1,
             rowspan: 1
           };
-
           if (cell.attrs.colwidth) {
             const pos = colIndex > 0 ? colIndex - map.colCount(cellPos) : 0;
             attrs.colwidth = cell.attrs.colwidth.slice().splice(pos, 1);
           }
-
           const newCell = cell.type.createChecked(attrs, cell.type.schema.nodes.paragraph.createChecked(), cell.marks);
           rowCells.push(newCell);
           continue;
-        } // normal cells that we want to keep
-
+        }
 
+        // normal cells that we want to keep
         if (!seen[cellPos]) {
           seen[cellPos] = true;
           rowCells.push(cell);
@@ -139,109 +119,88 @@ const deleteColumnsLegacy = rect => tr => {
         deletedCells[cellPos] = true;
       }
     }
-
     if (rowCells.length) {
       rows.push(row.type.createChecked(row.attrs, rowCells, row.marks));
     }
   }
-
   if (!rows.length) {
     return setMeta({
       type: 'DELETE_COLUMNS',
       problem: 'EMPTY_TABLE'
     })(tr);
   }
-
   const newTable = table.node.type.createChecked(table.node.attrs, rows, table.node.marks);
   const fixedTable = fixRowSpans(newTable);
-
   if (fixedTable === null) {
     return setMeta({
       type: 'DELETE_COLUMNS',
       problem: 'FIX_ROWSPANS'
     })(tr);
   }
-
   const cursorPos = getNextCursorPos(newTable, columnsToDelete);
   return setMeta({
     type: 'DELETE_COLUMNS'
-  })(tr.replaceWith(table.pos, table.pos + table.node.nodeSize, fixedTable) // move cursor to the left of the deleted columns if possible, otherwise - to the first column
+  })(tr.replaceWith(table.pos, table.pos + table.node.nodeSize, fixedTable)
+  // move cursor to the left of the deleted columns if possible, otherwise - to the first column
   .setSelection(Selection.near(tr.doc.resolve(table.pos + cursorPos))));
 };
-
 function getNextCursorPos(table, deletedColumns) {
   const minColumn = Math.min(...deletedColumns);
   const nextColumnWithCursor = minColumn > 0 ? minColumn - 1 : 0;
   const map = TableMap.get(table);
   return map.map[nextColumnWithCursor];
-} // returns an array of numbers, each number indicates the minimum rowSpan in each row
-
+}
 
+// returns an array of numbers, each number indicates the minimum rowSpan in each row
 function getMinRowSpans(table) {
   const minRowSpans = [];
-
   for (let rowIndex = 0; rowIndex < table.childCount; rowIndex++) {
     const rowSpans = [];
     const row = table.child(rowIndex);
-
     for (let colIndex = 0; colIndex < row.childCount; colIndex++) {
       const cell = row.child(colIndex);
       rowSpans.push(cell.attrs.rowspan);
     }
-
     minRowSpans[rowIndex] = Math.min(...rowSpans);
   }
-
   return minRowSpans;
 }
-
 function fixRowSpans(table) {
   const map = TableMap.get(table);
   const minRowSpans = getMinRowSpans(table);
-
   if (!minRowSpans.some(rowspan => rowspan > 1)) {
     return table;
   }
-
   const rows = [];
-
   for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
     const row = table.child(rowIndex);
-
     if (minRowSpans[rowIndex] === 1) {
       rows.push(row);
     } else {
       const rowCells = [];
-
       for (let colIndex = 0; colIndex < row.childCount; colIndex++) {
         const cell = row.child(colIndex);
         const rowspan = cell.attrs.rowspan - minRowSpans[rowIndex] + 1;
-
         if (rowspan < 1) {
           return null;
         }
-
-        const newCell = cell.type.createChecked({ ...cell.attrs,
+        const newCell = cell.type.createChecked({
+          ...cell.attrs,
           rowspan
         }, cell.content, cell.marks);
         rowCells.push(newCell);
       }
-
       rows.push(row.type.createChecked(row.attrs, rowCells, row.marks));
     }
   }
-
   if (!rows.length) {
     return null;
   }
-
   return table.type.createChecked(table.attrs, rows, table.marks);
 }
-
 export const deleteColumns = (rect, allowAddColumnCustomStep = false) => tr => {
   if (allowAddColumnCustomStep) {
     return deleteColumnsCustomStep(rect)(tr);
   }
-
   return deleteColumnsLegacy(rect)(tr);
 };