@heartlandone/vega 2.78.0 → 2.79.0

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

@@ -0,0 +1,33 @@
+import { getAllTableRows, buildTableGrid, buildCellStartColumnMap } from '../utils/utils';
+import { TableColumnStrategy } from './table-column-strategy.abstract';
+/**
+ * Strategy to handle the selection of a table column.
+ */
+export class SelectTableColumnStrategy extends TableColumnStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, target) {
+    const allTableRows = getAllTableRows(target);
+    const tableGrid = buildTableGrid(allTableRows);
+    const cellStartColMap = buildCellStartColumnMap(tableGrid);
+    const [startCellCol, endCellCol] = this.getBoundaryCellColumnRange(action.tableCellSelectRange, allTableRows, tableGrid);
+    const allNeedSelectedCells = [];
+    const selectedCellIds = new Set();
+    allTableRows.forEach((row) => {
+      row.children.forEach((cell) => {
+        const cellStartCol = cellStartColMap.get(cell.id);
+        if (cellStartCol === undefined) {
+          return;
+        }
+        if (cellStartCol >= startCellCol &&
+          cellStartCol <= endCellCol &&
+          !selectedCellIds.has(cell.id)) {
+          selectedCellIds.add(cell.id);
+          allNeedSelectedCells.push(cell);
+        }
+      });
+    });
+    action.selectCellCallback(allNeedSelectedCells);
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/table/action-handler-strategies/split-cell-horizontally-strategy.js

@@ -0,0 +1,143 @@
+import { RTETableRowBlock } from '../dto/table-row-block';
+import { RTETableBlock } from '../dto/table-block';
+import { InsertChildrenAfterAction } from '../../../dto/actions/insert-children-after-block';
+import { getCellSpan, getAllTableRows, getActualColumnPosition, getParentBlockByType, setSpanAttributes, createNewCell, } from '../utils/utils';
+import { generateUUID } from '../../../../../utils/misc';
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+/**
+ * Strategy to handle horizontal split of a table cell (splits top/bottom).
+ */
+export class SplitCellHorizontallyStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(_action, target) {
+    const row = target.parent;
+    const section = row.parent;
+    const table = getParentBlockByType(row, RTETableBlock);
+    const allRows = getAllTableRows(table);
+    const currentRowIndex = allRows.indexOf(row);
+    const { colSpan, rowSpan } = getCellSpan(target);
+    const cellColumnPosition = getActualColumnPosition(target, allRows);
+    // When rowSpan=1, we need to insert a new row and both cells have rowSpan=1
+    // When rowSpan>1, we split the existing rowSpan
+    const topRowSpan = Math.ceil(rowSpan / 2);
+    const bottomRowSpan = Math.max(1, rowSpan - topRowSpan);
+    const needsNewRow = rowSpan === 1;
+    // Update original cell's rowSpan (top cell)
+    setSpanAttributes(target, colSpan, topRowSpan, table);
+    // Determine where the bottom cell should be inserted
+    const bottomCellRowIndex = currentRowIndex + topRowSpan;
+    // Create the bottom cell with the same col span and type as the original
+    const bottomCell = createNewCell(target.type);
+    setSpanAttributes(bottomCell, colSpan, bottomRowSpan, table);
+    if (needsNewRow) {
+      // Need to create a new row for the bottom cell
+      const newRow = this.createNewRowWithCell(section, bottomCell);
+      // Find the correct position in the section to insert the new row
+      const rowIndexInSection = section.children.indexOf(row);
+      section.apply(new InsertChildrenAfterAction(section.children[rowIndexInSection], newRow));
+      // Update allRows
+      allRows.splice(bottomCellRowIndex, 0, newRow);
+      // Update all cells from all previous rows that span through the insertion point
+      // (except the split cell itself)
+      this.updateCellsSpanningThroughInsertionPoint(allRows, bottomCellRowIndex, target, table);
+    }
+    else {
+      // Row exists - insert the bottom cell at the correct position
+      const targetRow = allRows[bottomCellRowIndex];
+      const insertIndex = this.findInsertPosition(targetRow, cellColumnPosition, allRows, bottomCellRowIndex);
+      targetRow.children.splice(insertIndex, 0, bottomCell);
+      bottomCell.parent = targetRow;
+    }
+  }
+  /**
+   * Find the correct insertion position for a cell at a given column position in a row.
+   * Accounts for cells from previous rows with rowspan extending into the target row.
+   *
+   * @param {RTETableRowBlock} targetRow - The row to insert into.
+   * @param {number} targetColumnPosition - The target column position.
+   * @param {RTETableRowBlock[]} allRows - All rows in the table.
+   * @param {number} rowIndex - The index of the target row.
+   * @returns {number} The physical cell index to insert at.
+   */
+  findInsertPosition(targetRow, targetColumnPosition, allRows, rowIndex) {
+    // Calculate columns occupied by cells from previous rows extending into this row
+    let columnsOccupiedByPreviousRows = 0;
+    for (let r = 0; r < rowIndex; r++) {
+      const prevRow = allRows[r];
+      for (const prevCell of prevRow.children) {
+        const { colSpan, rowSpan } = getCellSpan(prevCell);
+        // Check if this cell extends into the target row
+        if (r + rowSpan > rowIndex) {
+          const prevCellColumnPosition = getActualColumnPosition(prevCell, allRows);
+          if (prevCellColumnPosition < targetColumnPosition) {
+            columnsOccupiedByPreviousRows += colSpan;
+          }
+        }
+      }
+    }
+    // Find the insertion position in the target row
+    let currentColumn = columnsOccupiedByPreviousRows;
+    for (let i = 0; i < targetRow.children.length; i++) {
+      if (currentColumn >= targetColumnPosition) {
+        return i;
+      }
+      const cell = targetRow.children[i];
+      const { colSpan } = getCellSpan(cell);
+      currentColumn += colSpan;
+    }
+    return targetRow.children.length;
+  }
+  /**
+   * Create a new row with only the bottom cell.
+   * Other columns will be covered by cells from the original row with increased rowSpan.
+   *
+   * @param {RTETableBodyBlock | RTETableHeadBlock} section - The section (thead or tbody).
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} bottomCell - The bottom cell to insert.
+   * @returns {RTETableRowBlock} The newly created row.
+   */
+  createNewRowWithCell(section, bottomCell) {
+    const rowTemplate = {
+      id: generateUUID(),
+      type: 'table-row',
+      children: [],
+    };
+    const newRow = RTETableRowBlock.from(rowTemplate);
+    newRow.parent = section;
+    // Add the bottom cell to the row
+    newRow.children.push(bottomCell);
+    bottomCell.parent = newRow;
+    return newRow;
+  }
+  /**
+   * Update all cells from all previous rows that span through the newly inserted row.
+   * When a new row is inserted at `insertionRowIndex`, any cell from a previous row
+   * that has rowSpan extending to or beyond that position needs rowSpan increased by 1.
+   *
+   * @param {RTETableRowBlock[]} allRows - All rows in the table (after insertion).
+   * @param {number} insertionRowIndex - The index where the new row was inserted.
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} splitCell - The cell that was split (skip this one).
+   * @param {RTETableBlock} table - The table block.
+   */
+  updateCellsSpanningThroughInsertionPoint(allRows, insertionRowIndex, splitCell, table) {
+    // Check all rows before the insertion point (not including the inserted row itself)
+    for (let r = 0; r < insertionRowIndex; r++) {
+      const row = allRows[r];
+      for (const cell of row.children) {
+        // Skip the cell that was split - it already has the correct rowSpan
+        if (cell === splitCell) {
+          continue;
+        }
+        const { colSpan, rowSpan } = getCellSpan(cell);
+        // Calculate where this cell ends
+        const cellRowEnd = r + rowSpan;
+        // If this cell extends to or past where we inserted the row,
+        // it needs to span over the new row too
+        if (cellRowEnd >= insertionRowIndex) {
+          setSpanAttributes(cell, colSpan, rowSpan + 1, table);
+        }
+      }
+    }
+  }
+}

package/dist/collection/components/vega-rich-text-editor/extensions/table/action-handler-strategies/split-cell-vertically-strategy.js

@@ -0,0 +1,80 @@
+import { RTETableBlock } from '../dto/table-block';
+import { InsertChildrenAfterAction } from '../../../dto/actions/insert-children-after-block';
+import { getCellSpan, getParentBlockByType, setSpanAttributes, getAllTableRows, getActualColumnPosition, createNewCell, } from '../utils/utils';
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+/**
+ * Strategy to handle vertical split of a table cell (splits left/right).
+ */
+export class SplitCellVerticallyStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(_action, target) {
+    const row = target.parent;
+    const table = getParentBlockByType(row, RTETableBlock);
+    const allRows = getAllTableRows(table);
+    const currentRowIndex = allRows.indexOf(row);
+    const { colSpan, rowSpan } = getCellSpan(target);
+    // Get the actual column position of the cell being split
+    const cellColumnStart = getActualColumnPosition(target, allRows);
+    const cellColumnEnd = cellColumnStart + colSpan - 1;
+    // Calculate new column spans (split the column span)
+    const leftColSpan = Math.ceil(colSpan / 2);
+    const rightColSpan = Math.floor(colSpan / 2);
+    // Update original cell's column spans (left cell)
+    setSpanAttributes(target, leftColSpan, rowSpan, table);
+    // Create new cell (right cell) with same type as original
+    const newCell = createNewCell(target.type);
+    setSpanAttributes(newCell, rightColSpan, rowSpan, table);
+    // Insert new cell after the original in the same row
+    row.apply(new InsertChildrenAfterAction(target, newCell));
+    // Only when splitting a cell with colSpan=1 do we add a new column to the table.
+    // When colSpan>1, we're just redistributing existing columns.
+    // For example:
+    //   colSpan=1: split into 1+1 → adds 1 new column
+    //   colSpan=2: split into 1+1 → just redistributes 2 existing columns
+    //   colSpan=3: split into 2+1 → just redistributes 3 existing columns
+    const newColumnsAdded = colSpan === 1 ? 1 : 0;
+    if (newColumnsAdded > 0) {
+      this.updateOtherRowsCells(allRows, currentRowIndex, cellColumnStart, cellColumnEnd, rowSpan, newColumnsAdded, table);
+    }
+  }
+  /**
+   * Update cells in other rows to account for the new columns added by the split.
+   * When a cell is split vertically and new columns are added to the table,
+   * cells in other rows that span across the position where the split happened
+   * need their colSpan increased.
+   *
+   * @param {RTETableRowBlock[]} allRows - All rows in the table.
+   * @param {number} splitRowIndex - The index of the row containing the split cell.
+   * @param {number} splitColumnStart - The starting column position of the split cell.
+   * @param {number} splitColumnEnd - The ending column position of the split cell.
+   * @param {number} splitCellRowSpan - The rowSpan of the split cell.
+   * @param {number} newColumnsAdded - The number of new columns added by the split.
+   * @param {RTETableBlock} table - The table block.
+   */
+  updateOtherRowsCells(allRows, splitRowIndex, splitColumnStart, splitColumnEnd, splitCellRowSpan, newColumnsAdded, table) {
+    // Iterate through all rows
+    for (let rowIndex = 0; rowIndex < allRows.length; rowIndex++) {
+      const currentRow = allRows[rowIndex];
+      // Skip rows that are spanned by the split cell itself
+      if (rowIndex >= splitRowIndex && rowIndex < splitRowIndex + splitCellRowSpan) {
+        continue;
+      }
+      // Check each cell in the current row
+      for (const cell of currentRow.children) {
+        const cellColumnStart = getActualColumnPosition(cell, allRows);
+        const { colSpan, rowSpan } = getCellSpan(cell);
+        const cellColumnEnd = cellColumnStart + colSpan - 1;
+        // Check if this cell spans across the columns where the split happened
+        // A cell needs updating if its column range overlaps with the split cell's column range
+        const overlaps = cellColumnEnd >= splitColumnStart && cellColumnStart <= splitColumnEnd;
+        if (overlaps) {
+          // Increase this cell's colSpan by the number of new columns added
+          setSpanAttributes(cell, colSpan + newColumnsAdded, rowSpan, table);
+          break; // No need to check other cells in this row
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,45 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { RemoveChildrenAction } from '../../../dto/actions/remove-child-action';
+import { CreateSegmentTableCellAction } from '../actions/create-segment-table-cell-action';
+/**
+ * Strategy to split a partially overlapped table cell.
+ */
+export class SplitTableCellStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, row) {
+    const { table, cell, col, cellStartCol, endCol, targetCellType } = action.payload;
+    const cellEndCol = cellStartCol + cell.colSpan - 1;
+    const leftColSpan = col > cellStartCol ? col - cellStartCol : 0;
+    const overlapEndCol = Math.min(endCol, cellEndCol);
+    const middleColSpan = overlapEndCol - col + 1;
+    const rightColSpan = cellEndCol - overlapEndCol;
+    if (leftColSpan > 0) {
+      row.apply(new CreateSegmentTableCellAction({
+        table,
+        sourceCell: cell,
+        colSpan: leftColSpan,
+        cellType: cell.type,
+        keepSourceContent: true,
+      }));
+    }
+    row.apply(new CreateSegmentTableCellAction({
+      table,
+      sourceCell: cell,
+      colSpan: middleColSpan,
+      cellType: targetCellType,
+      keepSourceContent: leftColSpan === 0,
+    }));
+    if (rightColSpan > 0) {
+      row.apply(new CreateSegmentTableCellAction({
+        table,
+        sourceCell: cell,
+        colSpan: rightColSpan,
+        cellType: cell.type,
+        keepSourceContent: leftColSpan === 0 && middleColSpan === cell.colSpan,
+      }));
+    }
+    row.apply(new RemoveChildrenAction(cell));
+  }
+}

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

@@ -0,0 +1,27 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { getActualColumnPosition } from '../utils/utils';
+/**
+ * Abstract base strategy for handling table column operations.
+ * Provides common functionality for all column-related strategies.
+ */
+export class TableColumnStrategy extends ActionHandleStrategy {
+  /**
+   * Finds the index range of cells within a table row.
+   * Returns the start and end indices of the given cell range.
+   *
+   * @param {(RTETableCellBlock | RTETableHeadCellBlock)[]} cellRange - The range of table cells to find indices for.
+   * @param {RTETableRowBlock[]} allTableRows - All table rows.
+   * @param {string[][]} grid - The 2D grid representation of the table
+   * @returns {[number, number]} A tuple containing the start and end indices.
+   */
+  getBoundaryCellColumnRange(cellRange, allTableRows, grid) {
+    let minCol = Number.POSITIVE_INFINITY;
+    let maxCol = Number.NEGATIVE_INFINITY;
+    cellRange.forEach((cell) => {
+      const logicalCol = getActualColumnPosition(cell, allTableRows, grid);
+      minCol = Math.min(minCol, logicalCol);
+      maxCol = Math.max(maxCol, logicalCol);
+    });
+    return [minCol, maxCol];
+  }
+}

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;