@hailin-zheng/editor-core 1.0.1 → 1.0.3

package/lib/framework/impl/table/table-util.js

@@ -0,0 +1,678 @@
+import { ElementUtil } from "@/med_editor/framework/element-util";
+import { ParagraphElement } from "../paragraph/p-impl";
+import { TableCellElement } from "./table-cell-impl";
+import { TableElement } from "./table-impl";
+import { TableRowElement } from "./table-row-impl";
+export class TableUtil {
+    static canDeleteTable(ss) {
+        const { startControl } = ss;
+        if (!startControl) {
+            return false;
+        }
+        const tb = ElementUtil.getParentByType(startControl, TableElement);
+        return tb ? true : false;
+    }
+    /**
+     * 校验当前选区是否可以执行合并单元格操作
+     * @param ss
+     * @returns
+     */
+    static canMergeCells(ss) {
+        const { ancestorCommonControl, startControl, endControl, collapsed, selectedRange } = ss;
+        if (collapsed) {
+            return false;
+        }
+        if (ancestorCommonControl instanceof TableElement || ancestorCommonControl instanceof TableRowElement) {
+            const tbElement = ancestorCommonControl instanceof TableElement ? ancestorCommonControl : ancestorCommonControl.parent;
+            const startCell = ElementUtil.getParentByType(startControl, TableCellElement);
+            const endCell = ElementUtil.getParentByType(endControl, TableCellElement);
+            if (startCell?.parent?.parent === tbElement && endCell?.parent?.parent === tbElement) {
+                const tbRegion = this.getTableRectSelectedRegion(tbElement, startCell, endCell);
+                if (selectedRange && selectedRange.target === tbElement) {
+                    const selectedCells = [];
+                    selectedRange.selectedChildren.every(item => item.selectedChildren.every(cell => selectedCells.push(cell.target)));
+                    for (let i = tbRegion.startRow; i <= tbRegion.endRow; i++) {
+                        const currRow = tbElement.getChild(i);
+                        for (let j = tbRegion.startCol; j <= tbRegion.endCol; j++) {
+                            const currCell = currRow.getChild(j);
+                            if (currCell.isNotBeMergedCell() && selectedCells.indexOf(currCell) < 0) {
+                                return false;
+                            }
+                        }
+                    }
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * 获取横向合并当前单元格合并结束索引位置
+     * @param tb
+     * @param rowIndex
+     * @param colIndex
+     */
+    static getHMergeEndIndex(tb, rowIndex, colIndex) {
+        const currRow = tb.getChild(rowIndex);
+        let index = colIndex;
+        for (let i = colIndex + 1; i < tb.getColsCount(); i++) {
+            const cell = currRow.getChild(i);
+            if (cell.props.hMerge === 'continue') {
+                index = i;
+            }
+            else {
+                break;
+            }
+        }
+        return index;
+    }
+    /**
+     * 获取横向合并当前单元格合并开始索引位置
+     * @param tb
+     * @param rowIndex
+     * @param colIndex
+     */
+    static getHMergeStartIndex(tb, rowIndex, colIndex) {
+        const row = tb.getChild(rowIndex);
+        for (let i = colIndex - 1; i >= 0; i--) {
+            const cell = row.getChild(i);
+            if (cell.props.hMerge === 'restart') {
+                return i;
+            }
+        }
+        throw new Error('未找到主合并单元格');
+    }
+    /**
+     * 获取纵向合并当前单元格合并结束索引位置
+     * @param tb
+     * @param rowIndex
+     * @param colIndex i
+     */
+    static getVMergeEndIndex(tb, rowIndex, colIndex) {
+        let index = rowIndex;
+        for (let i = rowIndex + 1; i < tb.length; i++) {
+            const currRow = tb.getChild(i);
+            const cell = currRow.getChild(colIndex);
+            if (cell.props.vMerge === 'continue') {
+                index = i;
+            }
+            else {
+                break;
+            }
+        }
+        return index;
+    }
+    /**
+     * 获取纵向合并当前单元格合并开始索引位置
+     * @param tb
+     * @param rowIndex
+     * @param colIndex i
+     */
+    static getVMergeStartIndex(tb, rowIndex, colIndex) {
+        for (let i = rowIndex - 1; i >= 0; i--) {
+            const currRow = tb.getChild(i);
+            const cell = currRow.getChild(colIndex);
+            if (cell.props.vMerge === 'restart') {
+                return i;
+            }
+        }
+        throw new Error('未找到主合并单元格');
+    }
+    /**
+     * 合并单元格
+     * @param ss
+     * @returns
+     */
+    static mergeCells(ss) {
+        const { ancestorCommonControl, startControl, endControl, collapsed } = ss;
+        if (collapsed) {
+            return;
+        }
+        if (ancestorCommonControl instanceof TableElement || ancestorCommonControl instanceof TableRowElement) {
+            const tbElement = ancestorCommonControl instanceof TableElement ? ancestorCommonControl : ancestorCommonControl.parent;
+            const startCell = ElementUtil.getParentByType(startControl, TableCellElement);
+            const endCell = ElementUtil.getParentByType(endControl, TableCellElement);
+            if (startCell?.parent?.parent === tbElement && endCell?.parent?.parent === tbElement) {
+                //this.combineCellContent(tbElement, startCell, endCell);
+                this.combineCells(tbElement, startCell, endCell);
+            }
+            this.checkRowBeMerged(ss);
+            ss.clear();
+        }
+    }
+    /**
+     * 在合并单元格后需要校验
+     * 1.如果某个行的所有单元格都不是normal，则需要删除当前行
+     * 2.如果某个列的所有的单元格都不是normal，则需要删除当前列
+     */
+    static checkRowBeMerged(ss) {
+        const tb = ElementUtil.getParentByType(ss.startControl, TableElement);
+        if (!tb) {
+            return;
+        }
+        const colsCount = tb.getColsCount();
+        const fullMergeRows = [];
+        for (let i = 0; i < tb.length; i++) {
+            const row = tb.getChild(i);
+            let count = 0;
+            for (let j = 0; j < colsCount; j++) {
+                const cell = row.getChild(j);
+                if (!cell.isNotBeMergedCell()) {
+                    count++;
+                }
+            }
+            //当前行所有的单元格都被合并，需要删除
+            if (count === colsCount) {
+                fullMergeRows.push(row);
+            }
+        }
+        fullMergeRows.forEach(row => this.removeRow(row));
+    }
+    /**
+     * 移除行
+     * @param row
+     */
+    static removeRow(row) {
+        const rowIndex = row.getIndex();
+        const tb = row.parent;
+        for (let i = 0; i < row.length; i++) {
+            const cell = row.getChild(i);
+            if (cell.props.vMerge === 'restart') {
+                const vMergeEndIndex = this.getVMergeEndIndex(tb, rowIndex, i);
+                if (vMergeEndIndex > rowIndex) {
+                    const nextRow = tb.getChild(rowIndex + 1);
+                    nextRow.getChild(i).props.vMerge = vMergeEndIndex - rowIndex > 2 ? 'restart' : null;
+                }
+            }
+            else if (cell.props.vMerge === 'continue') {
+                // const vMergeEndIndex = this.getVMergeEndIndex(tb, rowIndex, i);
+                // if (vMergeEndIndex > rowIndex) {
+                //     const nextRow = tb.getChild<TableRowElement>(rowIndex + 1);
+                //     nextRow.getChild<TableCellElement>(i).cellProps.vMerge = 'continue';
+                // }
+                const vMergeStartIndex = this.getVMergeStartIndex(tb, rowIndex, i);
+                const vMergeEndIndex = this.getVMergeEndIndex(tb, rowIndex, i);
+                //当前单元格处于合并行的最后一行，并且合并的行数为2行
+                if (vMergeEndIndex === rowIndex && vMergeEndIndex - vMergeStartIndex === 1) {
+                    const aboveCell = tb.getChild(vMergeStartIndex).getChild(i);
+                    aboveCell.props.vMerge = null;
+                }
+            }
+        }
+        tb.removeChild(row);
+    }
+    /**
+     * 移除列
+     * @param tb
+     * @param colIndex
+     */
+    static removeCol(tb, colIndex) {
+        for (let i = 0; i < tb.length; i++) {
+            const row = tb.getChild(i);
+            const cell = row.getChild(colIndex);
+            if (cell.props.hMerge === 'restart') {
+                const hMergeEndIndex = this.getHMergeEndIndex(tb, i, colIndex);
+                if (hMergeEndIndex > colIndex) {
+                    const nextCell = row.getChild(colIndex + 1);
+                    nextCell.props.hMerge = hMergeEndIndex - colIndex > 2 ? 'restart' : null;
+                }
+            }
+            else if (cell.props.hMerge === 'continue') {
+                const hMergeStartIndex = this.getHMergeStartIndex(tb, i, colIndex);
+                const hMergeEndIndex = this.getHMergeEndIndex(tb, i, colIndex);
+                //当前单元格处于合并行的最后一行，并且合并的行数为2行
+                if (hMergeEndIndex === colIndex && hMergeEndIndex - hMergeStartIndex === 1) {
+                    const masterVMergeCell = tb.getChild(hMergeStartIndex).getChild(i);
+                    masterVMergeCell.props.hMerge = null;
+                }
+            }
+            row.removeChild(cell);
+        }
+        tb.removeCol(colIndex);
+    }
+    /**
+     * 移除光标所在的当前行
+     * @param ss
+     */
+    static removeCurrRow(ss) {
+        const startCell = ElementUtil.getParentByType(ss.startControl, TableCellElement);
+        if (!startCell?.parent) {
+            throw new Error('parent is null');
+        }
+        const currRow = startCell.parent;
+        const tb = currRow.parent;
+        this.removeRow(currRow);
+        tb.pubOnChange('self');
+        tb.refreshView();
+    }
+    /**
+     * 移除光标所在的当前列
+     * @param ss
+     */
+    static removeCurrCol(ss) {
+        const startCell = ElementUtil.getParentByType(ss.startControl, TableCellElement);
+        if (!startCell?.parent) {
+            throw new Error('parent is null');
+        }
+        if (ss.collapsed) {
+            const currRow = startCell.parent;
+            const tb = currRow.parent;
+            this.removeCol(tb, startCell.getIndex());
+            ss.clear();
+            return;
+        }
+        const { ancestorCommonControl, startControl, endControl } = ss;
+        if (ancestorCommonControl instanceof TableElement || ancestorCommonControl instanceof TableRowElement) {
+            const tbElement = ancestorCommonControl instanceof TableElement ? ancestorCommonControl : ancestorCommonControl.parent;
+            const startCell = ElementUtil.getParentByType(startControl, TableCellElement);
+            const endCell = ElementUtil.getParentByType(endControl, TableCellElement);
+            if (startCell?.parent?.parent === tbElement && endCell?.parent?.parent === tbElement) {
+                const startColIndex = startCell.getIndex();
+                let endColIndex = endCell.getIndex();
+                while (startColIndex <= endColIndex) {
+                    this.removeCol(tbElement, endColIndex);
+                    endColIndex--;
+                }
+            }
+            tbElement.pubOnChange('self');
+        }
+        ss.clear();
+    }
+    /**
+     * 合并单元格
+     */
+    static combineCells(tbElement, startCell, endCell) {
+        const tbRegion = this.getTableRectSelectedRegion(tbElement, startCell, endCell);
+        const cellContents = [];
+        for (let i = tbRegion.startRow; i <= tbRegion.endRow; i++) {
+            const currRow = tbElement.getChild(i);
+            for (let j = tbRegion.startCol; j <= tbRegion.endCol; j++) {
+                const currCell = currRow.getChild(j);
+                currCell.props.vMerge = null;
+                currCell.props.hMerge = 'continue';
+                if (j === tbRegion.startCol) {
+                    currCell.props.vMerge = i === tbRegion.startRow ? 'restart' : 'continue';
+                    currCell.props.hMerge = 'restart';
+                }
+                if (currCell !== startCell) {
+                    cellContents.push(...ElementUtil.getChildrenElements(currCell));
+                    currCell.clearItems();
+                }
+            }
+        }
+        //如果合并的单元格都是空段落，则不合并内容
+        if (!cellContents.every((item) => (item instanceof ParagraphElement && item.length === 1))) {
+            for (let i = 0; i < cellContents.length; i++) {
+                startCell.addChild(cellContents[i]);
+            }
+        }
+    }
+    static canSplitCell(ss) {
+        const { ancestorCommonControl, startControl, endControl, collapsed } = ss;
+        if (ancestorCommonControl instanceof TableElement || ancestorCommonControl instanceof TableRowElement) {
+            const tbElement = ancestorCommonControl instanceof TableElement ? ancestorCommonControl : ancestorCommonControl.parent;
+            const startCell = ElementUtil.getParentByType(startControl, TableCellElement);
+            const endCell = ElementUtil.getParentByType(endControl, TableCellElement);
+            if (startCell?.parent?.parent === tbElement && endCell?.parent?.parent === tbElement) {
+                if (startCell === endCell) {
+                    return startCell.props.hMerge === 'restart' || startCell.props.vMerge === 'restart';
+                }
+            }
+        }
+        else {
+            const startCell = ElementUtil.getParentByType(startControl, TableCellElement);
+            if (!startCell) {
+                throw new Error('startCell is null');
+            }
+            const { hMerge, vMerge } = startCell?.props;
+            return hMerge === 'restart' || vMerge === 'restart' || !hMerge || !vMerge;
+        }
+        return false;
+    }
+    /**
+     * 将合并的单元格合并还原
+     * @param ss
+     */
+    static restoreCell(ss) {
+        const { ancestorCommonControl, startControl, endControl, collapsed } = ss;
+        const startCell = ElementUtil.getParentByType(startControl, TableCellElement);
+        if (startCell) {
+            this.restoreCellMerge(startCell);
+            ss.resetRange(startCell, 0);
+            startCell.refreshView();
+        }
+    }
+    static restoreCellMerge(cell) {
+        const { vMerge, hMerge } = cell.props;
+        const row = cell.parent;
+        const tb = row.parent;
+        const rowIndex = row.getIndex();
+        const colIndex = cell.getIndex();
+        if (vMerge === 'restart') {
+            for (let i = rowIndex + 1; i < tb.length; i++) {
+                const row = tb.getChild(i);
+                const cell = row.getChild(colIndex);
+                if (cell.props.vMerge === "continue") {
+                    cell.props.vMerge = null;
+                    if (cell.props.hMerge === "restart") {
+                        this.restoreCellMerge(cell);
+                    }
+                }
+            }
+        }
+        if (hMerge === 'restart') {
+            for (let i = colIndex + 1; i < row.length; i++) {
+                const cell = row.getChild(i);
+                if (cell.props.hMerge === "continue") {
+                    cell.props.hMerge = null;
+                    if (cell.props.vMerge === "restart") {
+                        this.restoreCellMerge(cell);
+                    }
+                }
+            }
+        }
+        cell.props.hMerge = null;
+        cell.props.vMerge = null;
+    }
+    static getVMergeRows(tb, masterRowIndex, masterColIndex) {
+        const items = [];
+        for (let i = masterRowIndex + 1; i < tb.length; i++) {
+            const row = tb.getChild(i);
+            const cell = row.getChild(masterColIndex);
+            if (cell.props.vMerge === 'continue') {
+                items.push(row);
+            }
+            else {
+                return items;
+            }
+        }
+        return items;
+    }
+    static insertCol(ss, insertColIndex) {
+        const startCell = ElementUtil.getParentByType(ss.startControl, TableCellElement);
+        if (!startCell?.parent) {
+            throw new Error('parent is null');
+        }
+        const startRow = startCell.parent;
+        const tb = startRow.parent;
+        const currColIndex = startCell.getIndex();
+        const colsCount = tb.getColsCount();
+        insertColIndex = insertColIndex < 0 ? 0 : insertColIndex;
+        insertColIndex = insertColIndex > colsCount ? colsCount : insertColIndex;
+        //插入列需要将之前列分割
+        const insertColWidth = insertColIndex === colsCount ? tb.getCellWidth(colsCount - 1) : tb.getCellWidth(insertColIndex);
+        const newColWidth = Math.floor(insertColWidth / 2);
+        if (newColWidth < 20) {
+            console.warn('插入列的最小宽度不能小于20,当前为:' + newColWidth);
+            return;
+        }
+        for (let i = 0; i < tb.length; i++) {
+            const row = tb.getChild(i);
+            const newCell = new TableCellElement();
+            if (insertColIndex === 0 || insertColIndex === colsCount) {
+                row.addChild(newCell, insertColIndex);
+                continue;
+            }
+            const focusCell = row.getChild(insertColIndex);
+            if (focusCell) {
+                if (focusCell.props.hMerge === 'continue') {
+                    //获取合并行的最后的行索引
+                    const hMergeEndColIndex = this.getHMergeEndIndex(tb, i, currColIndex);
+                    if (hMergeEndColIndex > insertColIndex || (hMergeEndColIndex === insertColIndex && currColIndex < insertColIndex)) {
+                        newCell.props.hMerge = 'continue';
+                    }
+                }
+                else if (focusCell.props.hMerge === 'restart' && currColIndex > insertColIndex) {
+                    newCell.props.hMerge = 'continue';
+                }
+            }
+            row.addChild(newCell, insertColIndex);
+        }
+        tb.setCellWidth(insertColIndex === colsCount ? insertColIndex - 1 : insertColIndex, insertColWidth - newColWidth);
+        tb.insertCol(insertColIndex, newColWidth);
+        tb.pubOnChange('self');
+        tb.refreshView();
+    }
+    static insertRow(ss, insertRowIndex) {
+        const startCell = ElementUtil.getParentByType(ss.startControl, TableCellElement);
+        if (!startCell?.parent) {
+            throw new Error('parent is null');
+        }
+        const startRow = startCell.parent;
+        const tb = startRow.parent;
+        const currRowIndex = startRow.getIndex();
+        insertRowIndex = insertRowIndex < 0 ? 0 : insertRowIndex;
+        insertRowIndex = insertRowIndex > tb.length ? tb.length : insertRowIndex;
+        const newRow = TableRowElement.createRow(tb.getColsCount());
+        //新行插在第一行或者最后一行
+        if (insertRowIndex === 0 || insertRowIndex === tb.length) {
+            tb.addChild(newRow, insertRowIndex);
+            tb.refreshView();
+            return newRow;
+        }
+        const destRow = tb.getChild(insertRowIndex);
+        for (let i = 0; i < destRow.length; i++) {
+            const destCell = destRow.getChild(i);
+            const newCell = newRow.getChild(i);
+            //如果当前单元格是普通单元格或者合并列的最后一个单元格，则不做处理
+            if (destCell.props.vMerge === 'continue') {
+                //获取合并列的最后的行索引
+                const vMergeEndRowIndex = this.getVMergeEndIndex(tb, insertRowIndex, i);
+                if (vMergeEndRowIndex > insertRowIndex || (vMergeEndRowIndex === insertRowIndex && currRowIndex < insertRowIndex)) {
+                    newCell.props.vMerge = 'continue';
+                    //newCell.cellProps.hMerge = destCell.cellProps.hMerge;
+                }
+            }
+            else if (destCell.props.vMerge === 'restart' && currRowIndex > insertRowIndex) {
+                //在上方新增行，目标行单元格属于合并的起点
+                newCell.props.vMerge = 'continue';
+                //newCell.cellProps.hMerge = destCell.cellProps.hMerge;
+            }
+        }
+        tb.addChild(newRow, insertRowIndex);
+        tb.refreshView();
+        return newRow;
+    }
+    /**
+     * 在下方插入行
+     */
+    static insertRowBelow(ss) {
+        const startCell = ElementUtil.getParentByType(ss.startControl, TableCellElement);
+        if (!startCell?.parent) {
+            throw new Error('parent is null');
+        }
+        const startRow = startCell.parent;
+        const currRowIndex = startRow.getIndex();
+        this.insertRow(ss, currRowIndex + 1);
+    }
+    /**
+     * 在上方插入行
+     */
+    static insertRowAbove(ss) {
+        const startCell = ElementUtil.getParentByType(ss.startControl, TableCellElement);
+        if (!startCell?.parent) {
+            throw new Error('parent is null');
+        }
+        const startRow = startCell.parent;
+        const currRowIndex = startRow.getIndex();
+        this.insertRow(ss, currRowIndex);
+    }
+    /**
+     * 在右侧插入列
+     */
+    static insertColToRight(ss) {
+        const startCell = ElementUtil.getParentByType(ss.startControl, TableCellElement);
+        if (!startCell?.parent) {
+            throw new Error('parent is null');
+        }
+        const currColIndex = startCell.getIndex();
+        this.insertCol(ss, currColIndex + 1);
+    }
+    /**
+     * 在左侧插入列
+     */
+    static insertColToLeft(ss) {
+        const startCell = ElementUtil.getParentByType(ss.startControl, TableCellElement);
+        if (!startCell?.parent) {
+            throw new Error('parent is null');
+        }
+        const currColIndex = startCell.getIndex();
+        this.insertCol(ss, currColIndex);
+    }
+    /**
+     * 跳转到下一个单元格中
+     * @param ss
+     */
+    static moveNextCell(ss) {
+        const startCell = ElementUtil.getParentByType(ss.startControl, TableCellElement);
+        if (!startCell?.parent) {
+            throw new Error('parent is null');
+        }
+        const rowIndex = startCell.parent.getIndex();
+        const nextCell = this.getNextCell(ss);
+        if (nextCell) {
+            ss.resetRange(nextCell, 0);
+            nextCell.refreshView();
+            return;
+        }
+        //新增行,并定位
+        const newRow = this.insertRow(ss, rowIndex + 1);
+        ss.resetRange(newRow, 0);
+        newRow.refreshView();
+    }
+    /**
+     * 获取下一个可定位的单元格
+     * @param ss
+     * @returns
+     */
+    static getNextCell(ss) {
+        const startCell = ElementUtil.getParentByType(ss.startControl, TableCellElement);
+        if (!startCell?.parent) {
+            throw new Error('parent is null');
+        }
+        const rowIndex = startCell.parent.getIndex();
+        const colIndex = startCell.getIndex();
+        const tb = startCell.parent.parent;
+        for (let i = rowIndex; i < tb.length; i++) {
+            let j = i === rowIndex ? colIndex + 1 : 0;
+            const currRow = tb.getChild(i);
+            for (; j < tb.getColsCount(); j++) {
+                const currCell = currRow.getChild(j);
+                if (currCell.isNotBeMergedCell()) {
+                    return currCell;
+                }
+            }
+        }
+        //throw new Error('getNextCell is null')
+    }
+    /**
+     * 当前光标是否在最后一个单元格中
+     */
+    static isLastVisiableCell(ss) {
+        return !this.getNextCell(ss);
+    }
+    /**
+     * 移除当前table
+     */
+    static removeTable(ss) {
+        const tb = ElementUtil.getParentByType(ss.startControl, TableElement);
+        if (!tb) {
+            console.warn('当前位置不存在表格');
+            return;
+        }
+        tb.parent.refreshView();
+        tb.remove();
+    }
+    /**
+     * 设置表格单元格对角线
+     * @param ss
+     * @param diagonal
+     * @returns
+     */
+    static setTableCellDiagonal(ss, diagonal) {
+        const tc = ElementUtil.getParentByType(ss.startControl, TableCellElement);
+        if (!tc) {
+            console.warn('当前位置不存在表格');
+            return;
+        }
+        if (!tc.props.diagonal || tc.props.diagonal !== diagonal) {
+            tc.props.diagonal = diagonal;
+        }
+        else if (tc.props.diagonal === diagonal) {
+            tc.props.diagonal = null;
+        }
+        tc.refreshView();
+    }
+    /**
+     * 将当前表格截断成两个相邻的表格
+     * @param tb
+     * @param rowIndex
+     */
+    static cutTable(tb, rowIndex) {
+        if (rowIndex === 0 || rowIndex === tb.length - 1) {
+            return;
+        }
+        const newTb = tb.clone(false);
+        const len = tb.length - 1;
+        while (len > rowIndex) {
+            const child = tb.getChild(len);
+            newTb.addChild(child.clone(true), 0);
+            tb.removeChild(child);
+        }
+        if (newTb.length > 0) {
+            tb.parent.addChild(newTb, tb.getIndex() + 1);
+        }
+    }
+    /**
+     * 获取表格选区区域最大的矩形区域
+     * @param tb
+     * @param startCell
+     * @param endCell
+     * @returns
+     */
+    static getTableRectSelectedRegion(tb, startCell, endCell) {
+        let startRow = startCell.parent.getIndex();
+        let startCol = startCell.getIndex();
+        let endRow = endCell.parent.getIndex();
+        let endCol = endCell.getIndex();
+        if (startRow > endRow) {
+            [endRow, startRow] = [startRow, endRow];
+        }
+        if (startCol > endCol) {
+            [endCol, startCol] = [startCol, endCol];
+        }
+        for (let i = startRow; i <= endRow; i++) {
+            const row = tb.getChild(i);
+            for (let j = startCol; j <= endCol; j++) {
+                const cell = row.getChild(j);
+                const { hMerge, vMerge } = cell.props;
+                if (hMerge === 'continue') {
+                    const startColIndex = TableUtil.getHMergeStartIndex(tb, i, j);
+                    const endColIndex = TableUtil.getHMergeEndIndex(tb, i, j);
+                    startCol = Math.min(startCol, startColIndex);
+                    endCol = Math.max(endCol, endColIndex);
+                }
+                if (vMerge === 'continue') {
+                    const startRowIndex = TableUtil.getVMergeStartIndex(tb, i, j);
+                    const endRowIndex = TableUtil.getVMergeEndIndex(tb, i, j);
+                    startRow = Math.min(startRow, startRowIndex);
+                    endRow = Math.max(endRow, endRowIndex);
+                }
+                if (vMerge === 'restart') {
+                    const rowIndex = TableUtil.getVMergeEndIndex(tb, i, j);
+                    if (rowIndex > endRow) {
+                        endRow = rowIndex;
+                    }
+                }
+                if (hMerge === 'restart') {
+                    const colIndex = TableUtil.getHMergeEndIndex(tb, i, j);
+                    if (colIndex > endCol) {
+                        endCol = colIndex;
+                    }
+                }
+            }
+        }
+        return { startRow, endRow, startCol, endCol };
+    }
+}
+//# sourceMappingURL=table-util.js.map