@atlaskit/editor-plugin-table 7.16.10 → 7.16.12

package/src/transforms/delete-rows.ts

@@ -9,139 +9,135 @@ import { findTable } from '@atlaskit/editor-tables/utils';
 import { mergeEmptyColumns } from './merge';
 
 export const deleteRows =
-  (rect: Rect, isHeaderRowRequired: boolean = false) =>
-  (tr: Transaction): Transaction => {
-    const table = findTable(tr.selection);
-    if (!table) {
-      return tr;
-    }
+	(rect: Rect, isHeaderRowRequired: boolean = false) =>
+	(tr: Transaction): Transaction => {
+		const table = findTable(tr.selection);
+		if (!table) {
+			return tr;
+		}
 
-    const rowsToDelete: number[] = [];
+		const rowsToDelete: number[] = [];
 
-    const map = TableMap.get(table.node);
+		const map = TableMap.get(table.node);
 
-    for (let i = rect.top; i < rect.bottom; i++) {
-      // skip header row if its required
-      if (isHeaderRowRequired) {
-        const cell = table.node.nodeAt(map.map[i * map.width]);
-        if (cell && cell.type !== cell.type.schema.nodes.tableHeader) {
-          rowsToDelete.push(i);
-        }
-      } else {
-        rowsToDelete.push(i);
-      }
-    }
+		for (let i = rect.top; i < rect.bottom; i++) {
+			// skip header row if its required
+			if (isHeaderRowRequired) {
+				const cell = table.node.nodeAt(map.map[i * map.width]);
+				if (cell && cell.type !== cell.type.schema.nodes.tableHeader) {
+					rowsToDelete.push(i);
+				}
+			} else {
+				rowsToDelete.push(i);
+			}
+		}
 
-    if (!rowsToDelete.length) {
-      return tr;
-    }
+		if (!rowsToDelete.length) {
+			return tr;
+		}
 
-    const rows: PMNode[] = [];
-    const seen: { [key: string]: boolean } = {};
-    const deletedCells: { [key: string]: boolean } = {};
+		const rows: PMNode[] = [];
+		const seen: { [key: string]: boolean } = {};
+		const deletedCells: { [key: string]: boolean } = {};
 
-    for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
-      const rowCells: PMNode[] = [];
-      const row = table.node.child(rowIndex);
+		for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
+			const rowCells: PMNode[] = [];
+			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 cellsInRow = map.cellsInRect({
-          left: 0,
-          top: rowIndex,
-          right: map.width,
-          bottom: rowIndex + 1,
-        });
-        if (rowsToDelete.indexOf(rowIndex) === -1 && !seen[cellPos]) {
-          // decrement rowspans for row-spanning cells that overlap deleted rows
-          if (cellsInRow.indexOf(cellPos) > -1) {
-            let overlappingRows = 0;
-            rowsToDelete.forEach((rowIndexToDelete) => {
-              if (
-                rowIndex < rowIndexToDelete &&
-                cell.attrs.rowspan + rowIndex - 1 >= rowIndexToDelete
-              ) {
-                overlappingRows += 1;
-              }
-            });
-            if (overlappingRows > 0) {
-              const newCell = cell.type.createChecked(
-                {
-                  ...cell.attrs,
-                  rowspan: cell.attrs.rowspan - overlappingRows,
-                },
-                cell.content,
-                cell.marks,
-              );
-              rowCells.push(newCell);
-              seen[cellPos] = true;
-              continue;
-            }
-          } else if (deletedCells[cellPos]) {
-            // if we're removing a row-spanning cell, we need to add missing cells to rows below
-            const attrs: CellAttributes = {
-              ...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;
-          }
+			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 cellsInRow = map.cellsInRect({
+					left: 0,
+					top: rowIndex,
+					right: map.width,
+					bottom: rowIndex + 1,
+				});
+				if (rowsToDelete.indexOf(rowIndex) === -1 && !seen[cellPos]) {
+					// decrement rowspans for row-spanning cells that overlap deleted rows
+					if (cellsInRow.indexOf(cellPos) > -1) {
+						let overlappingRows = 0;
+						rowsToDelete.forEach((rowIndexToDelete) => {
+							if (
+								rowIndex < rowIndexToDelete &&
+								cell.attrs.rowspan + rowIndex - 1 >= rowIndexToDelete
+							) {
+								overlappingRows += 1;
+							}
+						});
+						if (overlappingRows > 0) {
+							const newCell = cell.type.createChecked(
+								{
+									...cell.attrs,
+									rowspan: cell.attrs.rowspan - overlappingRows,
+								},
+								cell.content,
+								cell.marks,
+							);
+							rowCells.push(newCell);
+							seen[cellPos] = true;
+							continue;
+						}
+					} else if (deletedCells[cellPos]) {
+						// if we're removing a row-spanning cell, we need to add missing cells to rows below
+						const attrs: CellAttributes = {
+							...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
-          if (!seen[cellPos]) {
-            seen[cellPos] = true;
-            rowCells.push(cell);
-          }
-        } else if (cellsInRow.indexOf(cellPos) > -1) {
-          deletedCells[cellPos] = true;
-        }
-      }
+					// normal cells that we want to keep
+					if (!seen[cellPos]) {
+						seen[cellPos] = true;
+						rowCells.push(cell);
+					}
+				} else if (cellsInRow.indexOf(cellPos) > -1) {
+					deletedCells[cellPos] = true;
+				}
+			}
 
-      if (rowCells.length) {
-        rows.push(row.type.createChecked(row.attrs, rowCells, row.marks));
-      }
-    }
+			if (rowCells.length) {
+				rows.push(row.type.createChecked(row.attrs, rowCells, row.marks));
+			}
+		}
 
-    if (!rows.length) {
-      return tr;
-    }
+		if (!rows.length) {
+			return tr;
+		}
 
-    const newTable = table.node.type.createChecked(
-      table.node.attrs,
-      rows,
-      table.node.marks,
-    );
-    const fixedTable = mergeEmptyColumns(newTable);
-    if (fixedTable === null) {
-      return tr;
-    }
-    const cursorPos = getNextCursorPos(newTable, rowsToDelete);
+		const newTable = table.node.type.createChecked(table.node.attrs, rows, table.node.marks);
+		const fixedTable = mergeEmptyColumns(newTable);
+		if (fixedTable === null) {
+			return tr;
+		}
+		const cursorPos = getNextCursorPos(newTable, rowsToDelete);
 
-    return (
-      tr
-        .replaceWith(table.pos, table.pos + table.node.nodeSize, fixedTable)
-        // move cursor before the deleted rows if possible, otherwise - to the first row
-        .setSelection(Selection.near(tr.doc.resolve(table.pos + cursorPos)))
-    );
-  };
+		return (
+			tr
+				.replaceWith(table.pos, table.pos + table.node.nodeSize, fixedTable)
+				// move cursor before the deleted rows if possible, otherwise - to the first row
+				.setSelection(Selection.near(tr.doc.resolve(table.pos + cursorPos)))
+		);
+	};
 
 function getNextCursorPos(table: PMNode, deletedRows: number[]): number {
-  const minRow = Math.min(...deletedRows);
-  const nextRowWithCursor = minRow > 0 ? minRow - 1 : 0;
-  const map = TableMap.get(table);
-  return map.map[nextRowWithCursor * map.width];
+	const minRow = Math.min(...deletedRows);
+	const nextRowWithCursor = minRow > 0 ? minRow - 1 : 0;
+	const map = TableMap.get(table);
+	return map.map[nextRowWithCursor * map.width];
 }