@heartlandone/vega 2.77.1 → 2.79.0

package/dist/collection/components/vega-rich-text-editor/extensions/table/action-handler-strategies/table-row-strategy.abstract.js

@@ -0,0 +1,296 @@
+import { generateUUID } from '../../../../../utils/misc';
+import { cleanObject } from '../../../../../utils/object';
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { AppendChildrenAction } from '../../../dto/actions/append-child-nodes-action';
+import { InsertChildrenAfterAction } from '../../../dto/actions/insert-children-after-block';
+import { InsertChildrenBeforeAction } from '../../../dto/actions/insert-children-before-block';
+import { CommonAnnotationTypeEnum } from '../../../dto/annotations/common-annotation.abstract';
+import { CustomAttributeAnnotation } from '../../../dto/annotations/custom-attribute-annotation';
+import { RTETableHeadBlock } from '../dto/table-head-block';
+import { RTETableHeadCellBlock } from '../dto/table-head-cell-block';
+/**
+ * Abstract base strategy for table row actions. Provides common utilities for row manipulations.
+ */
+export class TableRowCommonUtilitiesStrategy extends ActionHandleStrategy {
+  /**
+   * Calculates the maximum number of cells in any row, accounting for colSpan.
+   *
+   * @param {RTETableRowBlock[]} rows - The rows to analyze.
+   * @returns {number} The maximum cell count across the rows.
+   */
+  getRowsMaxCellCount(rows) {
+    let maxCells = 0;
+    for (const row of rows) {
+      let rowCols = 0;
+      for (const cell of row.children) {
+        rowCols += cell.colSpan;
+      }
+      maxCells = Math.max(maxCells, rowCols);
+    }
+    return maxCells;
+  }
+  /**
+   * Compute logical start columns for each row's cells, accounting for colSpan and rowSpan.
+   *
+   * @param {RTETableRowBlock[]} rows - Table rows in a section.
+   * @returns {number[][]} Array of row cell start columns by cell index.
+   */
+  getRowCellStartCols(rows) {
+    // Calculate max columns efficiently
+    const maxCols = this.getRowsMaxCellCount(rows);
+    const rowStartCols = new Array(rows.length);
+    // Track occupied columns due to rowSpan
+    const spanCarryOver = new Array(maxCols).fill(0);
+    for (let rowIndex = 0; rowIndex < rows.length; rowIndex++) {
+      const row = rows[rowIndex];
+      const cells = row.children;
+      const startCols = new Array(cells.length);
+      let currentCol = 0;
+      for (let cellIndex = 0; cellIndex < cells.length; cellIndex++) {
+        const cell = cells[cellIndex];
+        // Skip columns occupied by previous row's rowspan
+        while (currentCol < spanCarryOver.length && spanCarryOver[currentCol] > 0) {
+          currentCol++;
+        }
+        startCols[cellIndex] = currentCol;
+        const colSpan = Math.max(cell.colSpan, TableRowCommonUtilitiesStrategy.DEFAULT_CELLSPAN);
+        // Mark columns as occupied if cell has rowspan > 1
+        if (cell.rowSpan > TableRowCommonUtilitiesStrategy.DEFAULT_CELLSPAN) {
+          for (let i = 0; i < colSpan; i++) {
+            const col = currentCol + i;
+            if (col < spanCarryOver.length) {
+              spanCarryOver[col] = Math.max(spanCarryOver[col], cell.rowSpan);
+            }
+          }
+        }
+        currentCol += colSpan;
+      }
+      rowStartCols[rowIndex] = startCols;
+      // Decrement all carryOver values at the end of each row
+      // This represents "one row has been consumed"
+      for (let i = 0; i < spanCarryOver.length; i++) {
+        if (spanCarryOver[i] > 0)
+          spanCarryOver[i]--;
+      }
+    }
+    return rowStartCols;
+  }
+  /**
+   * Updates the rowspan/colspan attribute of a table cell.
+   *
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} cell - The cell to update.
+   * @param {'rowspan' | 'colspan'} spanKey - The attribute key to update.
+   * @param {number} newSpan - The new rowspan/colspan value.
+   */
+  updateCellSpan(cell, spanKey, newSpan) {
+    const customAttrAnnotation = cell.getCustomAttributesAnnotation();
+    // Only set rowspan/colspan if > 1, otherwise remove the attribute
+    if (newSpan <= TableRowCommonUtilitiesStrategy.DEFAULT_CELLSPAN) {
+      if (customAttrAnnotation) {
+        const currentAttrs = customAttrAnnotation.render();
+        delete currentAttrs[spanKey];
+        cell.annotationMap.set(CommonAnnotationTypeEnum.CUSTOM_ATTRIBUTE, new CustomAttributeAnnotation(currentAttrs));
+      }
+    }
+    else {
+      const attrs = customAttrAnnotation ? customAttrAnnotation.render() : {};
+      attrs[spanKey] = newSpan.toString();
+      cell.annotationMap.set(CommonAnnotationTypeEnum.CUSTOM_ATTRIBUTE, new CustomAttributeAnnotation(attrs));
+    }
+  }
+  /**
+   * Insert moved cells into target rows using logical column positions.
+   *
+   * @param {Map<number, CellToMove[]>} cellsToMove - Cells grouped by target row.
+   * @param {RTETableRowBlock[]} allRows - All rows in the section.
+   * @param {number[][]} rowCellStartCols - Logical start columns per row.
+   */
+  insertMovedCells(cellsToMove, allRows, rowCellStartCols) {
+    cellsToMove.forEach((cells, targetRowIndex) => {
+      const targetRow = allRows[targetRowIndex];
+      if (targetRow) {
+        const targetRowStartCols = rowCellStartCols[targetRowIndex] || [];
+        // sort cells in descending order of logical start column to avoid index shifting issues during insertion
+        cells.sort((a, b) => {
+          if (a.logicalStartCol === b.logicalStartCol) {
+            return b.cellIndex - a.cellIndex;
+          }
+          return b.logicalStartCol - a.logicalStartCol;
+        });
+        cells.forEach((cellInfo) => {
+          const { cell, logicalStartCol } = cellInfo;
+          if (targetRow.children.length === 0) {
+            targetRow.apply(new AppendChildrenAction([cell]));
+            targetRowStartCols[0] = logicalStartCol;
+            return;
+          }
+          const insertIndex = targetRowStartCols.findIndex((startCol) => startCol >= logicalStartCol);
+          if (insertIndex === -1) {
+            const lastCell = targetRow.children[targetRow.children.length - 1];
+            targetRow.apply(new InsertChildrenAfterAction(lastCell, cell));
+            targetRowStartCols.push(logicalStartCol);
+          }
+          else if (insertIndex === 0) {
+            targetRow.apply(new InsertChildrenBeforeAction(targetRow.children[0], cell));
+            targetRowStartCols.unshift(logicalStartCol);
+          }
+          else {
+            targetRow.apply(new InsertChildrenBeforeAction(targetRow.children[insertIndex], cell));
+            targetRowStartCols.splice(insertIndex, 0, logicalStartCol);
+          }
+        });
+      }
+    });
+  }
+  /**
+   * Splits the selected rows into head rows and body rows.
+   *
+   * @param {RTETableRowBlock[]} rows - The rows to be split.
+   * @returns {RTETableRowBlock[][]} - An array containing two arrays: the first with head rows and the second with body rows.
+   */
+  splitRowsBySection(rows) {
+    const headRows = [];
+    const bodyRows = [];
+    rows.forEach((row) => {
+      if (row.parent instanceof RTETableHeadBlock) {
+        headRows.push(row);
+      }
+      else {
+        bodyRows.push(row);
+      }
+    });
+    return [headRows, bodyRows];
+  }
+  /**
+   * Build indices for selected rows within the section.
+   *
+   * @param {RTETableRowBlock[]} selectedRows - Selected rows.
+   * @param {RTETableRowBlock[]} allRows - All rows in the section.
+   * @returns {Set<number>} The set of selected row indices.
+   */
+  buildSelectedIndices(selectedRows, allRows) {
+    return new Set(selectedRows
+      .map((row) => allRows.indexOf(row))
+      .filter((index) => index >= 0));
+  }
+  /**
+   * Determine whether a cell's row span intersects the removal range.
+   *
+   * @param {number} cellStartIndex - Cell start row index.
+   * @param {number} cellEndIndex - Cell end row index.
+   * @param {number} firstRemovalIndex - First row index to remove.
+   * @param {number} lastRemovalIndex - Last row index to remove.
+   * @returns {boolean} True if the ranges intersect.
+   */
+  intersectsRemovalRange(cellStartIndex, cellEndIndex, firstRemovalIndex, lastRemovalIndex) {
+    return cellStartIndex <= lastRemovalIndex && cellEndIndex >= firstRemovalIndex;
+  }
+  /**
+   * Count how many rows in the cell span are being removed.
+   *
+   * @param {number} cellStartIndex - Cell start row index.
+   * @param {number} cellEndIndex - Cell end row index.
+   * @param {Set<number>} removalIndices - Indices of rows to remove.
+   * @returns {number} Count of removed rows in the span.
+   */
+  countRemovedRows(cellStartIndex, cellEndIndex, removalIndices) {
+    let removedRowsCount = 0;
+    for (let i = cellStartIndex; i <= cellEndIndex; i++) {
+      if (removalIndices.has(i)) {
+        removedRowsCount++;
+      }
+    }
+    return removedRowsCount;
+  }
+  /**
+   * Get the column head end index in a table row.
+   *
+   * @param {RTETableRowBlock} tableRow - The table row block.
+   * @returns {number} The end index of the column head.
+   */
+  getHeadCellLength(tableRow) {
+    let length = 0;
+    for (let i = 0; i < tableRow.children.length; i++) {
+      const cellBlock = tableRow.children[i];
+      if (cellBlock instanceof RTETableHeadCellBlock) {
+        length += cellBlock.colSpan;
+      }
+      else {
+        break;
+      }
+    }
+    return length;
+  }
+  /**
+   * Gets the starting cell for a given cell index by checking row spans.
+   *
+   * @param {RTETableRowBlock[]} allRows - All rows in the section to check for row spans.
+   * @param {number[][]} rowsStartCols - Pre-calculated starting column indices for each cell in each row.
+   * @param {number} rowIndex - The index of the row to start checking from.
+   * @param {number} cellIndex - The logical cell index to find the starting cell for.
+   * @returns {LogicalStartSpanCell} - The starting cell and its row index if found, otherwise the cell is undefined.
+   */
+  getTheStartSpanCell(allRows, rowsStartCols, rowIndex, cellIndex) {
+    const result = { rowIndex };
+    for (let i = rowIndex; i >= 0; i--) {
+      const cellStartCols = rowsStartCols[i];
+      if (cellStartCols.includes(cellIndex)) {
+        result.cell = allRows[i].children[cellStartCols.indexOf(cellIndex)];
+        result.rowIndex = i;
+        break;
+      }
+    }
+    return result;
+  }
+  /**
+   * Get the default cell block template.
+   *
+   * @param {string} cellType - The type of the cell block.
+   * @param {number} colSpan - The colspan attribute for the cell.
+   * @param {number} rowSpan - The rowspan attribute for the cell.
+   * @returns {VegaRTETableCellBlock | VegaRTETableHeadCellBlock} The default cell block template.
+   */
+  getDefaultCellBlockTemplate(cellType, colSpan, rowSpan = 1) {
+    const customAttribute = cleanObject({
+      colspan: colSpan > 1 ? colSpan.toString() : null,
+      rowspan: rowSpan > 1 ? rowSpan.toString() : null,
+    });
+    const id = generateUUID();
+    const cellBlock = {
+      id,
+      type: cellType,
+      children: [
+        {
+          id: `${id}-p`,
+          type: 'paragraph',
+          nodes: [
+            {
+              id: `${id}-p-t`,
+              type: 'text',
+              text: '',
+            },
+          ],
+        },
+      ],
+    };
+    if (Object.keys(customAttribute).length > 0) {
+      cellBlock.annotations = {
+        customAttribute,
+      };
+    }
+    return cellBlock;
+  }
+  /**
+   * Convert a numeric-keyed map to an array sorted by ascending key.
+   *
+   * @typedef T - The type of the values in the map.
+   * @param {Map<number, T>} valueMap - The map with numeric keys to convert.
+   * @returns {T[]} An array of values sorted by their numeric keys.
+   */
+  getSortedValuesByNumericKey(valueMap) {
+    return Array.from(valueMap.entries())
+      .sort(([aKey], [bKey]) => aKey - bKey)
+      .map(([, value]) => value);
+  }
+}
+TableRowCommonUtilitiesStrategy.DEFAULT_CELLSPAN = 1;

package/dist/collection/components/vega-rich-text-editor/extensions/table/action-handler-strategies/toggle-header-row-strategy.js

@@ -0,0 +1,274 @@
+import { generateUUID } from '../../../../../utils/misc';
+import { rgbToHex } from '../../../../../utils/ui';
+import { AppendChildrenAction } from '../../../dto/actions/append-child-nodes-action';
+import { InsertChildrenAfterAction } from '../../../dto/actions/insert-children-after-block';
+import { InsertChildrenBeforeAction } from '../../../dto/actions/insert-children-before-block';
+import { RemoveChildrenAction } from '../../../dto/actions/remove-child-action';
+import { UpdateCursorPositionAction } from '../../../dto/actions/update-cursor-position-action';
+import { RTETableHeadCellAnnotation } from '../annotations/table-head-cell-annotation';
+import { RTETableBodyBlock } from '../dto/table-body-block';
+import { RTETableCellBlock } from '../dto/table-cell-block';
+import { RTETableHeadBlock } from '../dto/table-head-block';
+import { RTETableHeadCellBlock } from '../dto/table-head-cell-block';
+import { TableRowCommonUtilitiesStrategy } from './table-row-strategy.abstract';
+/**
+ * Strategy class for handling converting selected rows to header rows or reverting them back to normal rows.
+ */
+export class ToggleHeaderRowStrategy extends TableRowCommonUtilitiesStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    const { selectedRows } = action;
+    const [headerRows, bodyRows] = this.splitRowsBySection(selectedRows);
+    if (bodyRows.length > 0) {
+      this.convertToHeaderRows(bodyRows, target);
+    }
+    else {
+      this.revertToBodyRows(headerRows, target);
+    }
+    const root = this.getRootContent(target);
+    if (root) {
+      const focusNode = selectedRows[0].getFirstNode();
+      focusNode && root.apply(new UpdateCursorPositionAction(focusNode, 0));
+    }
+  }
+  /**
+   * Converts normal rows to header rows.
+   *
+   * @param {RTETableRowBlock[]} rows - The table row blocks to convert.
+   * @param {RTETableBlock} table - The table block containing the rows.
+   */
+  convertToHeaderRows(rows, table) {
+    let tableHead = table.children.find((block) => block instanceof RTETableHeadBlock);
+    const tableBody = rows[0].parent;
+    if (!tableHead) {
+      tableHead = RTETableHeadBlock.from({
+        id: generateUUID(),
+        type: 'table-head',
+        children: [],
+      });
+      table.apply(new InsertChildrenBeforeAction(tableBody, tableHead));
+    }
+    const endIndex = tableBody.children.indexOf(rows[rows.length - 1]);
+    const shouldConvertRows = tableBody.children.slice(0, endIndex + 1);
+    const rowsToBeConvertedIndices = this.buildSelectedIndices(shouldConvertRows, tableBody.children);
+    const firstSelectedIndex = Math.min(...rowsToBeConvertedIndices);
+    const lastSelectedIndex = Math.max(...rowsToBeConvertedIndices);
+    if (rowsToBeConvertedIndices.size > 0) {
+      if (rowsToBeConvertedIndices.size < tableBody.children.length) {
+        const rowCellStartCols = this.getRowCellStartCols(tableBody.children);
+        const cellsToMove = this.collectCellsToMove(tableBody.children, rowCellStartCols, rowsToBeConvertedIndices, firstSelectedIndex, lastSelectedIndex);
+        this.insertMovedCells(cellsToMove, tableBody.children, rowCellStartCols);
+      }
+      this.convertBodyRowsToHeaderRows(tableBody, tableHead, shouldConvertRows);
+    }
+  }
+  /**
+   * Converts body rows to header rows.
+   *
+   * @param {RTETableBodyBlock} tableBody - The table body block containing the rows to be converted.
+   * @param {RTETableHeadBlock} tableHead - The table head block to which the rows will be moved.
+   * @param {RTETableRowBlock[]} shouldConvertRows - The rows to be converted.
+   */
+  convertBodyRowsToHeaderRows(tableBody, tableHead, shouldConvertRows) {
+    for (let i = 0; i < shouldConvertRows.length; i++) {
+      const rowBlock = shouldConvertRows[i];
+      rowBlock.children = rowBlock.children.map((cell) => this.convertTdToTh(cell));
+      tableBody.apply(new RemoveChildrenAction(rowBlock));
+    }
+    tableHead.apply(new AppendChildrenAction(shouldConvertRows));
+  }
+  /**
+   * Converts header rows back to normal rows.
+   *
+   * @param {RTETableRowBlock[]} rows - The table row blocks to convert.
+   * @param {RTETableBlock} table - The table block containing the rows.
+   */
+  revertToBodyRows(rows, table) {
+    let tableBody = table.children.find((block) => block instanceof RTETableBodyBlock);
+    const tableHead = rows[0].parent;
+    if (!tableBody) {
+      tableBody = RTETableBodyBlock.from({
+        id: generateUUID(),
+        type: 'table-body',
+        children: [],
+      });
+      table.apply(new InsertChildrenAfterAction(tableHead, tableBody));
+    }
+    const startIndex = tableHead.children.indexOf(rows[0]);
+    const shouldConvertRows = tableHead.children.slice(startIndex);
+    const rowsToBeConvertedIndices = this.buildSelectedIndices(shouldConvertRows, tableHead.children);
+    if (rowsToBeConvertedIndices.size > 0) {
+      const rowCellStartCols = this.getRowCellStartCols(tableHead.children);
+      const cellsToMove = this.collectCellsToMove(tableHead.children, rowCellStartCols, rowsToBeConvertedIndices, Math.min(...rowsToBeConvertedIndices), Math.max(...rowsToBeConvertedIndices));
+      this.insertMovedCells(cellsToMove, tableHead.children, rowCellStartCols);
+      this.convertHeadRowsToBodyRows(tableHead, tableBody, shouldConvertRows);
+    }
+  }
+  /**
+   * Convert header rows to body rows.
+   *
+   * @param {RTETableHeadBlock} tableHead - The table head block containing the rows to be converted.
+   * @param {RTETableBodyBlock} tableBody - The table body block to which the rows will be moved.
+   * @param {RTETableRowBlock[]} shouldConvertRows - The rows to be converted.
+   */
+  convertHeadRowsToBodyRows(tableHead, tableBody, shouldConvertRows) {
+    const firstBodyRow = tableBody.children[0];
+    const rowCellStartCols = this.getRowCellStartCols(shouldConvertRows);
+    for (let i = 0; i < shouldConvertRows.length; i++) {
+      const rowBlock = shouldConvertRows[i];
+      tableHead.apply(new RemoveChildrenAction(rowBlock));
+      const headCellLength = firstBodyRow ? this.getHeadCellLength(firstBodyRow) : 0;
+      rowBlock.children = this.convertThToTd(rowBlock, rowCellStartCols[i], headCellLength);
+      if (firstBodyRow) {
+        tableBody.apply(new InsertChildrenBeforeAction(firstBodyRow, rowBlock));
+      }
+    }
+    if (!firstBodyRow) {
+      tableBody.apply(new AppendChildrenAction(shouldConvertRows));
+    }
+  }
+  /**
+   * Collect cells that need to be moved to the next remaining row.
+   *
+   * @param {RTETableRowBlock[]} allRows - All rows in the section.
+   * @param {number[][]} rowCellStartCols - Logical start columns per row.
+   * @param {Set<number>} selectedIndices - Indices of selected rows.
+   * @param {number} firstSelectedIndex - First selected row index.
+   * @param {number} lastSelectedIndex - Last selected row index.
+   * @returns {Map<number, CellToMove[]>} Map of target row index to cells to move.
+   */
+  collectCellsToMove(allRows, rowCellStartCols, selectedIndices, firstSelectedIndex, lastSelectedIndex) {
+    const cellsToMove = new Map();
+    const rowCount = allRows.length;
+    for (let rowIndex = 0; rowIndex < rowCount; rowIndex++) {
+      const row = allRows[rowIndex];
+      const cellCount = row.children.length;
+      for (let cellIndex = 0; cellIndex < cellCount; cellIndex++) {
+        const cell = row.children[cellIndex];
+        const cellRowSpan = cell.rowSpan;
+        // Skip cells without rowspan
+        if (cellRowSpan <= TableRowCommonUtilitiesStrategy.DEFAULT_CELLSPAN)
+          continue;
+        const cellEndIndex = rowIndex + cellRowSpan - 1;
+        // If the cell's row span does not intersect with the removal range, skip it
+        if (!this.intersectsRemovalRange(rowIndex, cellEndIndex, firstSelectedIndex, lastSelectedIndex)) {
+          continue;
+        }
+        const selectedRowsCount = this.countRemovedRows(rowIndex, cellEndIndex, selectedIndices);
+        const newRowSpan = cellRowSpan - selectedRowsCount;
+        // Scenario 1: Cell starts before selected range and spans into it, head row convert to body row
+        if (rowIndex < firstSelectedIndex && cellEndIndex >= firstSelectedIndex) {
+          this.updateCellSpan(cell, 'rowspan', newRowSpan);
+          const targetRowIndex = firstSelectedIndex;
+          if (targetRowIndex < rowCount && selectedIndices.has(targetRowIndex)) {
+            const logicalStartCol = rowCellStartCols[rowIndex][cellIndex];
+            if (!cellsToMove.has(targetRowIndex)) {
+              cellsToMove.set(targetRowIndex, []);
+            }
+            cellsToMove.get(targetRowIndex).push({
+              cell: this.cloneCellWithRowSpan(cell, selectedRowsCount),
+              newRowSpan: selectedRowsCount,
+              cellIndex,
+              logicalStartCol,
+            });
+          }
+          continue;
+        }
+        // Scenario 2: Cell starts in selected row and spans beyond, we need to move it to the next remaining row and update rowspan. body row convert to head row.
+        if (rowIndex >= firstSelectedIndex && cellEndIndex > lastSelectedIndex) {
+          this.updateCellSpan(cell, 'rowspan', selectedRowsCount);
+          const targetRowIndex = lastSelectedIndex + 1;
+          if (targetRowIndex < rowCount && !selectedIndices.has(targetRowIndex)) {
+            const logicalStartCol = rowCellStartCols[rowIndex][cellIndex];
+            if (!cellsToMove.has(targetRowIndex)) {
+              cellsToMove.set(targetRowIndex, []);
+            }
+            cellsToMove.get(targetRowIndex).push({
+              cell: this.cloneCellWithRowSpan(cell, newRowSpan),
+              newRowSpan,
+              cellIndex,
+              logicalStartCol,
+            });
+          }
+        }
+      }
+    }
+    return cellsToMove;
+  }
+  /**
+   * Converts a table data cell to a table header cell.
+   *
+   * @param {RTETableHeadCellBlock} cell - The table cell block to convert.
+   * @returns {RTETableHeadCellBlock} The converted table header cell block.
+   */
+  convertTdToTh(cell) {
+    if (cell instanceof RTETableHeadCellBlock) {
+      return cell;
+    }
+    const headCell = RTETableHeadCellBlock.from(cell.toJSON());
+    headCell.parent = cell.parent;
+    return headCell;
+  }
+  /**
+   * Converts table header cells to table body cells.
+   * Need to check each cell's logical column index to determine whether it should be converted or not.
+   *
+   * @param {RTETableRowBlock} row - The table row block containing the cells.
+   * @param {number[]} rowCellStartCol - The starting column indices for each cell in the row.
+   * @param {number} headCellLength - The number of header cells in the reference row.
+   * @returns {RTETableCellBlock[]} The converted table body cell blocks.
+   */
+  convertThToTd(row, rowCellStartCol, headCellLength) {
+    return row.children.map((cell, index) => {
+      let bodyCell = cell;
+      const isHeadCell = rowCellStartCol[index] < headCellLength ? true : false;
+      const cellJSON = cell.toJSON();
+      bodyCell = isHeadCell
+        ? cell
+        : RTETableCellBlock.from(this.deleteHeadCellDefaultBackground(cellJSON));
+      bodyCell.parent = row;
+      return bodyCell;
+    });
+  }
+  /**
+   * Clones a table cell with a new rowspan value, used when moving cells during row conversion.
+   * For example, when converting body rows contains a cell with rowspan, we need to clone a new empty cell with same colspan and insert it into the remaining row, and update the original cell's rowspan to make sure the table structure is correct after conversion.
+   *
+   * @param {RTETableCellBlock} cell - The cell to clone.
+   * @param {number} newRowSpan - The new rowspan value for the cloned cell.
+   * @returns {RTETableCellBlock} The cloned cell with updated rowspan.
+   */
+  cloneCellWithRowSpan(cell, newRowSpan) {
+    // Clone the cell (parent will be updated when inserted)
+    const clonedCell = cell.clone(cell.parent);
+    clonedCell.id = generateUUID();
+    clonedCell.children = []; // Clear children to make it an empty cell
+    const paragraph = this.createNewParagraph('');
+    paragraph && clonedCell.apply(new AppendChildrenAction([paragraph]));
+    // Update the rowspan of the cloned cell
+    this.updateCellSpan(clonedCell, 'rowspan', newRowSpan);
+    return clonedCell;
+  }
+  /**
+   * Delete the default background color annotation from a header cell when converting it to a body cell.
+   *
+   * @param {VegaRTETableHeadCellBlock} cell - The table head cell block to process.
+   * @returns {VegaRTETableCellBlock} The processed table cell block with default background color annotation removed if applicable.
+   */
+  deleteHeadCellDefaultBackground(cell) {
+    var _a;
+    if (cell && cell.annotations && cell.annotations.customStyle) {
+      delete cell.annotations.tableCell;
+      const backgroundColor = cell.annotations.customStyle.backgroundColor;
+      const defaultBackgroundColor = RTETableHeadCellAnnotation.getDefaultBackgroundColor();
+      if (backgroundColor &&
+        (backgroundColor === defaultBackgroundColor ||
+          ((_a = rgbToHex(backgroundColor)) === null || _a === void 0 ? void 0 : _a.toUpperCase()) === defaultBackgroundColor)) {
+        delete cell.annotations.customStyle.backgroundColor;
+      }
+    }
+    return cell;
+  }
+}