@visactor/vtable 1.26.5 → 1.26.6

package/dist/vtable.js

@@ -54828,6 +54828,9 @@
 	                continue;
 	            }
 	            const originRecordIndex = this.getOriginRecordIndexForGroup(recordIndex);
+	            if (!isValid$1(originRecordIndex)) {
+	                continue;
+	            }
 	            this.beforeChangedRecordsMap.delete(originRecordIndex.toString());
 	            this.dataSourceObj.records.splice(originRecordIndex, 1);
 	            this.sourceLength -= 1;
@@ -54842,6 +54845,9 @@
 	                continue;
 	            }
 	            const originRecordIndex = this.getOriginRecordIndexForGroup(recordIndex);
+	            if (!isValid$1(originRecordIndex)) {
+	                continue;
+	            }
 	            this.beforeChangedRecordsMap.delete(originRecordIndex.toString());
 	            this.dataSourceObj.records[originRecordIndex] = records[index];
 	        }
@@ -57743,17 +57749,25 @@
 	    if ('shape' in icon && icon.shape === 'circle') {
 	        iconAttribute.shape = icon.shape;
 	    }
+	    if (icon.type === 'text') {
+	        iconAttribute.text = icon.content;
+	        merge(iconAttribute, icon.style);
+	    }
+	    if (isNil$1(iconAttribute.opacity)) {
+	        iconAttribute.opacity =
+	            iconAttribute.visibleTime === 'mouseenter_cell' || iconAttribute.visibleTime === 'click_cell' ? 0 : 1;
+	    }
 	    if (mark) {
 	        mark.setAttributes(iconAttribute);
-	        mark.loadImage(iconAttribute.image);
+	        if (iconAttribute.image) {
+	            mark.loadImage(iconAttribute.image);
+	        }
 	        mark.tooltip = icon.tooltip;
 	        mark.name = icon.name;
 	        return mark;
 	    }
 	    let iconMark;
 	    if (icon.type === 'text') {
-	        iconAttribute.text = icon.content;
-	        merge(iconAttribute, icon.style);
 	        iconMark = new TextIcon(iconAttribute);
 	        iconMark.tooltip = icon.tooltip;
 	        iconMark.name = icon.name;
@@ -59497,22 +59511,41 @@
 	    }
 	}
 	function computeRowHeight(row, startCol, endCol, table) {
+	    return computeRowHeightInternal(row, startCol, endCol, table, true);
+	}
+	function computeRowHeightInternal(row, startCol, endCol, table, enableCustomCompute) {
 	    const isAllRowsAuto = table.isAutoRowHeight(row) || (table.heightMode === 'adaptive' && table.options.autoHeightInAdaptiveMode !== false);
 	    if (!isAllRowsAuto && table.getDefaultRowHeight(row) !== 'auto') {
 	        return table.getDefaultRowHeight(row);
 	    }
 	    let maxHeight;
-	    if (table.options.customComputeRowHeight) {
-	        const customRowHeight = table.options.customComputeRowHeight({
+	    if (enableCustomCompute && table.options.customComputeRowHeight) {
+	        let realHeight;
+	        let hasRealHeight = false;
+	        const getRealHeight = () => {
+	            if (!hasRealHeight) {
+	                realHeight = computeRowHeightInternal(row, startCol, endCol, table, false);
+	                hasRealHeight = true;
+	            }
+	            return realHeight;
+	        };
+	        const computeArgs = {
 	            row,
 	            table
+	        };
+	        Object.defineProperty(computeArgs, 'realHeight', {
+	            get: getRealHeight,
+	            enumerable: false,
+	            configurable: true
 	        });
+	        const customRowHeight = table.options.customComputeRowHeight(computeArgs);
 	        if (typeof customRowHeight === 'number') {
 	            return customRowHeight;
 	        }
-	        else if (customRowHeight !== 'auto') {
-	            return table.getDefaultRowHeight(row);
+	        else if (customRowHeight === 'auto') {
+	            return getRealHeight();
 	        }
+	        return table.getDefaultRowHeight(row);
 	    }
 	    if (table.internalProps.rowHeightConfig) {
 	        const rowHeightConfig = table.internalProps.rowHeightConfig.find((item) => item.key === row);
@@ -63146,6 +63179,25 @@
 	    containerGroup.setAttribute('height', heightMax);
 	}
 
+	function fillVisibleBodyRows$1(proxy, distRow) {
+	    const { table } = proxy;
+	    const bodyBottomRow = table.rowCount - 1 - table.bottomFrozenRowCount;
+	    const visibleBodyHeight = table.tableNoFrameHeight - table.getFrozenRowsHeight() - table.getBottomFrozenRowsHeight();
+	    let targetRow = distRow;
+	    while (targetRow < bodyBottomRow && table.getRowsHeight(table.frozenRowCount, targetRow) < visibleBodyHeight) {
+	        const nextRow = targetRow + 1;
+	        computeRowsHeight(table, nextRow, nextRow, false);
+	        targetRow = nextRow;
+	    }
+	    return targetRow;
+	}
+	function syncVisibleBodyRows(proxy, targetRow) {
+	    if (targetRow <= proxy.totalRow) {
+	        return;
+	    }
+	    proxy.totalRow = targetRow;
+	    proxy.totalActualBodyRowCount = Math.max(proxy.totalActualBodyRowCount, targetRow - proxy.bodyTopRow + 1);
+	}
 	function createGroupForFirstScreen(cornerHeaderGroup, colHeaderGroup, rowHeaderGroup, rightFrozenGroup, bottomFrozenGroup, bodyGroup, xOrigin, yOrigin, proxy) {
 	    const { table } = proxy;
 	    const { leftBottomCornerGroup, rightTopCornerGroup, rightBottomCornerGroup } = table.scenegraph;
@@ -63171,6 +63223,7 @@
 	    else {
 	        distRow = Math.min(proxy.firstScreenRowLimit - 1, table.rowCount - 1);
 	    }
+	    let bodyDistRow = Math.min(proxy.bodyBottomRow, distRow - table.bottomFrozenRowCount);
 	    if (table.internalProps._widthResizedColMap.size === 0) {
 	        computeColsWidth(table, 0, distColForCompute ?? distCol);
 	    }
@@ -63178,6 +63231,10 @@
 	        computeRowsHeight(table, 0, table.options.canvasHeight === 'auto' || table.options.customConfig?.forceComputeAllRowHeight
 	            ? table.rowCount - 1
 	            : distRowForCompute ?? distRow);
+	        if (table.heightMode === 'autoHeight') {
+	            bodyDistRow = fillVisibleBodyRows$1(proxy, bodyDistRow);
+	            syncVisibleBodyRows(proxy, bodyDistRow);
+	        }
 	    }
 	    if (distCol < table.colCount - table.rightFrozenColCount) {
 	        if (table.colCount - table.rightFrozenColCount <= table.colCount - 1) {
@@ -63202,13 +63259,13 @@
 	        createColGroup(colHeaderGroup, xOrigin, yOrigin, table.frozenColCount, distCol - table.rightFrozenColCount, 0, table.frozenRowCount - 1, 'columnHeader', table);
 	    if (table.frozenColCount > 0) {
 	        if (table.leftRowSeriesNumberCount > 0) {
-	            createColGroup(rowHeaderGroup, xOrigin, yOrigin, 0, table.leftRowSeriesNumberCount - 1, table.frozenRowCount, distRow - table.bottomFrozenRowCount, 'rowHeader', table);
+	            createColGroup(rowHeaderGroup, xOrigin, yOrigin, 0, table.leftRowSeriesNumberCount - 1, table.frozenRowCount, bodyDistRow, 'rowHeader', table);
 	        }
 	        if (table.frozenColCount > table.leftRowSeriesNumberCount) {
-	            createColGroup(rowHeaderGroup, xOrigin, yOrigin, table.leftRowSeriesNumberCount, Math.min(table.frozenColCount - 1, table.rowHeaderLevelCount + table.leftRowSeriesNumberCount - 1), table.frozenRowCount, distRow - table.bottomFrozenRowCount, 'rowHeader', table);
+	            createColGroup(rowHeaderGroup, xOrigin, yOrigin, table.leftRowSeriesNumberCount, Math.min(table.frozenColCount - 1, table.rowHeaderLevelCount + table.leftRowSeriesNumberCount - 1), table.frozenRowCount, bodyDistRow, 'rowHeader', table);
 	        }
 	        if (table.frozenColCount > table.rowHeaderLevelCount + table.leftRowSeriesNumberCount) {
-	            createColGroup(rowHeaderGroup, xOrigin, yOrigin, table.rowHeaderLevelCount + table.leftRowSeriesNumberCount, table.frozenColCount - 1, table.frozenRowCount, distRow - table.bottomFrozenRowCount, 'body', table);
+	            createColGroup(rowHeaderGroup, xOrigin, yOrigin, table.rowHeaderLevelCount + table.leftRowSeriesNumberCount, table.frozenColCount - 1, table.frozenRowCount, bodyDistRow, 'body', table);
 	        }
 	    }
 	    if (table.bottomFrozenRowCount > 0) {
@@ -63228,13 +63285,13 @@
 	    }
 	    if (table.rightFrozenColCount > 0) {
 	        createColGroup(rightTopCornerGroup, xOrigin, yOrigin, table.colCount - 1 - table.rightFrozenColCount + 1, table.colCount - 1, 0, table.frozenRowCount - 1, 'columnHeader', table);
-	        createColGroup(rightFrozenGroup, xOrigin, yOrigin, table.colCount - 1 - table.rightFrozenColCount + 1, table.colCount - 1, table.frozenRowCount, distRow - table.bottomFrozenRowCount, table.isPivotChart() ? 'rowHeader' : 'body', table);
+	        createColGroup(rightFrozenGroup, xOrigin, yOrigin, table.colCount - 1 - table.rightFrozenColCount + 1, table.colCount - 1, table.frozenRowCount, bodyDistRow, table.isPivotChart() ? 'rowHeader' : 'body', table);
 	    }
 	    if (table.bottomFrozenRowCount > 0 && table.rightFrozenColCount > 0) {
 	        createColGroup(rightBottomCornerGroup, xOrigin, yOrigin, table.colCount - 1 - table.rightFrozenColCount + 1, table.colCount - 1, table.rowCount - 1 - table.bottomFrozenRowCount + 1, table.rowCount - 1, 'body', table);
 	    }
 	    distCol - table.rightFrozenColCount >= table.frozenColCount &&
-	        createColGroup(bodyGroup, xOrigin, yOrigin, table.frozenColCount, distCol - table.rightFrozenColCount, table.frozenRowCount, distRow - table.bottomFrozenRowCount, 'body', table);
+	        createColGroup(bodyGroup, xOrigin, yOrigin, table.frozenColCount, distCol - table.rightFrozenColCount, table.frozenRowCount, bodyDistRow, 'body', table);
 	    if (!bodyGroup.firstChild &&
 	        !colHeaderGroup.firstChild &&
 	        !cornerHeaderGroup.firstChild &&
@@ -65468,6 +65525,11 @@
 	        updateAfter = updateAfter ?? needUpdateAfter;
 	        rowHeightsMap.insert(row);
 	    });
+	    const filledVisibleRowStart = fillVisibleBodyRows(scene);
+	    if (isNumber$3(filledVisibleRowStart)) {
+	        updateAfter = updateAfter ?? filledVisibleRowStart;
+	        rowUpdatePos = isValid$1(rowUpdatePos) ? Math.min(rowUpdatePos, filledVisibleRowStart) : filledVisibleRowStart;
+	    }
 	    resetRowNumberAndY(scene);
 	    if (addRows.length) {
 	        const beforeRow = addRows[0] - 1;
@@ -65612,6 +65674,34 @@
 	    }
 	    return row;
 	}
+	function fillVisibleBodyRows(scene) {
+	    const { table, proxy } = scene;
+	    if (table.heightMode !== 'autoHeight') {
+	        return undefined;
+	    }
+	    const bodyBottomRow = table.rowCount - 1 - table.bottomFrozenRowCount;
+	    const visibleBodyHeight = table.tableNoFrameHeight - table.getFrozenRowsHeight() - table.getBottomFrozenRowsHeight();
+	    let targetRow = Math.min(proxy.rowEnd, bodyBottomRow);
+	    computeRowsHeight(table, proxy.rowStart, targetRow, false);
+	    while (targetRow < bodyBottomRow && table.getRowsHeight(table.frozenRowCount, targetRow) < visibleBodyHeight) {
+	        const nextRow = targetRow + 1;
+	        computeRowsHeight(table, nextRow, nextRow, false);
+	        targetRow = nextRow;
+	    }
+	    if (targetRow <= proxy.rowEnd) {
+	        return undefined;
+	    }
+	    const startRow = proxy.rowEnd + 1;
+	    for (let row = startRow; row <= targetRow; row++) {
+	        addRowCellGroup(row, scene);
+	    }
+	    proxy.rowEnd = targetRow;
+	    proxy.currentRow = Math.max(proxy.currentRow, targetRow);
+	    proxy.totalRow = Math.max(proxy.totalRow, targetRow);
+	    proxy.totalActualBodyRowCount = Math.max(proxy.totalActualBodyRowCount, targetRow - proxy.rowStart + 1);
+	    proxy.rowUpdatePos = Math.min(proxy.rowUpdatePos, startRow);
+	    return startRow;
+	}
 	function resetRowNumber(scene) {
 	    scene.bodyGroup.forEachChildren((colGroup) => {
 	        let rowIndex = scene.bodyRowStart;
@@ -68704,32 +68794,65 @@
 	                }
 	            }
 	        }
-	        if (this.table.bottomFrozenRowCount > 0) {
-	            this.bottomFrozenGroup.setAttribute('y', this.tableGroup.attribute.height - this.table.getBottomFrozenRowsHeight());
+	        const hasFrozenCols = this.table.frozenColCount > 0;
+	        const hasRightFrozenCols = this.table.rightFrozenColCount > 0;
+	        const hasFrozenRows = this.table.frozenRowCount > 0;
+	        const hasBottomFrozenRows = this.table.bottomFrozenRowCount > 0;
+	        if (hasBottomFrozenRows) {
+	            const bottomFrozenRowsHeight = this.table.getBottomFrozenRowsHeight();
+	            const topFrozenBottom = Math.max(this.colHeaderGroup.attribute.y + this.colHeaderGroup.attribute.height, this.cornerHeaderGroup.attribute.y + this.cornerHeaderGroup.attribute.height, this.rightTopCornerGroup.attribute.y + this.rightTopCornerGroup.attribute.height);
+	            const middleContentBottom = Math.max(this.rowHeaderGroup.attribute.y + this.rowHeaderGroup.attribute.height, this.bodyGroup.attribute.y + this.bodyGroup.attribute.height, this.rightFrozenGroup.attribute.y + this.rightFrozenGroup.attribute.height, topFrozenBottom);
+	            const bottomFrozenY = Math.min(this.tableGroup.attribute.height - bottomFrozenRowsHeight, middleContentBottom);
+	            this.bottomFrozenGroup.setAttribute('y', bottomFrozenY);
 	            this.leftBottomCornerGroup.setAttributes({
-	                visible: true,
-	                y: this.tableGroup.attribute.height - this.table.getBottomFrozenRowsHeight(),
-	                height: this.table.getBottomFrozenRowsHeight(),
-	                width: this.table.getFrozenColsWidth()
+	                visible: hasFrozenCols,
+	                y: bottomFrozenY,
+	                height: bottomFrozenRowsHeight,
+	                width: hasFrozenCols ? this.table.getFrozenColsWidth() : 0
 	            });
 	            this.rightBottomCornerGroup.setAttributes({
-	                visible: true,
-	                y: this.tableGroup.attribute.height - this.table.getBottomFrozenRowsHeight(),
-	                height: this.table.getBottomFrozenRowsHeight()
+	                visible: hasRightFrozenCols,
+	                x: 0,
+	                y: bottomFrozenY,
+	                width: 0,
+	                height: bottomFrozenRowsHeight
 	            });
 	        }
-	        if (this.table.rightFrozenColCount > 0) {
-	            this.rightFrozenGroup.setAttribute('x', this.tableGroup.attribute.width - this.table.getRightFrozenColsWidth());
+	        else {
+	            this.leftBottomCornerGroup.setAttributes({
+	                visible: false,
+	                width: 0,
+	                height: 0
+	            });
+	            this.rightBottomCornerGroup.setAttributes({
+	                visible: false,
+	                width: 0,
+	                height: 0
+	            });
+	        }
+	        if (hasRightFrozenCols) {
+	            const rightFrozenColsWidth = this.table.getRightFrozenColsWidth();
+	            const middleContentRight = Math.max(this.colHeaderGroup.attribute.x + this.colHeaderGroup.attribute.width, this.bodyGroup.attribute.x + this.bodyGroup.attribute.width, this.bottomFrozenGroup.attribute.x + this.bottomFrozenGroup.attribute.width);
+	            const rightFrozenX = Math.min(this.tableGroup.attribute.width - rightFrozenColsWidth, middleContentRight);
+	            this.rightFrozenGroup.setAttribute('x', rightFrozenX);
 	            this.rightTopCornerGroup.setAttributes({
-	                visible: true,
-	                x: this.tableGroup.attribute.width - this.table.getRightFrozenColsWidth(),
-	                width: this.table.getRightFrozenColsWidth(),
-	                height: this.table.getFrozenRowsHeight()
+	                visible: hasFrozenRows,
+	                x: rightFrozenX,
+	                width: hasFrozenRows ? rightFrozenColsWidth : 0,
+	                height: hasFrozenRows ? this.table.getFrozenRowsHeight() : 0
 	            });
 	            this.rightBottomCornerGroup.setAttributes({
-	                visible: true,
-	                x: this.tableGroup.attribute.width - this.table.getRightFrozenColsWidth(),
-	                width: this.table.getRightFrozenColsWidth()
+	                visible: hasBottomFrozenRows,
+	                x: rightFrozenX,
+	                width: hasBottomFrozenRows ? rightFrozenColsWidth : 0,
+	                height: hasBottomFrozenRows ? this.table.getBottomFrozenRowsHeight() : 0
+	            });
+	        }
+	        else {
+	            this.rightTopCornerGroup.setAttributes({
+	                visible: false,
+	                width: 0,
+	                height: 0
 	            });
 	        }
 	        this.updateDomContainer();
@@ -71573,6 +71696,25 @@
 	        }
 	    }
 	}
+	function setCheckboxStateByRecordIndex(recordIndex, field, checked, table) {
+	    setRecordCheckboxState(recordIndex, field, checked, table.stateManager.checkedState);
+	    if (table.internalProps.enableCheckboxCascade && checked !== 'indeterminate') {
+	        updateChildrenCheckboxStateByRecordIndex(recordIndex, field, checked, table);
+	        updateParentCheckboxStateByRecordIndex(recordIndex, field, table);
+	    }
+	    updateVisibleCheckboxCellByRecordIndex(recordIndex, field, checked, table);
+	    updateHeaderCheckboxStateByField(field, table);
+	    renderCheckboxStateUpdate(table);
+	}
+	function clearCheckboxState(field, table) {
+	    if (!isValid$1(field)) {
+	        return;
+	    }
+	    clearRecordCheckboxState(table.records, field, table);
+	    updateVisibleCheckboxCellsByField(field, false, table);
+	    updateHeaderCheckboxStateByField(field, table);
+	    renderCheckboxStateUpdate(table);
+	}
 	function setCellCheckboxStateByAttribute(col, row, checked, table) {
 	    const cellGroup = table.scenegraph.getCell(col, row);
 	    const checkbox = cellGroup?.getChildByName('checkbox') ||
@@ -71657,6 +71799,186 @@
 	    });
 	    return result;
 	}
+	function normalizeRecordIndex(recordIndex) {
+	    if (isArray$5(recordIndex) && recordIndex.length === 1) {
+	        return recordIndex[0];
+	    }
+	    return recordIndex;
+	}
+	function setRecordCheckboxState(recordIndex, field, checked, checkedState) {
+	    const dataIndex = normalizeRecordIndex(recordIndex).toString();
+	    if (checkedState.get(dataIndex)) {
+	        checkedState.get(dataIndex)[field] = checked;
+	    }
+	    else {
+	        checkedState.set(dataIndex, {
+	            [field]: checked
+	        });
+	    }
+	}
+	function clearRecordCheckboxState(records, field, table, parentIndex = []) {
+	    if (!isArray$5(records)) {
+	        return;
+	    }
+	    records.forEach((record, index) => {
+	        const recordIndex = parentIndex.length ? parentIndex.concat(index) : [index];
+	        const currentState = getRecordCheckboxState(recordIndex, record, field, table);
+	        if (currentState !== false) {
+	            setRecordCheckboxState(recordIndex, field, false, table.stateManager.checkedState);
+	        }
+	        if (isArray$5(record?.children)) {
+	            clearRecordCheckboxState(record.children, field, table, recordIndex);
+	        }
+	    });
+	}
+	function updateVisibleCheckboxCellByRecordIndex(recordIndex, field, checked, table) {
+	    const bodyRowIndex = table.getBodyRowIndexByRecordIndex?.(recordIndex);
+	    if (!isNumber$3(bodyRowIndex) || bodyRowIndex < 0) {
+	        return;
+	    }
+	    const row = bodyRowIndex + table.columnHeaderLevelCount;
+	    const cols = getCheckboxColsByField(field, row, table);
+	    cols.forEach(col => {
+	        setCellCheckboxStateByAttribute(col, row, checked, table);
+	    });
+	}
+	function updateVisibleCheckboxCellsByField(field, checked, table) {
+	    const bodyStartRow = table.columnHeaderLevelCount;
+	    const cols = getCheckboxColsByField(field, bodyStartRow, table);
+	    for (let row = table.columnHeaderLevelCount; row < table.rowCount; row++) {
+	        cols.forEach(col => {
+	            setCellCheckboxStateByAttribute(col, row, checked, table);
+	        });
+	    }
+	}
+	function renderCheckboxStateUpdate(table) {
+	    const renderAsync = table.renderAsync;
+	    if (isFunction$3(renderAsync)) {
+	        renderAsync.call(table);
+	    }
+	    else {
+	        table.render();
+	    }
+	}
+	function updateHeaderCheckboxStateByField(field, table) {
+	    const fieldKey = field;
+	    let hasChecked = false;
+	    let hasUnchecked = false;
+	    let hasRecord = false;
+	    traverseRecords(table.records, (record, recordIndex) => {
+	        const state = getRecordCheckboxState(recordIndex, record, field, table);
+	        hasRecord = true;
+	        if (state === true) {
+	            hasChecked = true;
+	        }
+	        else if (state === 'indeterminate') {
+	            hasChecked = true;
+	            hasUnchecked = true;
+	        }
+	        else {
+	            hasUnchecked = true;
+	        }
+	    });
+	    const checked = hasRecord && hasChecked && !hasUnchecked ? true : hasChecked ? 'indeterminate' : false;
+	    table.stateManager.headerCheckedState[fieldKey] = checked;
+	    updateVisibleHeaderCheckboxCellByField(field, checked, table);
+	}
+	function updateVisibleHeaderCheckboxCellByField(field, checked, table) {
+	    for (let row = 0; row < table.columnHeaderLevelCount; row++) {
+	        for (let col = 0; col < table.colCount; col++) {
+	            if (table.getHeaderField(col, row) === field && table.getCellType(col, row) === 'checkbox') {
+	                table.scenegraph.updateHeaderCheckboxCellState(col, row, checked);
+	            }
+	        }
+	    }
+	}
+	function getCheckboxColsByField(field, row, table) {
+	    const cols = [];
+	    for (let col = 0; col < table.colCount; col++) {
+	        if (table.isHeader(col, row)) {
+	            continue;
+	        }
+	        const define = table.getBodyColumnDefine(col, row);
+	        if (define?.field === field && table.getCellType(col, row) === 'checkbox') {
+	            cols.push(col);
+	        }
+	    }
+	    return cols;
+	}
+	function updateChildrenCheckboxStateByRecordIndex(recordIndex, field, checked, table) {
+	    const record = getRecordByRecordIndex(table.records, recordIndex);
+	    if (!record?.children?.length) {
+	        return;
+	    }
+	    record.children.forEach((child, childIndex) => {
+	        const childRecordIndex = normalizeRecordIndexToArray(recordIndex).concat(childIndex);
+	        setRecordCheckboxState(childRecordIndex, field, checked, table.stateManager.checkedState);
+	        updateVisibleCheckboxCellByRecordIndex(childRecordIndex, field, checked, table);
+	        updateChildrenCheckboxStateByRecordIndex(childRecordIndex, field, checked, table);
+	    });
+	}
+	function updateParentCheckboxStateByRecordIndex(recordIndex, field, table) {
+	    const recordIndexPath = normalizeRecordIndexToArray(recordIndex);
+	    for (let level = recordIndexPath.length - 1; level > 0; level--) {
+	        const parentIndex = recordIndexPath.slice(0, level);
+	        const parentRecord = getRecordByRecordIndex(table.records, parentIndex);
+	        if (!parentRecord?.children?.length) {
+	            continue;
+	        }
+	        const childStates = parentRecord.children.map((child, childIndex) => {
+	            const childRecordIndex = parentIndex.concat(childIndex);
+	            const childState = getRecordCheckboxState(childRecordIndex, child, field, table);
+	            setRecordCheckboxState(childRecordIndex, field, childState, table.stateManager.checkedState);
+	            return childState;
+	        });
+	        const allChecked = childStates.every(state => state === true);
+	        const allUnchecked = childStates.every(state => state !== true && state !== 'indeterminate');
+	        const parentState = allChecked ? true : allUnchecked ? false : 'indeterminate';
+	        setRecordCheckboxState(parentIndex, field, parentState, table.stateManager.checkedState);
+	        updateVisibleCheckboxCellByRecordIndex(parentIndex, field, parentState, table);
+	    }
+	}
+	function getRecordCheckboxState(recordIndex, record, field, table) {
+	    const fieldKey = field;
+	    const dataIndex = normalizeRecordIndex(recordIndex).toString();
+	    const cachedState = table.stateManager.checkedState.get(dataIndex)?.[fieldKey];
+	    if (isValid$1(cachedState)) {
+	        return cachedState;
+	    }
+	    const value = record?.[fieldKey];
+	    if (isObject$7(value) && isValid$1(value.checked)) {
+	        return value.checked;
+	    }
+	    if (typeof value === 'boolean') {
+	        return value;
+	    }
+	    return false;
+	}
+	function getRecordByRecordIndex(records, recordIndex) {
+	    const recordIndexPath = normalizeRecordIndexToArray(recordIndex);
+	    let currentRecords = records;
+	    let record;
+	    for (let i = 0; i < recordIndexPath.length; i++) {
+	        record = currentRecords?.[recordIndexPath[i]];
+	        currentRecords = record?.children;
+	    }
+	    return record;
+	}
+	function normalizeRecordIndexToArray(recordIndex) {
+	    return isArray$5(recordIndex) ? recordIndex : [recordIndex];
+	}
+	function traverseRecords(records, handler, parentIndex = []) {
+	    if (!isArray$5(records)) {
+	        return;
+	    }
+	    records.forEach((record, index) => {
+	        const recordIndex = parentIndex.length ? parentIndex.concat(index) : index;
+	        handler(record, recordIndex);
+	        if (isArray$5(record?.children)) {
+	            traverseRecords(record.children, handler, isArray$5(recordIndex) ? recordIndex : [recordIndex]);
+	        }
+	    });
+	}
 	function initRecordCheckState(records, state) {
 	    const table = state.table;
 	    const start = table.isPivotTable()
@@ -77253,6 +77575,9 @@
 	    _table;
 	    constructor(_table) {
 	        this._table = _table;
+	        this.updateIcons();
+	    }
+	    updateIcons() {
 	        const regedIcons = get$4();
 	        this.expandIcon = regedIcons[InternalIconName.expandIconName];
 	        this.collapseIcon = regedIcons[InternalIconName.collapseIconName];
@@ -78455,6 +78780,9 @@
 	    _table;
 	    constructor(_table) {
 	        this._table = _table;
+	        this.updateIcons();
+	    }
+	    updateIcons() {
 	        const regedIcons = get$4();
 	        this.freezeIcon = regedIcons[InternalIconName.freezeIconName];
 	        this.frozenIcon = regedIcons[InternalIconName.frozenIconName];
@@ -79166,6 +79494,9 @@
 	    _table;
 	    constructor(_table) {
 	        this._table = _table;
+	        this.updateIcons();
+	    }
+	    updateIcons() {
 	        const regedIcons = get$4();
 	        this.dragReorderIconName = regedIcons[InternalIconName.dragReorderIconName];
 	    }
@@ -80935,8 +81266,9 @@
 	    pluginEventMap = new Map();
 	    constructor(table, options) {
 	        this.table = table;
-	        options.plugins?.map(plugin => {
+	        options.plugins?.forEach(plugin => {
 	            this.register(plugin);
+	            plugin.init?.(this.table, options);
 	            this._bindTableEventForPlugin(plugin);
 	        });
 	    }
@@ -80960,18 +81292,20 @@
 	            this.pluginEventMap.set(plugin.id, [...(this.pluginEventMap.get(plugin.id) || []), id]);
 	        });
 	    }
-	    removeOrAddPlugins(plugins) {
+	    removeOrAddPlugins(plugins, options = this.table.options) {
 	        const removedPlugins = Array.from(this.plugins.values()).filter(plugin => !plugins?.some(p => p.id === plugin.id));
 	        removedPlugins.forEach(plugin => {
 	            this.pluginEventMap.get(plugin.id)?.forEach(id => {
 	                this.table.off(id);
 	            });
-	            this.release();
+	            this.pluginEventMap.delete(plugin.id);
+	            plugin.release?.(this.table);
 	            this.plugins.delete(plugin.id);
 	        });
 	        const addedPlugins = plugins?.filter(plugin => !this.plugins.has(plugin.id));
 	        addedPlugins?.forEach(plugin => {
 	            this.register(plugin);
+	            plugin.init?.(this.table, options);
 	            this._bindTableEventForPlugin(plugin);
 	        });
 	    }
@@ -80993,6 +81327,9 @@
 	const { isTouchEvent } = event;
 	const rangeReg = /^\$(\d+)\$(\d+)$/;
 	importStyle$2();
+	function normalizeCellType(cellType) {
+	    return isValid$1(cellType) ? cellType : 'text';
+	}
 	class BaseTable extends EventTarget$1 {
 	    internalProps;
 	    showFrozenIcon = true;
@@ -81031,7 +81368,7 @@
 	        return TABLE_EVENT_TYPE;
 	    }
 	    options;
-	    version = "1.26.5";
+	    version = "1.26.6";
 	    pagination;
 	    id = `VTable${Date.now()}`;
 	    headerStyleCache;
@@ -81224,7 +81561,7 @@
 	        internalProps.focusedTable = false;
 	        internalProps.theme = themes.of(options.theme ?? themes.DEFAULT);
 	        internalProps.theme.isPivot = this.isPivotTable();
-	        setIconColor(internalProps.theme.functionalIconsStyle);
+	        this._updateFunctionalIcons();
 	        if (container) {
 	            if (clearDOM) {
 	                container.innerHTML = '';
@@ -82859,7 +83196,7 @@
 	        internalProps.stick.changedCells.clear();
 	        internalProps.theme = themes.of(options.theme ?? themes.DEFAULT);
 	        internalProps.theme.isPivot = this.isPivotTable();
-	        setIconColor(internalProps.theme.functionalIconsStyle);
+	        this._updateFunctionalIcons();
 	        this.scenegraph.updateStageBackground();
 	        internalProps.autoWrapText = options.autoWrapText;
 	        internalProps.enableLineBreak = options.enableLineBreak;
@@ -83346,6 +83683,12 @@
 	        this.scenegraph.createSceneGraph();
 	        this.render();
 	    }
+	    _updateFunctionalIcons() {
+	        setIconColor(this.internalProps.theme.functionalIconsStyle);
+	        this.internalProps.headerHelper?.updateIcons();
+	        this.internalProps.bodyHelper?.updateIcons();
+	        this.internalProps.rowSeriesNumberHelper?.updateIcons();
+	    }
 	    get theme() {
 	        return this.internalProps.theme;
 	    }
@@ -83353,13 +83696,13 @@
 	        this.internalProps.theme = themes.of(theme ?? themes.DEFAULT);
 	        this.internalProps.theme.isPivot = this.isPivotTable();
 	        this.options.theme = theme;
-	        setIconColor(this.internalProps.theme.functionalIconsStyle);
+	        this._updateFunctionalIcons();
 	    }
 	    updateTheme(theme) {
 	        const oldHoverState = { col: this.stateManager.hover.cellPos.col, row: this.stateManager.hover.cellPos.row };
 	        this.internalProps.theme = themes.of(theme ?? themes.DEFAULT);
 	        this.internalProps.theme.isPivot = this.isPivotTable();
-	        setIconColor(this.internalProps.theme.functionalIconsStyle);
+	        this._updateFunctionalIcons();
 	        this.options.theme = theme;
 	        this.scenegraph.updateComponent();
 	        this.scenegraph.updateStageBackground();
@@ -83378,13 +83721,13 @@
 	    }
 	    getBodyColumnType(col, row) {
 	        const cellType = this.internalProps.layoutMap.getBody(col, row)?.cellType ?? 'text';
-	        return getProp('cellType', { cellType }, col, row, this);
+	        return normalizeCellType(getProp('cellType', { cellType }, col, row, this));
 	    }
 	    getCellType(col, row) {
 	        let cellType;
 	        if (this.isSeriesNumberInHeader(col, row)) {
 	            const seriesHeaderCellType = this.internalProps.layoutMap.getSeriesNumberHeader(col, row).cellType;
-	            return seriesHeaderCellType === 'radio' ? 'text' : seriesHeaderCellType;
+	            return normalizeCellType(seriesHeaderCellType === 'radio' ? 'text' : seriesHeaderCellType);
 	        }
 	        else if (this.isHeader(col, row)) {
 	            cellType = this.internalProps.layoutMap.getHeader(col, row).headerType;
@@ -83392,7 +83735,7 @@
 	        else {
 	            cellType = this.internalProps.layoutMap.getBody(col, row).cellType;
 	        }
-	        return getProp('cellType', { cellType }, col, row, this);
+	        return normalizeCellType(getProp('cellType', { cellType }, col, row, this));
 	    }
 	    getHeaderField(col, row) {
 	        return this.internalProps.layoutMap.getHeaderField(col, row);
@@ -89011,6 +89354,9 @@
 	                const { title } = table.internalProps.layoutMap.getSeriesNumberHeader(col, row);
 	                return title;
 	            }
+	            if (table.internalProps.layoutMap.isAggregation(col, row)) {
+	                return '';
+	            }
 	            let value;
 	            if (this.internalProps.groupBy) {
 	                const record = table.getCellRawRecord(col, row);
@@ -89064,6 +89410,9 @@
 	                const { title } = table.internalProps.layoutMap.getSeriesNumberHeader(col, row);
 	                return title;
 	            }
+	            if (table.internalProps.layoutMap.isAggregation(col, row)) {
+	                return '';
+	            }
 	            const { format } = table.internalProps.layoutMap.getSeriesNumberBody(col, row);
 	            return typeof format === 'function' ? format(col, row, this) : row - this.columnHeaderLevelCount;
 	        }
@@ -89165,7 +89514,7 @@
 	        clearRowHeightCache: true
 	    }) {
 	        const internalProps = this.internalProps;
-	        this.pluginManager.removeOrAddPlugins(options.plugins);
+	        this.pluginManager.removeOrAddPlugins(options.plugins, options);
 	        super.updateOption(options, updateConfig);
 	        internalProps.frozenColDragHeaderMode =
 	            options.dragOrder?.frozenColDragHeaderMode ?? options.frozenColDragHeaderMode;
@@ -89720,6 +90069,15 @@
 	    setCellCheckboxState(col, row, checked) {
 	        setCellCheckboxState(col, row, checked, this);
 	    }
+	    setCellCheckboxStateByRecordIndex(recordIndex, field, checked) {
+	        setCheckboxStateByRecordIndex(recordIndex, field, checked, this);
+	    }
+	    clearCheckboxState(field) {
+	        clearCheckboxState(field, this);
+	    }
+	    clearAllCheckboxState(field) {
+	        this.clearCheckboxState(field);
+	    }
 	    setCellRadioState(col, row, index) {
 	        setCellRadioState(col, row, index, this);
 	    }
@@ -90329,11 +90687,12 @@
 	        }
 	    }
 	    updateRecords(records, recordIndexs, triggerEvent = true) {
-	        listTableUpdateRecords(records, recordIndexs, this);
+	        const updateRecordIndexs = recordIndexs ?? records?.map((_, index) => index) ?? [];
+	        listTableUpdateRecords(records, updateRecordIndexs, this);
 	        if (triggerEvent) {
 	            this.fireListeners(TABLE_EVENT_TYPE.UPDATE_RECORD, {
 	                records,
-	                recordIndexs,
+	                recordIndexs: updateRecordIndexs,
 	                updateCount: records.length
 	            });
 	        }
@@ -105862,7 +106221,7 @@
 	}
 
 	registerForVrender();
-	const version = "1.26.5";
+	const version = "1.26.6";
 	function getIcons() {
 	    return get$4();
 	}