@heartlandone/vega 2.77.1 → 2.79.0

package/dist/collection/components/vega-rich-text-editor/extensions/table/action-handler-strategies/insert-table-row-into-same-section-strategy.js

@@ -0,0 +1,55 @@
+import { generateUUID } from '../../../../../utils/misc';
+import { InsertChildrenAfterAction } from '../../../dto/actions/insert-children-after-block';
+import { InsertChildrenBeforeAction } from '../../../dto/actions/insert-children-before-block';
+import { InsertTableRowDirection, } from '../actions/insert-table-row-into-same-section-action';
+import { RTETableRowBlock } from '../dto/table-row-block';
+import { TableRowCommonUtilitiesStrategy } from './table-row-strategy.abstract';
+/**
+ * Strategy class for handling the insertion of a new row into a table.
+ * The new row will be inserted in the same section (header or body) as the reference row based on the insert direction and the position of the selected rows.
+ */
+export class InsertTableRowIntoSameSectionStrategy extends TableRowCommonUtilitiesStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action) {
+    const { insertDirection, selectedRows } = action;
+    // The reference block will control where to insert the new row
+    const refBlock = insertDirection === InsertTableRowDirection.ABOVE
+      ? selectedRows[0]
+      : selectedRows[selectedRows.length - 1];
+    const rowBlockJSON = {
+      id: generateUUID(),
+      type: 'table-row',
+      children: [],
+    };
+    const allRows = refBlock.parent.children;
+    const rowCellMaxCount = this.getRowsMaxCellCount(allRows);
+    const currentRowIndex = allRows.indexOf(refBlock);
+    const rowStartCols = this.getRowCellStartCols(allRows);
+    const rowCellMap = new Map();
+    for (let i = 0; i < rowCellMaxCount; i++) {
+      const { cell, rowIndex } = this.getTheStartSpanCell(allRows, rowStartCols, currentRowIndex, i);
+      if (cell) {
+        const { colSpan, rowSpan } = cell;
+        const shouldIncreaseRowSpan = insertDirection === InsertTableRowDirection.ABOVE
+          ? rowIndex !== currentRowIndex
+          : rowIndex + rowSpan > currentRowIndex + 1;
+        // If the new row is inserted in the middle of the row span, we need to increase the row span of the cell; otherwise, we can just add a new cell.
+        if (shouldIncreaseRowSpan) {
+          this.updateCellSpan(cell, 'rowspan', rowSpan + 1);
+          i += colSpan - 1;
+          continue;
+        }
+        rowCellMap.set(i, this.getDefaultCellBlockTemplate(cell.type, colSpan));
+        i += colSpan - 1;
+      }
+    }
+    rowBlockJSON.children = this.getSortedValuesByNumericKey(rowCellMap);
+    const newRow = RTETableRowBlock.from(rowBlockJSON);
+    const insertAction = insertDirection === InsertTableRowDirection.ABOVE
+      ? new InsertChildrenBeforeAction(refBlock, newRow)
+      : new InsertChildrenAfterAction(refBlock, newRow);
+    refBlock.parent.apply(insertAction);
+  }
+}

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

@@ -0,0 +1,120 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { RemoveChildrenAction } from '../../../dto/actions/remove-child-action';
+import { getFirstNode, getCellSpan, buildTableGrid, setSpanAttributes } from '../utils/utils';
+import { UpdateCursorPositionAction } from '../../../dto/actions/update-cursor-position-action';
+import { MergeCellsOperationType } from '../setting-event-handlers/merge-cells-operation';
+/**
+ * Strategy to handle the merging of table cells.
+ */
+export class MergeCellsStrategy extends ActionHandleStrategy {
+  /**
+   * Handles the merge cells action.
+   *
+   * @param {MergeCellsAction} action - The action containing merge details.
+   * @param {RTETableBlock} target - The target table block.
+   */
+  handleAction(action, target) {
+    const { targetCell, mergeCells, colSpan, rowSpan, direction } = action;
+    this.mergeContentToTargetCell(targetCell, mergeCells);
+    setSpanAttributes(targetCell, colSpan, rowSpan, target);
+    this.deleteOtherSelectedCells(mergeCells, targetCell);
+    if (direction !== MergeCellsOperationType.MERGE_CELL_LEFT &&
+      direction !== MergeCellsOperationType.MERGE_CELL_RIGHT &&
+      rowSpan > 1) {
+      this.clearRowSpanIfUniformAcrossRow(targetCell, target, rowSpan);
+    }
+    const root = this.getRootContent(target);
+    const nextFocusNode = getFirstNode(targetCell);
+    if (root && nextFocusNode) {
+      root.apply(new UpdateCursorPositionAction(nextFocusNode));
+    }
+  }
+  /**
+   * Merge content from all selected cells to the target cell.
+   *
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} targetCell - The target cell.
+   * @param {RTETableCellBlock[] | RTETableHeadCellBlock[]} selectedCells - All selected cells.
+   */
+  mergeContentToTargetCell(targetCell, selectedCells) {
+    const allChildren = selectedCells.flatMap((cell) => cell.children);
+    const valueCells = allChildren.filter((child) => child.isNotEmpty());
+    const allChildrenBlocks = valueCells.length > 0 ? valueCells : [allChildren[0]];
+    targetCell.children = allChildrenBlocks.map((childBlock) => childBlock.clone(targetCell));
+  }
+  /**
+   * Delete all selected cells except the target cell.
+   *
+   * @param {RTETableCellBlock[] | RTETableHeadCellBlock[]} selectedCells - All selected cells.
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} targetCell - The target cell (should not be deleted).
+   */
+  deleteOtherSelectedCells(selectedCells, targetCell) {
+    selectedCells.forEach((cell) => {
+      if (cell !== targetCell) {
+        const row = cell.parent;
+        row.apply(new RemoveChildrenAction(cell));
+      }
+    });
+  }
+  /**
+   * Remove rowSpan from all cells in the target row when every cell shares the same rowSpan.
+   * This avoids keeping stale row spans after a merge operation that no longer spans rows.
+   *
+   * @param {RTETableCellBlock | RTETableHeadCellBlock} targetCell - The target cell to set attributes on.
+   * @param {RTETableBlock} table - The table block.
+   * @param {number} targetCellRowSpan - The target cell rowSpan.
+   */
+  clearRowSpanIfUniformAcrossRow(targetCell, table, targetCellRowSpan) {
+    const targetRow = targetCell.parent;
+    const allRows = targetRow.parent.children;
+    const grid = buildTableGrid(allRows);
+    const rowIndexes = [];
+    for (let r = 0; r < grid.length; r++) {
+      if (grid[r].includes(targetCell.id)) {
+        rowIndexes.push(r);
+      }
+    }
+    if (rowIndexes.length > 1) {
+      const windowStart = rowIndexes[0];
+      const windowEnd = windowStart + targetCellRowSpan - 1;
+      const uniformIds = new Set();
+      let minRowSpan = Number.POSITIVE_INFINITY;
+      for (let c = 0; c < grid[0].length; c++) {
+        let firstId = grid[windowStart][c];
+        let count = 1;
+        let isRowSpan = false;
+        for (let r = windowStart + 1; r <= windowEnd; r++) {
+          if (grid[r][c] === firstId) {
+            count++;
+            continue;
+          }
+          if (count > 1) {
+            isRowSpan = true;
+            minRowSpan = Math.min(minRowSpan, count);
+            uniformIds.add(firstId);
+          }
+          count = 1;
+          firstId = grid[r][c];
+        }
+        if (count < 2 && !isRowSpan) {
+          uniformIds.clear();
+          break;
+        }
+        if (count > 1) {
+          minRowSpan = Math.min(minRowSpan, count);
+          uniformIds.add(firstId);
+        }
+      }
+      if (uniformIds.size > 0) {
+        allRows.forEach((row) => {
+          row.children.forEach((cell) => {
+            if (uniformIds.has(cell.id)) {
+              const { rowSpan, colSpan } = getCellSpan(cell);
+              const reducedRowSpan = rowSpan - minRowSpan + 1;
+              setSpanAttributes(cell, colSpan, reducedRowSpan, table);
+            }
+          });
+        });
+      }
+    }
+  }
+}

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

@@ -0,0 +1,21 @@
+import { ActionHandleStrategy } from '../../../dto/action-handle-strategies/action-handle-strategy.abstract';
+import { InsertChildrenBeforeAction } from '../../../dto/actions/insert-children-before-block';
+import { RemoveChildrenAction } from '../../../dto/actions/remove-child-action';
+import { RTETableCellBlock } from '../dto/table-cell-block';
+import { RTETableHeadCellBlock } from '../dto/table-head-cell-block';
+/**
+ * Strategy to replace a fully overlapped table cell.
+ */
+export class ReplaceTableCellStrategy extends ActionHandleStrategy {
+  /**
+   * @inheritDoc
+   */
+  handleAction(action, row) {
+    const { cell, targetCellType } = action.payload;
+    const newCell = targetCellType === 'table-head-cell'
+      ? RTETableHeadCellBlock.from(cell.toJSON())
+      : RTETableCellBlock.from(cell.toJSON());
+    row.apply(new InsertChildrenBeforeAction(cell, newCell));
+    row.apply(new RemoveChildrenAction(cell));
+  }
+}

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];
+  }
+}