@atlaskit/editor-plugin-table 7.16.10 → 7.16.12

package/src/transforms/split.ts

@@ -11,88 +11,78 @@ import { TableMap } from '@atlaskit/editor-tables/table-map';
  * @param columnEnd - End of the rect not included (rect.right)
  */
 export function splitCellsInColumns(
-  tr: Transaction,
-  tablePos: number,
-  columnStart: number,
-  columnEnd: number,
+	tr: Transaction,
+	tablePos: number,
+	columnStart: number,
+	columnEnd: number,
 ): Transaction {
-  let mapStart = tr.mapping.maps.length;
-  const table = tr.doc.nodeAt(tablePos);
-  if (!table) {
-    return tr;
-  }
+	let mapStart = tr.mapping.maps.length;
+	const table = tr.doc.nodeAt(tablePos);
+	if (!table) {
+		return tr;
+	}
 
-  const tableStart = tr.doc.resolve(tablePos).start(1);
-  const map = TableMap.get(table);
+	const tableStart = tr.doc.resolve(tablePos).start(1);
+	const map = TableMap.get(table);
 
-  for (let column = columnStart; column < columnEnd; column++) {
-    for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
-      const cellIndex = rowIndex * map.width + column;
-      const cellPos = map.map[cellIndex];
+	for (let column = columnStart; column < columnEnd; column++) {
+		for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
+			const cellIndex = rowIndex * map.width + column;
+			const cellPos = map.map[cellIndex];
 
-      // Check if the cell is contained by another by another row/column
-      const hasMergedCellsBefore =
-        (column > 0 && map.map[cellIndex - 1] === cellPos) ||
-        (rowIndex > 0 &&
-          map.map[(rowIndex - 1) * map.width + column] === cellPos);
-      // Check if the cell contains another row/column
-      const hasMergedCellsAfter =
-        (column < map.width - 1 && map.map[cellIndex + 1] === cellPos) ||
-        (rowIndex < map.height - 1 &&
-          map.map[(rowIndex + 1) * map.width + column] === cellPos);
-      if (!hasMergedCellsBefore && hasMergedCellsAfter) {
-        // Is a merged cell that start in this row/column
-        const cellNode = table.nodeAt(cellPos) as ProseMirrorNode;
-        if (!cellNode) {
-          continue;
-        }
-        const {
-          colwidth,
-          colspan = 1,
-          rowspan = 1,
-        } = cellNode.attrs as CellAttributes;
+			// Check if the cell is contained by another by another row/column
+			const hasMergedCellsBefore =
+				(column > 0 && map.map[cellIndex - 1] === cellPos) ||
+				(rowIndex > 0 && map.map[(rowIndex - 1) * map.width + column] === cellPos);
+			// Check if the cell contains another row/column
+			const hasMergedCellsAfter =
+				(column < map.width - 1 && map.map[cellIndex + 1] === cellPos) ||
+				(rowIndex < map.height - 1 && map.map[(rowIndex + 1) * map.width + column] === cellPos);
+			if (!hasMergedCellsBefore && hasMergedCellsAfter) {
+				// Is a merged cell that start in this row/column
+				const cellNode = table.nodeAt(cellPos) as ProseMirrorNode;
+				if (!cellNode) {
+					continue;
+				}
+				const { colwidth, colspan = 1, rowspan = 1 } = cellNode.attrs as CellAttributes;
 
-        let mapping = tr.mapping.slice(mapStart);
+				let mapping = tr.mapping.slice(mapStart);
 
-        // Update current node with the simple colspan
-        const baseAttrs: CellAttributes = {
-          ...(cellNode.attrs as CellAttributes),
-          colspan: 1,
-          rowspan: 1,
-        };
-        // Add the new cells
-        for (
-          let cellRowIndex = rowIndex;
-          cellRowIndex < rowIndex + rowspan;
-          cellRowIndex++
-        ) {
-          for (let i = 0; i < colspan; i++) {
-            let mapping = tr.mapping.slice(mapStart);
-            const cellPos = map.positionAt(cellRowIndex, column + i, table);
-            tr.insert(
-              mapping.map(cellPos + tableStart),
-              cellNode.type.createAndFill({
-                ...baseAttrs,
-                colwidth: colwidth ? [colwidth[i]] : undefined,
-              })!,
-            );
-          }
-        }
+				// Update current node with the simple colspan
+				const baseAttrs: CellAttributes = {
+					...(cellNode.attrs as CellAttributes),
+					colspan: 1,
+					rowspan: 1,
+				};
+				// Add the new cells
+				for (let cellRowIndex = rowIndex; cellRowIndex < rowIndex + rowspan; cellRowIndex++) {
+					for (let i = 0; i < colspan; i++) {
+						let mapping = tr.mapping.slice(mapStart);
+						const cellPos = map.positionAt(cellRowIndex, column + i, table);
+						tr.insert(
+							mapping.map(cellPos + tableStart),
+							cellNode.type.createAndFill({
+								...baseAttrs,
+								colwidth: colwidth ? [colwidth[i]] : undefined,
+							})!,
+						);
+					}
+				}
 
-        // Delete the original cell
-        mapping = tr.mapping.slice(mapStart);
-        tr.delete(
-          mapping.map(cellPos + tableStart),
-          mapping.map(cellPos + tableStart + cellNode.nodeSize),
-        );
+				// Delete the original cell
+				mapping = tr.mapping.slice(mapStart);
+				tr.delete(
+					mapping.map(cellPos + tableStart),
+					mapping.map(cellPos + tableStart + cellNode.nodeSize),
+				);
 
-        // Skip rows based on rowspan
-        if (rowspan && rowspan > 1) {
-          rowIndex += rowspan - 1;
-        }
-      }
-    }
-  }
+				// Skip rows based on rowspan
+				if (rowspan && rowspan > 1) {
+					rowIndex += rowspan - 1;
+				}
+			}
+		}
+	}
 
-  return tr;
+	return tr;
 }