@lexical/table 0.29.1-nightly.20250401.0 → 0.29.1-nightly.20250403.0

package/LexicalTable.dev.mjs

@@ -7,7 +7,7 @@
  */
 
 import { addClassNamesToElement, $descendantsMatching, $findMatchingParent, removeClassNamesFromElement, objectKlassEquals, isHTMLElement as isHTMLElement$1, $insertFirst as $insertFirst$1, mergeRegister, $insertNodeToNearestRoot, $unwrapAndFilterDescendants } from '@lexical/utils';
-import { ElementNode, isHTMLElement, $isInlineElementOrDecoratorNode, $isTextNode, $isLineBreakNode, $createParagraphNode, $applyNodeReplacement, createCommand, $createTextNode, $getSelection, $isRangeSelection, $createPoint, $isParagraphNode, $isElementNode, $normalizeSelection__EXPERIMENTAL, isCurrentlyReadOnlyMode, TEXT_TYPE_TO_FORMAT, $getNodeByKey, $getEditor, $setSelection, SELECTION_CHANGE_COMMAND, getDOMSelection, $createRangeSelection, $isRootNode, INSERT_PARAGRAPH_COMMAND, COMMAND_PRIORITY_HIGH, KEY_ESCAPE_COMMAND, COMMAND_PRIORITY_CRITICAL, CUT_COMMAND, FORMAT_TEXT_COMMAND, FORMAT_ELEMENT_COMMAND, CONTROLLED_TEXT_INSERTION_COMMAND, KEY_TAB_COMMAND, FOCUS_COMMAND, SELECTION_INSERT_CLIPBOARD_NODES_COMMAND, $getPreviousSelection, $getNearestNodeFromDOMNode, $createRangeSelectionFromDom, $isRootOrShadowRoot, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_UP_COMMAND, KEY_ARROW_LEFT_COMMAND, KEY_ARROW_RIGHT_COMMAND, DELETE_WORD_COMMAND, DELETE_LINE_COMMAND, DELETE_CHARACTER_COMMAND, KEY_BACKSPACE_COMMAND, KEY_DELETE_COMMAND, isDOMNode, $caretFromPoint, $isExtendableTextPointCaret, $extendCaretToRange, $isSiblingCaret, $getSiblingCaret, $setPointFromCaret, $normalizeCaret, $getAdjacentChildCaret, $isChildCaret, $getChildCaret, setDOMUnmanaged, COMMAND_PRIORITY_EDITOR, CLICK_COMMAND } from 'lexical';
+import { ElementNode, isHTMLElement, $isInlineElementOrDecoratorNode, $isTextNode, $isLineBreakNode, $createParagraphNode, $applyNodeReplacement, createCommand, $createTextNode, $getSelection, $isRangeSelection, $isParagraphNode, $createPoint, $isElementNode, $normalizeSelection__EXPERIMENTAL, isCurrentlyReadOnlyMode, TEXT_TYPE_TO_FORMAT, $getNodeByKey, $getEditor, $setSelection, SELECTION_CHANGE_COMMAND, getDOMSelection, $createRangeSelection, $isRootNode, INSERT_PARAGRAPH_COMMAND, COMMAND_PRIORITY_HIGH, KEY_ESCAPE_COMMAND, COMMAND_PRIORITY_CRITICAL, CUT_COMMAND, FORMAT_TEXT_COMMAND, FORMAT_ELEMENT_COMMAND, CONTROLLED_TEXT_INSERTION_COMMAND, KEY_TAB_COMMAND, FOCUS_COMMAND, SELECTION_INSERT_CLIPBOARD_NODES_COMMAND, $getPreviousSelection, $getNearestNodeFromDOMNode, $createRangeSelectionFromDom, $isRootOrShadowRoot, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_UP_COMMAND, KEY_ARROW_LEFT_COMMAND, KEY_ARROW_RIGHT_COMMAND, DELETE_WORD_COMMAND, DELETE_LINE_COMMAND, DELETE_CHARACTER_COMMAND, KEY_BACKSPACE_COMMAND, KEY_DELETE_COMMAND, isDOMNode, $caretFromPoint, $isExtendableTextPointCaret, $extendCaretToRange, $isSiblingCaret, $getSiblingCaret, $setPointFromCaret, $normalizeCaret, $getAdjacentChildCaret, $isChildCaret, $getChildCaret, setDOMUnmanaged, COMMAND_PRIORITY_EDITOR, CLICK_COMMAND } from 'lexical';
 import { copyToClipboard, $getClipboardDataFromSelection } from '@lexical/clipboard';
 
 /**
@@ -533,6 +533,10 @@ function $removeTableRowAtIndex(tableNode, indexToDelete) {
   targetRowNode.remove();
   return tableNode;
 }
+
+/**
+ * @deprecated This function does not support merged cells. Use {@link $insertTableRowAtSelection} or {@link $insertTableRowAtNode} instead.
+ */
 function $insertTableRow(tableNode, targetIndex, shouldInsertAfter = true, rowCount, table) {
   const tableRows = tableNode.getChildren();
   if (targetIndex >= tableRows.length || targetIndex < 0) {
@@ -585,7 +589,7 @@ const getHeaderState = (currentState, possibleState) => {
  * taking into account any spans. If successful, returns the
  * inserted table row node.
  */
-function $insertTableRow__EXPERIMENTAL(insertAfter = true) {
+function $insertTableRowAtSelection(insertAfter = true) {
   const selection = $getSelection();
   if (!($isRangeSelection(selection) || $isTableSelection(selection))) {
     formatDevErrorMessage(`Expected a RangeSelection or TableSelection`);
@@ -594,17 +598,40 @@ function $insertTableRow__EXPERIMENTAL(insertAfter = true) {
   const focus = selection.focus.getNode();
   const [anchorCell] = $getNodeTriplet(anchor);
   const [focusCell,, grid] = $getNodeTriplet(focus);
-  const [gridMap, focusCellMap, anchorCellMap] = $computeTableMap(grid, focusCell, anchorCell);
-  const columnCount = gridMap[0].length;
+  const [, focusCellMap, anchorCellMap] = $computeTableMap(grid, focusCell, anchorCell);
   const {
     startRow: anchorStartRow
   } = anchorCellMap;
   const {
     startRow: focusStartRow
   } = focusCellMap;
+  if (insertAfter) {
+    return $insertTableRowAtNode(anchorStartRow + anchorCell.__rowSpan > focusStartRow + focusCell.__rowSpan ? anchorCell : focusCell, true);
+  } else {
+    return $insertTableRowAtNode(focusStartRow < anchorStartRow ? focusCell : anchorCell, false);
+  }
+}
+
+/**
+ * @deprecated renamed to {@link $insertTableRowAtSelection}
+ */
+const $insertTableRow__EXPERIMENTAL = $insertTableRowAtSelection;
+
+/**
+ * Inserts a table row before or after the given cell node,
+ * taking into account any spans. If successful, returns the
+ * inserted table row node.
+ */
+function $insertTableRowAtNode(cellNode, insertAfter = true) {
+  const [,, grid] = $getNodeTriplet(cellNode);
+  const [gridMap, cellMap] = $computeTableMap(grid, cellNode, cellNode);
+  const columnCount = gridMap[0].length;
+  const {
+    startRow: cellStartRow
+  } = cellMap;
   let insertedRow = null;
   if (insertAfter) {
-    const insertAfterEndRow = Math.max(focusStartRow + focusCell.__rowSpan, anchorStartRow + anchorCell.__rowSpan) - 1;
+    const insertAfterEndRow = cellStartRow + cellNode.__rowSpan - 1;
     const insertAfterEndRowMap = gridMap[insertAfterEndRow];
     const newRow = $createTableRowNode();
     for (let i = 0; i < columnCount; i++) {
@@ -628,7 +655,7 @@ function $insertTableRow__EXPERIMENTAL(insertAfter = true) {
     insertAfterEndRowNode.insertAfter(newRow);
     insertedRow = newRow;
   } else {
-    const insertBeforeStartRow = Math.min(focusStartRow, anchorStartRow);
+    const insertBeforeStartRow = cellStartRow;
     const insertBeforeStartRowMap = gridMap[insertBeforeStartRow];
     const newRow = $createTableRowNode();
     for (let i = 0; i < columnCount; i++) {
@@ -654,6 +681,10 @@ function $insertTableRow__EXPERIMENTAL(insertAfter = true) {
   }
   return insertedRow;
 }
+
+/**
+ * @deprecated This function does not support merged cells. Use {@link $insertTableColumnAtSelection} or {@link $insertTableColumnAtNode} instead.
+ */
 function $insertTableColumn(tableNode, targetIndex, shouldInsertAfter = true, columnCount, table) {
   const tableRows = tableNode.getChildren();
   const tableCellsToBeInserted = [];
@@ -704,7 +735,7 @@ function $insertTableColumn(tableNode, targetIndex, shouldInsertAfter = true, co
  * taking into account any spans. If successful, returns the
  * first inserted cell node.
  */
-function $insertTableColumn__EXPERIMENTAL(insertAfter = true) {
+function $insertTableColumnAtSelection(insertAfter = true) {
   const selection = $getSelection();
   if (!($isRangeSelection(selection) || $isTableSelection(selection))) {
     formatDevErrorMessage(`Expected a RangeSelection or TableSelection`);
@@ -713,10 +744,38 @@ function $insertTableColumn__EXPERIMENTAL(insertAfter = true) {
   const focus = selection.focus.getNode();
   const [anchorCell] = $getNodeTriplet(anchor);
   const [focusCell,, grid] = $getNodeTriplet(focus);
-  const [gridMap, focusCellMap, anchorCellMap] = $computeTableMap(grid, focusCell, anchorCell);
+  const [, focusCellMap, anchorCellMap] = $computeTableMap(grid, focusCell, anchorCell);
+  const {
+    startColumn: anchorStartColumn
+  } = anchorCellMap;
+  const {
+    startColumn: focusStartColumn
+  } = focusCellMap;
+  if (insertAfter) {
+    return $insertTableColumnAtNode(anchorStartColumn + anchorCell.__colSpan > focusStartColumn + focusCell.__colSpan ? anchorCell : focusCell, true);
+  } else {
+    return $insertTableColumnAtNode(focusStartColumn < anchorStartColumn ? focusCell : anchorCell, false);
+  }
+}
+
+/**
+ * @deprecated renamed to {@link $insertTableColumnAtSelection}
+ */
+const $insertTableColumn__EXPERIMENTAL = $insertTableColumnAtSelection;
+
+/**
+ * Inserts a column before or after the given cell node,
+ * taking into account any spans. If successful, returns the
+ * first inserted cell node.
+ */
+function $insertTableColumnAtNode(cellNode, insertAfter = true, shouldSetSelection = true) {
+  const [,, grid] = $getNodeTriplet(cellNode);
+  const [gridMap, cellMap] = $computeTableMap(grid, cellNode, cellNode);
   const rowCount = gridMap.length;
-  const startColumn = insertAfter ? Math.max(focusCellMap.startColumn, anchorCellMap.startColumn) : Math.min(focusCellMap.startColumn, anchorCellMap.startColumn);
-  const insertAfterColumn = insertAfter ? startColumn + focusCell.__colSpan - 1 : startColumn - 1;
+  const {
+    startColumn
+  } = cellMap;
+  const insertAfterColumn = insertAfter ? startColumn + cellNode.__colSpan - 1 : startColumn - 1;
   const gridFirstChild = grid.getFirstChild();
   if (!$isTableRowNode(gridFirstChild)) {
     formatDevErrorMessage(`Expected firstTable child to be a row`);
@@ -773,7 +832,7 @@ function $insertTableColumn__EXPERIMENTAL(insertAfter = true) {
       currentCell.setColSpan(currentCell.__colSpan + 1);
     }
   }
-  if (firstInsertedCell !== null) {
+  if (firstInsertedCell !== null && shouldSetSelection) {
     $moveSelectionToCell(firstInsertedCell);
   }
   const colWidths = grid.getColWidths();
@@ -786,6 +845,10 @@ function $insertTableColumn__EXPERIMENTAL(insertAfter = true) {
   }
   return firstInsertedCell;
 }
+
+/**
+ * @deprecated This function does not support merged cells. Use {@link $deleteTableColumnAtSelection} instead.
+ */
 function $deleteTableColumn(tableNode, targetIndex) {
   const tableRows = tableNode.getChildren();
   for (let i = 0; i < tableRows.length; i++) {
@@ -800,7 +863,7 @@ function $deleteTableColumn(tableNode, targetIndex) {
   }
   return tableNode;
 }
-function $deleteTableRow__EXPERIMENTAL() {
+function $deleteTableRowAtSelection() {
   const selection = $getSelection();
   if (!($isRangeSelection(selection) || $isTableSelection(selection))) {
     formatDevErrorMessage(`Expected a RangeSelection or TableSelection`);
@@ -885,7 +948,12 @@ function $deleteTableRow__EXPERIMENTAL() {
     $moveSelectionToCell(cell);
   }
 }
-function $deleteTableColumn__EXPERIMENTAL() {
+
+/**
+ * @deprecated renamed to {@link $deleteTableRowAtSelection}
+ */
+const $deleteTableRow__EXPERIMENTAL = $deleteTableRowAtSelection;
+function $deleteTableColumnAtSelection() {
   const selection = $getSelection();
   if (!($isRangeSelection(selection) || $isTableSelection(selection))) {
     formatDevErrorMessage(`Expected a RangeSelection or TableSelection`);
@@ -959,6 +1027,11 @@ function $deleteTableColumn__EXPERIMENTAL() {
     grid.setColWidths(newColWidths);
   }
 }
+
+/**
+ * @deprecated renamed to {@link $deleteTableColumnAtSelection}
+ */
+const $deleteTableColumn__EXPERIMENTAL = $deleteTableColumnAtSelection;
 function $moveSelectionToCell(cell) {
   const firstDescendant = cell.getFirstDescendant();
   if (firstDescendant == null) {
@@ -975,13 +1048,122 @@ function $insertFirst(parent, node) {
     parent.append(node);
   }
 }
+function $mergeCells(cellNodes) {
+  if (cellNodes.length === 0) {
+    return null;
+  }
+
+  // Find the table node
+  const tableNode = $getTableNodeFromLexicalNodeOrThrow(cellNodes[0]);
+  const [gridMap] = $computeTableMapSkipCellCheck(tableNode, null, null);
+
+  // Find the boundaries of the selection including merged cells
+  let minRow = Infinity;
+  let maxRow = -Infinity;
+  let minCol = Infinity;
+  let maxCol = -Infinity;
+
+  // First pass: find the actual boundaries considering merged cells
+  const processedCells = new Set();
+  for (const row of gridMap) {
+    for (const mapCell of row) {
+      if (!mapCell || !mapCell.cell) {
+        continue;
+      }
+      const cellKey = mapCell.cell.getKey();
+      if (processedCells.has(cellKey)) {
+        continue;
+      }
+      if (cellNodes.some(cell => cell.is(mapCell.cell))) {
+        processedCells.add(cellKey);
+        // Get the actual position of this cell in the grid
+        const cellStartRow = mapCell.startRow;
+        const cellStartCol = mapCell.startColumn;
+        const cellRowSpan = mapCell.cell.__rowSpan || 1;
+        const cellColSpan = mapCell.cell.__colSpan || 1;
+
+        // Update boundaries considering the cell's actual position and span
+        minRow = Math.min(minRow, cellStartRow);
+        maxRow = Math.max(maxRow, cellStartRow + cellRowSpan - 1);
+        minCol = Math.min(minCol, cellStartCol);
+        maxCol = Math.max(maxCol, cellStartCol + cellColSpan - 1);
+      }
+    }
+  }
+
+  // Validate boundaries
+  if (minRow === Infinity || minCol === Infinity) {
+    return null;
+  }
+
+  // The total span of the merged cell
+  const totalRowSpan = maxRow - minRow + 1;
+  const totalColSpan = maxCol - minCol + 1;
+
+  // Use the top-left cell as the target cell
+  const targetCellMap = gridMap[minRow][minCol];
+  if (!targetCellMap.cell) {
+    return null;
+  }
+  const targetCell = targetCellMap.cell;
+
+  // Set the spans for the target cell
+  targetCell.setColSpan(totalColSpan);
+  targetCell.setRowSpan(totalRowSpan);
+
+  // Move content from other cells to the target cell
+  const seenCells = new Set([targetCell.getKey()]);
+
+  // Second pass: merge content and remove other cells
+  for (let row = minRow; row <= maxRow; row++) {
+    for (let col = minCol; col <= maxCol; col++) {
+      const mapCell = gridMap[row][col];
+      if (!mapCell.cell) {
+        continue;
+      }
+      const currentCell = mapCell.cell;
+      const key = currentCell.getKey();
+      if (!seenCells.has(key)) {
+        seenCells.add(key);
+        const isEmpty = $cellContainsEmptyParagraph(currentCell);
+        if (!isEmpty) {
+          targetCell.append(...currentCell.getChildren());
+        }
+        currentCell.remove();
+      }
+    }
+  }
+
+  // Ensure target cell has content
+  if (targetCell.getChildrenSize() === 0) {
+    targetCell.append($createParagraphNode());
+  }
+  return targetCell;
+}
+function $cellContainsEmptyParagraph(cell) {
+  if (cell.getChildrenSize() !== 1) {
+    return false;
+  }
+  const firstChild = cell.getFirstChildOrThrow();
+  if (!$isParagraphNode(firstChild) || !firstChild.isEmpty()) {
+    return false;
+  }
+  return true;
+}
 function $unmergeCell() {
   const selection = $getSelection();
   if (!($isRangeSelection(selection) || $isTableSelection(selection))) {
     formatDevErrorMessage(`Expected a RangeSelection or TableSelection`);
   }
   const anchor = selection.anchor.getNode();
-  const [cell, row, grid] = $getNodeTriplet(anchor);
+  const cellNode = $findMatchingParent(anchor, $isTableCellNode);
+  if (!$isTableCellNode(cellNode)) {
+    formatDevErrorMessage(`Expected to find a parent TableCellNode`);
+  }
+  return $unmergeCellNode(cellNode);
+}
+function $unmergeCellNode(cellNode) {
+  const [cell, row, grid] = $getNodeTriplet(cellNode);
   const colSpan = cell.__colSpan;
   const rowSpan = cell.__rowSpan;
   if (colSpan === 1 && rowSpan === 1) {
@@ -2283,62 +2465,115 @@ function applyTableHandlers(tableNode, element, editor, hasTabHandler) {
     if (nodes.length !== 1 || !$isTableNode(nodes[0]) || !isSelectionInsideOfGrid || anchorAndFocus === null) {
       return false;
     }
-    const [anchor] = anchorAndFocus;
-    const newGrid = nodes[0];
-    const newGridRows = newGrid.getChildren();
-    const newColumnCount = newGrid.getFirstChildOrThrow().getChildrenSize();
-    const newRowCount = newGrid.getChildrenSize();
-    const gridCellNode = $findMatchingParent(anchor.getNode(), n => $isTableCellNode(n));
-    const gridRowNode = gridCellNode && $findMatchingParent(gridCellNode, n => $isTableRowNode(n));
-    const gridNode = gridRowNode && $findMatchingParent(gridRowNode, n => $isTableNode(n));
-    if (!$isTableCellNode(gridCellNode) || !$isTableRowNode(gridRowNode) || !$isTableNode(gridNode)) {
+    const [anchor, focus] = anchorAndFocus;
+    const [anchorCellNode, anchorRowNode, gridNode] = $getNodeTriplet(anchor);
+    const focusCellNode = $findMatchingParent(focus.getNode(), n => $isTableCellNode(n));
+    if (!$isTableCellNode(anchorCellNode) || !$isTableCellNode(focusCellNode) || !$isTableRowNode(anchorRowNode) || !$isTableNode(gridNode)) {
       return false;
     }
-    const startY = gridRowNode.getIndexWithinParent();
-    const stopY = Math.min(gridNode.getChildrenSize() - 1, startY + newRowCount - 1);
-    const startX = gridCellNode.getIndexWithinParent();
-    const stopX = Math.min(gridRowNode.getChildrenSize() - 1, startX + newColumnCount - 1);
-    const fromX = Math.min(startX, stopX);
-    const fromY = Math.min(startY, stopY);
-    const toX = Math.max(startX, stopX);
-    const toY = Math.max(startY, stopY);
-    const gridRowNodes = gridNode.getChildren();
-    let newRowIdx = 0;
-    for (let r = fromY; r <= toY; r++) {
-      const currentGridRowNode = gridRowNodes[r];
-      if (!$isTableRowNode(currentGridRowNode)) {
-        return false;
-      }
-      const newGridRowNode = newGridRows[newRowIdx];
-      if (!$isTableRowNode(newGridRowNode)) {
-        return false;
+    const templateGrid = nodes[0];
+    const [initialGridMap, anchorCellMap, focusCellMap] = $computeTableMap(gridNode, anchorCellNode, focusCellNode);
+    const [templateGridMap] = $computeTableMapSkipCellCheck(templateGrid, null, null);
+    const initialRowCount = initialGridMap.length;
+    const initialColCount = initialRowCount > 0 ? initialGridMap[0].length : 0;
+
+    // If we have a range selection, we'll fit the template grid into the
+    // table, growing the table if necessary.
+    let startRow = anchorCellMap.startRow;
+    let startCol = anchorCellMap.startColumn;
+    let affectedRowCount = templateGridMap.length;
+    let affectedColCount = affectedRowCount > 0 ? templateGridMap[0].length : 0;
+    if (isTableSelection) {
+      // If we have a table selection, we'll only modify the cells within
+      // the selection boundary.
+      const selectionBoundary = $computeTableCellRectBoundary(initialGridMap, anchorCellMap, focusCellMap);
+      const selectionRowCount = selectionBoundary.maxRow - selectionBoundary.minRow + 1;
+      const selectionColCount = selectionBoundary.maxColumn - selectionBoundary.minColumn + 1;
+      startRow = selectionBoundary.minRow;
+      startCol = selectionBoundary.minColumn;
+      affectedRowCount = Math.min(affectedRowCount, selectionRowCount);
+      affectedColCount = Math.min(affectedColCount, selectionColCount);
+    }
+
+    // Step 1: Unmerge all merged cells within the affected area
+    let didPerformMergeOperations = false;
+    const lastRowForUnmerge = Math.min(initialRowCount, startRow + affectedRowCount) - 1;
+    const lastColForUnmerge = Math.min(initialColCount, startCol + affectedColCount) - 1;
+    const unmergedKeys = new Set();
+    for (let row = startRow; row <= lastRowForUnmerge; row++) {
+      for (let col = startCol; col <= lastColForUnmerge; col++) {
+        const cellMap = initialGridMap[row][col];
+        if (unmergedKeys.has(cellMap.cell.getKey())) {
+          continue; // cell was a merged cell that was already handled
+        }
+        if (cellMap.cell.__rowSpan === 1 && cellMap.cell.__colSpan === 1) {
+          continue; // cell is not a merged cell
+        }
+        $unmergeCellNode(cellMap.cell);
+        unmergedKeys.add(cellMap.cell.getKey());
+        didPerformMergeOperations = true;
       }
-      const gridCellNodes = currentGridRowNode.getChildren();
-      const newGridCellNodes = newGridRowNode.getChildren();
-      let newColumnIdx = 0;
-      for (let c = fromX; c <= toX; c++) {
-        const currentGridCellNode = gridCellNodes[c];
-        if (!$isTableCellNode(currentGridCellNode)) {
-          return false;
+    }
+    let [interimGridMap] = $computeTableMapSkipCellCheck(gridNode.getWritable(), null, null);
+
+    // Step 2: Expand current table (if needed)
+    const rowsToInsert = affectedRowCount - initialRowCount + startRow;
+    for (let i = 0; i < rowsToInsert; i++) {
+      const cellMap = interimGridMap[initialRowCount - 1][0];
+      $insertTableRowAtNode(cellMap.cell);
+    }
+    const colsToInsert = affectedColCount - initialColCount + startCol;
+    for (let i = 0; i < colsToInsert; i++) {
+      const cellMap = interimGridMap[0][initialColCount - 1];
+      $insertTableColumnAtNode(cellMap.cell, true, false);
+    }
+    [interimGridMap] = $computeTableMapSkipCellCheck(gridNode.getWritable(), null, null);
+
+    // Step 3: Merge cells and set cell content, to match template grid
+    for (let row = startRow; row < startRow + affectedRowCount; row++) {
+      for (let col = startCol; col < startCol + affectedColCount; col++) {
+        const templateRow = row - startRow;
+        const templateCol = col - startCol;
+        const templateCellMap = templateGridMap[templateRow][templateCol];
+        if (templateCellMap.startRow !== templateRow || templateCellMap.startColumn !== templateCol) {
+          continue; // cell is a merged cell that was already handled
         }
-        const newGridCellNode = newGridCellNodes[newColumnIdx];
-        if (!$isTableCellNode(newGridCellNode)) {
-          return false;
+        const templateCell = templateCellMap.cell;
+        if (templateCell.__rowSpan !== 1 || templateCell.__colSpan !== 1) {
+          const cellsToMerge = [];
+          const lastRowForMerge = Math.min(row + templateCell.__rowSpan, startRow + affectedRowCount) - 1;
+          const lastColForMerge = Math.min(col + templateCell.__colSpan, startCol + affectedColCount) - 1;
+          for (let r = row; r <= lastRowForMerge; r++) {
+            for (let c = col; c <= lastColForMerge; c++) {
+              const cellMap = interimGridMap[r][c];
+              cellsToMerge.push(cellMap.cell);
+            }
+          }
+          $mergeCells(cellsToMerge);
+          didPerformMergeOperations = true;
         }
-        const originalChildren = currentGridCellNode.getChildren();
-        newGridCellNode.getChildren().forEach(child => {
+        const {
+          cell
+        } = interimGridMap[row][col];
+        const originalChildren = cell.getChildren();
+        templateCell.getChildren().forEach(child => {
           if ($isTextNode(child)) {
             const paragraphNode = $createParagraphNode();
             paragraphNode.append(child);
-            currentGridCellNode.append(child);
+            cell.append(child);
           } else {
-            currentGridCellNode.append(child);
+            cell.append(child);
           }
         });
         originalChildren.forEach(n => n.remove());
-        newColumnIdx++;
       }
-      newRowIdx++;
+    }
+    if (isTableSelection && didPerformMergeOperations) {
+      // reset the table selection in case the anchor or focus cell was
+      // removed via merge operations
+      const [finalGridMap] = $computeTableMapSkipCellCheck(gridNode.getWritable(), null, null);
+      const newAnchorCellMap = finalGridMap[anchorCellMap.startRow][anchorCellMap.startColumn];
+      newAnchorCellMap.cell.selectEnd();
     }
     return true;
   }, COMMAND_PRIORITY_CRITICAL));
@@ -3889,4 +4124,4 @@ function registerTablePlugin(editor) {
   }, COMMAND_PRIORITY_EDITOR), editor.registerCommand(CLICK_COMMAND, $tableClickCommand, COMMAND_PRIORITY_EDITOR), editor.registerNodeTransform(TableNode, $tableTransform), editor.registerNodeTransform(TableRowNode, $tableRowTransform), editor.registerNodeTransform(TableCellNode, $tableCellTransform));
 }
 
-export { $computeTableMap, $computeTableMapSkipCellCheck, $createTableCellNode, $createTableNode, $createTableNodeWithDimensions, $createTableRowNode, $createTableSelection, $createTableSelectionFrom, $deleteTableColumn, $deleteTableColumn__EXPERIMENTAL, $deleteTableRow__EXPERIMENTAL, $findCellNode, $findTableNode, $getElementForTableNode, $getNodeTriplet, $getTableAndElementByKey, $getTableCellNodeFromLexicalNode, $getTableCellNodeRect, $getTableColumnIndexFromTableCellNode, $getTableNodeFromLexicalNodeOrThrow, $getTableRowIndexFromTableCellNode, $getTableRowNodeFromTableCellNodeOrThrow, $insertTableColumn, $insertTableColumn__EXPERIMENTAL, $insertTableRow, $insertTableRow__EXPERIMENTAL, $isScrollableTablesActive, $isTableCellNode, $isTableNode, $isTableRowNode, $isTableSelection, $removeTableRowAtIndex, $unmergeCell, INSERT_TABLE_COMMAND, TableCellHeaderStates, TableCellNode, TableNode, TableObserver, TableRowNode, applyTableHandlers, getDOMCellFromTarget, getTableElement, getTableObserverFromTableElement, registerTableCellUnmergeTransform, registerTablePlugin, registerTableSelectionObserver, setScrollableTablesActive };
+export { $computeTableMap, $computeTableMapSkipCellCheck, $createTableCellNode, $createTableNode, $createTableNodeWithDimensions, $createTableRowNode, $createTableSelection, $createTableSelectionFrom, $deleteTableColumn, $deleteTableColumnAtSelection, $deleteTableColumn__EXPERIMENTAL, $deleteTableRowAtSelection, $deleteTableRow__EXPERIMENTAL, $findCellNode, $findTableNode, $getElementForTableNode, $getNodeTriplet, $getTableAndElementByKey, $getTableCellNodeFromLexicalNode, $getTableCellNodeRect, $getTableColumnIndexFromTableCellNode, $getTableNodeFromLexicalNodeOrThrow, $getTableRowIndexFromTableCellNode, $getTableRowNodeFromTableCellNodeOrThrow, $insertTableColumn, $insertTableColumnAtSelection, $insertTableColumn__EXPERIMENTAL, $insertTableRow, $insertTableRowAtSelection, $insertTableRow__EXPERIMENTAL, $isScrollableTablesActive, $isTableCellNode, $isTableNode, $isTableRowNode, $isTableSelection, $mergeCells, $removeTableRowAtIndex, $unmergeCell, INSERT_TABLE_COMMAND, TableCellHeaderStates, TableCellNode, TableNode, TableObserver, TableRowNode, applyTableHandlers, getDOMCellFromTarget, getTableElement, getTableObserverFromTableElement, registerTableCellUnmergeTransform, registerTablePlugin, registerTableSelectionObserver, setScrollableTablesActive };

package/LexicalTable.js.flow

@@ -239,6 +239,7 @@ declare export function $removeTableRowAtIndex(
   indexToDelete: number,
 ): TableNode;
 
+/** @deprecated This function does not support merged cells. Use {@link $insertTableRowAtSelection} or {@link $insertTableRowAtNode} instead. */
 declare export function $insertTableRow(
   tableNode: TableNode,
   targetIndex: number,
@@ -247,6 +248,7 @@ declare export function $insertTableRow(
   table: TableDOMTable,
 ): TableNode;
 
+/** @deprecated This function does not support merged cells. Use {@link $insertTableColumnAtSelection} or {@link $insertTableColumnAtNode} instead. */
 declare export function $insertTableColumn(
   tableNode: TableNode,
   targetIndex: number,
@@ -255,21 +257,49 @@ declare export function $insertTableColumn(
   table: TableDOMTable,
 ): TableNode;
 
+/** @deprecated This function does not support merged cells. Use {@link $deleteTableColumnAtSelection} instead. */
 declare export function $deleteTableColumn(
   tableNode: TableNode,
   targetIndex: number,
 ): TableNode;
 
+declare export function $insertTableRowAtSelection(
+  insertAfter?: boolean,
+): TableRowNode | null;
+
+declare export function $insertTableRowAtNode(
+  cellNode: TableCellNode,
+  insertAfter?: boolean,
+): TableRowNode | null;
+
+declare export function $insertTableColumnAtSelection(
+  insertAfter?: boolean,
+): TableCellNode | null;
+
+declare export function $insertTableColumnAtNode(
+  cellNode: TableCellNode,
+  insertAfter?: boolean,
+  shouldSetSelection?: boolean,
+): TableCellNode | null
+
+declare export function $deleteTableRowAtSelection(): void;
+
+declare export function $deleteTableColumnAtSelection(): void;
+
+/** @deprecated renamed to {@link $insertTableRowAtSelection} */ 
 declare export function $insertTableRow__EXPERIMENTAL(
   insertAfter: boolean,
 ): TableRowNode | null;
 
+/** @deprecated renamed to {@link $insertTableColumnAtSelection} */ 
 declare export function $insertTableColumn__EXPERIMENTAL(
   insertAfter: boolean,
 ): TableCellNode | null;
 
+/** @deprecated renamed to {@link $deleteTableRowAtSelection} */ 
 declare export function $deleteTableRow__EXPERIMENTAL(): void;
 
+/** @deprecated renamed to {@link $deleteTableColumnAtSelection} */ 
 declare export function $deleteTableColumn__EXPERIMENTAL(): void;
 
 declare export function $unmergeCell(): void;

package/LexicalTable.mjs

@@ -18,7 +18,9 @@ export const $createTableRowNode = mod.$createTableRowNode;
 export const $createTableSelection = mod.$createTableSelection;
 export const $createTableSelectionFrom = mod.$createTableSelectionFrom;
 export const $deleteTableColumn = mod.$deleteTableColumn;
+export const $deleteTableColumnAtSelection = mod.$deleteTableColumnAtSelection;
 export const $deleteTableColumn__EXPERIMENTAL = mod.$deleteTableColumn__EXPERIMENTAL;
+export const $deleteTableRowAtSelection = mod.$deleteTableRowAtSelection;
 export const $deleteTableRow__EXPERIMENTAL = mod.$deleteTableRow__EXPERIMENTAL;
 export const $findCellNode = mod.$findCellNode;
 export const $findTableNode = mod.$findTableNode;
@@ -32,14 +34,17 @@ export const $getTableNodeFromLexicalNodeOrThrow = mod.$getTableNodeFromLexicalN
 export const $getTableRowIndexFromTableCellNode = mod.$getTableRowIndexFromTableCellNode;
 export const $getTableRowNodeFromTableCellNodeOrThrow = mod.$getTableRowNodeFromTableCellNodeOrThrow;
 export const $insertTableColumn = mod.$insertTableColumn;
+export const $insertTableColumnAtSelection = mod.$insertTableColumnAtSelection;
 export const $insertTableColumn__EXPERIMENTAL = mod.$insertTableColumn__EXPERIMENTAL;
 export const $insertTableRow = mod.$insertTableRow;
+export const $insertTableRowAtSelection = mod.$insertTableRowAtSelection;
 export const $insertTableRow__EXPERIMENTAL = mod.$insertTableRow__EXPERIMENTAL;
 export const $isScrollableTablesActive = mod.$isScrollableTablesActive;
 export const $isTableCellNode = mod.$isTableCellNode;
 export const $isTableNode = mod.$isTableNode;
 export const $isTableRowNode = mod.$isTableRowNode;
 export const $isTableSelection = mod.$isTableSelection;
+export const $mergeCells = mod.$mergeCells;
 export const $removeTableRowAtIndex = mod.$removeTableRowAtIndex;
 export const $unmergeCell = mod.$unmergeCell;
 export const INSERT_TABLE_COMMAND = mod.INSERT_TABLE_COMMAND;

package/LexicalTable.node.mjs

@@ -16,7 +16,9 @@ export const $createTableRowNode = mod.$createTableRowNode;
 export const $createTableSelection = mod.$createTableSelection;
 export const $createTableSelectionFrom = mod.$createTableSelectionFrom;
 export const $deleteTableColumn = mod.$deleteTableColumn;
+export const $deleteTableColumnAtSelection = mod.$deleteTableColumnAtSelection;
 export const $deleteTableColumn__EXPERIMENTAL = mod.$deleteTableColumn__EXPERIMENTAL;
+export const $deleteTableRowAtSelection = mod.$deleteTableRowAtSelection;
 export const $deleteTableRow__EXPERIMENTAL = mod.$deleteTableRow__EXPERIMENTAL;
 export const $findCellNode = mod.$findCellNode;
 export const $findTableNode = mod.$findTableNode;
@@ -30,14 +32,17 @@ export const $getTableNodeFromLexicalNodeOrThrow = mod.$getTableNodeFromLexicalN
 export const $getTableRowIndexFromTableCellNode = mod.$getTableRowIndexFromTableCellNode;
 export const $getTableRowNodeFromTableCellNodeOrThrow = mod.$getTableRowNodeFromTableCellNodeOrThrow;
 export const $insertTableColumn = mod.$insertTableColumn;
+export const $insertTableColumnAtSelection = mod.$insertTableColumnAtSelection;
 export const $insertTableColumn__EXPERIMENTAL = mod.$insertTableColumn__EXPERIMENTAL;
 export const $insertTableRow = mod.$insertTableRow;
+export const $insertTableRowAtSelection = mod.$insertTableRowAtSelection;
 export const $insertTableRow__EXPERIMENTAL = mod.$insertTableRow__EXPERIMENTAL;
 export const $isScrollableTablesActive = mod.$isScrollableTablesActive;
 export const $isTableCellNode = mod.$isTableCellNode;
 export const $isTableNode = mod.$isTableNode;
 export const $isTableRowNode = mod.$isTableRowNode;
 export const $isTableSelection = mod.$isTableSelection;
+export const $mergeCells = mod.$mergeCells;
 export const $removeTableRowAtIndex = mod.$removeTableRowAtIndex;
 export const $unmergeCell = mod.$unmergeCell;
 export const INSERT_TABLE_COMMAND = mod.INSERT_TABLE_COMMAND;