k-vtable 1.0.36 → 1.0.37

package/dist/vtable.js

@@ -41970,26 +41970,53 @@
         return parse$2(font);
     }
 
-    function getQuadProps(paddingOrigin) {
-        if (isNumber$3(paddingOrigin) || isString$2(paddingOrigin) || isArray$5(paddingOrigin)) {
-            let padding = parsePadding(paddingOrigin);
-            if (typeof padding === 'number' || typeof padding === 'string') {
-                padding = [padding, padding, padding, padding];
-            }
-            else if (Array.isArray(padding)) {
-                padding = padding.slice(0);
-            }
-            return padding;
+    function normalizeQuadArray(values) {
+        if (values.length === 0) {
+            return [0, 0, 0, 0];
+        }
+        if (values.length === 1) {
+            return [values[0], values[0], values[0], values[0]];
+        }
+        if (values.length === 2) {
+            return [values[0], values[1], values[0], values[1]];
+        }
+        if (values.length === 3) {
+            return [values[0], values[1], values[2], values[1]];
+        }
+        return [values[0], values[1], values[2], values[3]];
+    }
+    function parseStringQuad(padding) {
+        const tokens = padding.trim().split(/\s+/);
+        const values = tokens.map(token => Number.parseFloat(token)).filter(value => Number.isFinite(value));
+        if (values.length === tokens.length && values.length > 0) {
+            return normalizeQuadArray(values);
         }
-        else if (paddingOrigin &&
-            (isFinite(paddingOrigin.bottom) ||
-                isFinite(paddingOrigin.left) ||
-                isFinite(paddingOrigin.right) ||
-                isFinite(paddingOrigin.top))) {
+        return [padding, padding, padding, padding];
+    }
+    function normalizePaddingObject(paddingOrigin) {
+        if (Number.isFinite(paddingOrigin.bottom) ||
+            Number.isFinite(paddingOrigin.left) ||
+            Number.isFinite(paddingOrigin.right) ||
+            Number.isFinite(paddingOrigin.top)) {
             return [paddingOrigin.top ?? 0, paddingOrigin.right ?? 0, paddingOrigin.bottom ?? 0, paddingOrigin.left ?? 0];
         }
         return [0, 0, 0, 0];
     }
+    function getQuadProps(paddingOrigin) {
+        if (Array.isArray(paddingOrigin)) {
+            return normalizeQuadArray(paddingOrigin.slice(0, 4));
+        }
+        if (typeof paddingOrigin === 'number' && Number.isFinite(paddingOrigin)) {
+            return [paddingOrigin, paddingOrigin, paddingOrigin, paddingOrigin];
+        }
+        if (typeof paddingOrigin === 'string') {
+            return parseStringQuad(paddingOrigin);
+        }
+        if (paddingOrigin && typeof paddingOrigin === 'object') {
+            return normalizePaddingObject(paddingOrigin);
+        }
+        return [0, 0, 0, 0];
+    }
 
     const TYPE_PAREN = 0;
     const TYPE_UNIT = 1;
@@ -43511,7 +43538,7 @@
                 col: range?.start.col ?? col,
                 row: range?.start.row ?? row,
                 dataValue: table.getCellOriginValue(col, row),
-                value: table.getCellValue(col, row) || '',
+                value: table.getCellValue(col, row),
                 rect: {
                     left: 0,
                     top: 0,
@@ -43547,7 +43574,7 @@
                 col,
                 row,
                 dataValue: table.getCellOriginValue(col, row),
-                value: table.getCellValue(col, row) || '',
+                value: table.getCellValue(col, row),
                 rect: {
                     left: 0,
                     top: 0,
@@ -46990,7 +47017,7 @@
                 col: cellRange?.start.col ?? col,
                 row: cellRange?.start.row ?? row,
                 dataValue: table.getCellOriginValue(col, row),
-                value: table.getCellValue(col, row) || '',
+                value: table.getCellValue(col, row),
                 rect: getCellRect$1(col, row, table),
                 table,
                 originCol: col,
@@ -48348,6 +48375,16 @@
         }
     }
 
+    function getBodyHorizontalScrollRange(table) {
+        const totalWidth = table.getAllColsWidth();
+        const frozenColsWidth = table.getFrozenColsWidth();
+        const rightFrozenColsWidth = table.getRightFrozenColsWidth();
+        const frozenColsContentWidth = table.getFrozenColsContentWidth?.() ?? frozenColsWidth;
+        const rightFrozenColsContentWidth = table.getRightFrozenColsContentWidth?.() ?? rightFrozenColsWidth;
+        const bodyViewportWidth = table.tableNoFrameWidth - frozenColsWidth - rightFrozenColsWidth;
+        const bodyContentWidth = totalWidth - frozenColsContentWidth - rightFrozenColsContentWidth;
+        return Math.max(0, bodyContentWidth - bodyViewportWidth);
+    }
     function getColX(col, table, isRightFrozen) {
         if (isRightFrozen) {
             return (Math.min(table.tableNoFrameWidth, table.getAllColsWidth()) -
@@ -48752,24 +48789,25 @@
             const rightFrozenColsContentWidth = this.table.getRightFrozenColsContentWidth?.() ?? rightFrozenColsWidth;
             const hoverOn = this.table.theme.scrollStyle.hoverOn;
             const sizeTolerance = this.table.options.customConfig?._disableColumnAndRowSizeRound ? 1 : 0;
-            if (totalWidth > tableWidth + sizeTolerance) {
-                const y = Math.min(tableHeight, totalHeight);
+            const bodyScrollRange = getBodyHorizontalScrollRange(this.table);
+            const y = Math.min(tableHeight, totalHeight);
+            let attrY = 0;
+            if (this.table.theme.scrollStyle.barToSide) {
+                attrY =
+                    this.table.tableNoFrameHeight -
+                        (hoverOn ? width : -this.table.scenegraph.tableGroup.attribute.y) +
+                        this.table.tableY;
+            }
+            else {
+                attrY = y - (hoverOn ? width : -this.table.scenegraph.tableGroup.attribute.y);
+            }
+            const ignoreFrozenCols = this.table.theme.scrollStyle?.ignoreFrozenCols ?? false;
+            if (bodyScrollRange > sizeTolerance) {
                 const bodyViewportWidth = tableWidth - frozenColsWidth - rightFrozenColsWidth;
-                const bodyContentWidth = totalWidth - frozenColsContentWidth - rightFrozenColsContentWidth;
+                const bodyContentWidth = bodyViewportWidth + bodyScrollRange;
                 const rangeEnd = bodyContentWidth > 0 ? Math.max(0.05, bodyViewportWidth / bodyContentWidth) : 1;
-                let attrY = 0;
-                if (this.table.theme.scrollStyle.barToSide) {
-                    attrY =
-                        this.table.tableNoFrameHeight -
-                            (hoverOn ? width : -this.table.scenegraph.tableGroup.attribute.y) +
-                            this.table.tableY;
-                }
-                else {
-                    attrY = y - (hoverOn ? width : -this.table.scenegraph.tableGroup.attribute.y);
-                }
                 let hScrollBarx = frozenColsWidth + (!hoverOn ? this.table.scenegraph.tableGroup.attribute.x : 0);
                 let hScrollBarWidth = tableWidth - frozenColsWidth - rightFrozenColsWidth;
-                const ignoreFrozenCols = this.table.theme.scrollStyle?.ignoreFrozenCols ?? false;
                 if (ignoreFrozenCols) {
                     hScrollBarx = !hoverOn ? this.table.scenegraph.tableGroup.attribute.x : 0;
                     hScrollBarWidth = tableWidth;
@@ -48793,62 +48831,6 @@
                 if (horizontalVisible === 'always') {
                     this.hScrollBar.showAll();
                 }
-                const frozenScrollable = this.table.options.scrollFrozenCols && this.table.getFrozenColsOffset() > 0;
-                if (!ignoreFrozenCols && frozenScrollable) {
-                    const frozenRangeEnd = Math.max(0.05, frozenColsWidth / frozenColsContentWidth);
-                    const x = !hoverOn ? this.table.scenegraph.tableGroup.attribute.x : 0;
-                    this.frozenHScrollBar.setAttributes({
-                        x,
-                        y: attrY,
-                        width: frozenColsWidth,
-                        range: [0, frozenRangeEnd],
-                        visible: horizontalVisible === 'always'
-                    });
-                    const bounds = this.frozenHScrollBar.AABBBounds && this.frozenHScrollBar.globalAABBBounds;
-                    this.frozenHScrollBar._viewPosition = {
-                        x: bounds.x1,
-                        y: bounds.y1
-                    };
-                    if (horizontalVisible === 'always') {
-                        this.frozenHScrollBar.showAll();
-                    }
-                }
-                else {
-                    this.frozenHScrollBar.setAttributes({
-                        x: -this.table.tableNoFrameWidth * 2,
-                        y: -this.table.tableNoFrameHeight * 2,
-                        width: 0,
-                        visible: false
-                    });
-                }
-                const rightFrozenScrollable = this.table.options.scrollRightFrozenCols && this.table.getRightFrozenColsOffset() > 0;
-                if (!ignoreFrozenCols && rightFrozenScrollable) {
-                    const rightFrozenRangeEnd = Math.max(0.05, rightFrozenColsWidth / rightFrozenColsContentWidth);
-                    const x = tableWidth - rightFrozenColsWidth + (!hoverOn ? this.table.scenegraph.tableGroup.attribute.x : 0);
-                    this.rightFrozenHScrollBar.setAttributes({
-                        x,
-                        y: attrY,
-                        width: rightFrozenColsWidth,
-                        range: [0, rightFrozenRangeEnd],
-                        visible: horizontalVisible === 'always'
-                    });
-                    const bounds = this.rightFrozenHScrollBar.AABBBounds && this.rightFrozenHScrollBar.globalAABBBounds;
-                    this.rightFrozenHScrollBar._viewPosition = {
-                        x: bounds.x1,
-                        y: bounds.y1
-                    };
-                    if (horizontalVisible === 'always') {
-                        this.rightFrozenHScrollBar.showAll();
-                    }
-                }
-                else {
-                    this.rightFrozenHScrollBar.setAttributes({
-                        x: -this.table.tableNoFrameWidth * 2,
-                        y: -this.table.tableNoFrameHeight * 2,
-                        width: 0,
-                        visible: false
-                    });
-                }
             }
             else {
                 this.hScrollBar.setAttributes({
@@ -48857,12 +48839,56 @@
                     width: 0,
                     visible: false
                 });
+            }
+            const frozenScrollable = this.table.options.scrollFrozenCols && this.table.getFrozenColsOffset() > 0;
+            if (!ignoreFrozenCols && frozenScrollable) {
+                const frozenRangeEnd = Math.max(0.05, frozenColsWidth / frozenColsContentWidth);
+                const x = !hoverOn ? this.table.scenegraph.tableGroup.attribute.x : 0;
+                this.frozenHScrollBar.setAttributes({
+                    x,
+                    y: attrY,
+                    width: frozenColsWidth,
+                    range: [0, frozenRangeEnd],
+                    visible: horizontalVisible === 'always'
+                });
+                const bounds = this.frozenHScrollBar.AABBBounds && this.frozenHScrollBar.globalAABBBounds;
+                this.frozenHScrollBar._viewPosition = {
+                    x: bounds.x1,
+                    y: bounds.y1
+                };
+                if (horizontalVisible === 'always') {
+                    this.frozenHScrollBar.showAll();
+                }
+            }
+            else {
                 this.frozenHScrollBar.setAttributes({
                     x: -this.table.tableNoFrameWidth * 2,
                     y: -this.table.tableNoFrameHeight * 2,
                     width: 0,
                     visible: false
                 });
+            }
+            const rightFrozenScrollable = this.table.options.scrollRightFrozenCols && this.table.getRightFrozenColsOffset() > 0;
+            if (!ignoreFrozenCols && rightFrozenScrollable) {
+                const rightFrozenRangeEnd = Math.max(0.05, rightFrozenColsWidth / rightFrozenColsContentWidth);
+                const x = tableWidth - rightFrozenColsWidth + (!hoverOn ? this.table.scenegraph.tableGroup.attribute.x : 0);
+                this.rightFrozenHScrollBar.setAttributes({
+                    x,
+                    y: attrY,
+                    width: rightFrozenColsWidth,
+                    range: [0, rightFrozenRangeEnd],
+                    visible: horizontalVisible === 'always'
+                });
+                const bounds = this.rightFrozenHScrollBar.AABBBounds && this.rightFrozenHScrollBar.globalAABBBounds;
+                this.rightFrozenHScrollBar._viewPosition = {
+                    x: bounds.x1,
+                    y: bounds.y1
+                };
+                if (horizontalVisible === 'always') {
+                    this.rightFrozenHScrollBar.showAll();
+                }
+            }
+            else {
                 this.rightFrozenHScrollBar.setAttributes({
                     x: -this.table.tableNoFrameWidth * 2,
                     y: -this.table.tableNoFrameHeight * 2,
@@ -53748,7 +53774,7 @@
                 col: cellRange?.start.col ?? col,
                 row: cellRange?.start.row ?? row,
                 dataValue: table.getCellOriginValue(col, row),
-                value: table.getCellValue(col, row) || '',
+                value: table.getCellValue(col, row),
                 rect: getCellRect(col, row, table),
                 table,
                 originCol: col,
@@ -57534,7 +57560,9 @@
                 const headerColGroup = scene.getColGroup(col, true);
                 insertBefore(rightTopCornerGroup, headerColGroup, rightTopCornerGroup.firstChild);
                 const bottomColGroup = scene.getColGroupInBottom(col);
-                insertBefore(rightBottomCornerGroup, bottomColGroup, rightBottomCornerGroup.firstChild);
+                if (bottomColGroup) {
+                    insertBefore(rightBottomCornerGroup, bottomColGroup, rightBottomCornerGroup.firstChild);
+                }
             }
             let x = 0;
             rightFrozenGroup.forEachChildren((columnGroup) => {
@@ -57561,9 +57589,11 @@
                 headerColGroup?.setAttribute('x', colHeaderGroup.lastChild.attribute.x + table.getColWidth(colHeaderGroup.lastChild.col));
                 colHeaderGroup?.appendChild(headerColGroup);
                 const bottomColGroup = scene.getColGroupInRightBottomCorner(col);
-                bottomColGroup?.setAttribute('x', bottomFrozenGroup.lastChild.attribute.x +
-                    table.getColWidth(bottomFrozenGroup.lastChild.col));
-                bottomFrozenGroup?.appendChild(bottomColGroup);
+                if (bottomColGroup) {
+                    const lastBottomColGroup = bottomFrozenGroup.lastChild;
+                    bottomColGroup.setAttribute('x', lastBottomColGroup ? lastBottomColGroup.attribute.x + table.getColWidth(lastBottomColGroup.col) : 0);
+                    bottomFrozenGroup.appendChild(bottomColGroup);
+                }
             }
             let x = 0;
             rightFrozenGroup.forEachChildren((columnGroup) => {
@@ -60121,6 +60151,9 @@
                         lastBodyCol.attribute.x -
                         lastBodyCol.attribute.width;
             }
+            if (this.table.options.scrollFrozenCols && x > 0) {
+                x = 0;
+            }
             if (this.table.getFrozenColsWidth() + x === this.bodyGroup.attribute.x) {
                 return;
             }
@@ -60236,11 +60269,17 @@
             this.rowHeaderGroup.forEachChildrenSkipChild((column) => {
                 rowHeaderWidth += column.attribute.width;
             });
+            if (table.options.scrollFrozenCols) {
+                rowHeaderWidth = table.getFrozenColsWidth();
+            }
             this.rowHeaderGroup.setAttribute('width', rowHeaderWidth);
             let cornerHeaderWidth = 0;
             this.cornerHeaderGroup.forEachChildrenSkipChild((column) => {
                 cornerHeaderWidth += column.attribute.width;
             });
+            if (table.options.scrollFrozenCols) {
+                cornerHeaderWidth = table.getFrozenColsWidth();
+            }
             this.cornerHeaderGroup.setAttribute('width', cornerHeaderWidth);
             this.colHeaderGroup.setAttribute('x', this.cornerHeaderGroup.attribute.width);
             this.rowHeaderGroup.setAttribute('y', this.cornerHeaderGroup.attribute.height);
@@ -64004,11 +64043,8 @@
             }
         }
         updateHorizontalScrollBar(xRatio) {
-            const totalWidth = this.table.getAllColsWidth();
             const oldHorizontalBarPos = this.scroll.horizontalBarPos;
-            const frozenOffset = this.table.getFrozenColsOffset?.() ?? 0;
-            const rightFrozenOffset = this.table.getRightFrozenColsOffset?.() ?? 0;
-            const scrollRange = Math.max(0, totalWidth - this.table.scenegraph.width - frozenOffset - rightFrozenOffset);
+            const scrollRange = getBodyHorizontalScrollRange(this.table);
             let horizontalBarPos = Math.ceil(xRatio * scrollRange);
             if (!isValid$1(horizontalBarPos) || isNaN(horizontalBarPos)) {
                 horizontalBarPos = 0;
@@ -64118,10 +64154,7 @@
                 return;
             }
             this.table.scrollLeft;
-            const totalWidth = this.table.getAllColsWidth();
-            const frozenOffset = this.table.getFrozenColsOffset?.() ?? 0;
-            const rightFrozenOffset = this.table.getRightFrozenColsOffset?.() ?? 0;
-            const scrollRange = Math.max(0, totalWidth - this.table.scenegraph.width - frozenOffset - rightFrozenOffset);
+            const scrollRange = getBodyHorizontalScrollRange(this.table);
             const sizeTolerance = this.table.options.customConfig?._disableColumnAndRowSizeRound ? 1 : 0;
             left = Math.max(0, Math.min(left, scrollRange - sizeTolerance));
             left = Math.ceil(left);
@@ -65400,15 +65433,19 @@
             if (e.button !== 0) {
                 return;
             }
+            const endedResizeCol = stateManager.isResizeCol();
+            const endedResizeRow = stateManager.isResizeRow();
+            const endedMoveCol = stateManager.isMoveCol();
+            const shouldSkipClickCell = endedResizeCol || endedResizeRow;
             if (stateManager.interactionState === 'grabing') {
                 stateManager.updateInteractionState(InteractionState.default);
-                if (stateManager.isResizeCol()) {
+                if (endedResizeCol) {
                     endResizeCol(table);
                 }
-                else if (stateManager.isResizeRow()) {
+                else if (endedResizeRow) {
                     endResizeRow(table);
                 }
-                else if (stateManager.isMoveCol()) {
+                else if (endedMoveCol) {
                     const endMoveColSuccess = table.stateManager.endMoveCol();
                     fireMoveColEventListeners(table, endMoveColSuccess, e.nativeEvent);
                 }
@@ -65438,7 +65475,7 @@
             else if (stateManager.interactionState === InteractionState.scrolling) {
                 stateManager.updateInteractionState(InteractionState.default);
             }
-            if (!table.eventManager.isDraging) {
+            if (!table.eventManager.isDraging && !shouldSkipClickCell) {
                 const eventArgsSet = getEventArgsSet(e);
                 if (!eventManager.isTouchMove &&
                     e.button === 0 &&
@@ -67684,6 +67721,9 @@
         }
         cellIsHeaderCheck(eventArgsSet, update) {
             const { eventArgs } = eventArgsSet;
+            if (!eventArgs) {
+                return false;
+            }
             const { col, row, target } = eventArgs;
             if (!this.table.isHeader(col, row)) {
                 return false;
@@ -72286,7 +72326,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "1.0.36";
+        version = "1.0.37";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -73816,15 +73856,14 @@
         }
         getBodyVisibleCellRange() {
             const { scrollTop, scrollLeft } = this;
-            const frozenRowsHeight = this.getFrozenRowsHeight();
             const frozenColsContentWidth = this.getFrozenColsContentWidth();
             const frozenColsOffset = this.getFrozenColsOffset();
             const bottomFrozenRowsHeight = this.getBottomFrozenRowsHeight();
             const rightFrozenColsWidth = this.getRightFrozenColsWidth();
-            const { row: rowStart } = this.getRowAt(scrollTop + frozenRowsHeight + 1);
+            const rowStart = Math.max(this.getTargetRowAt(scrollTop + 1)?.row ?? -1, this.frozenRowCount);
             const { col: colStart } = this.getColAt(scrollLeft + frozenColsContentWidth + 1);
             const rowEnd = this.getAllRowsHeight() > this.tableNoFrameHeight
-                ? this.getRowAt(scrollTop + this.tableNoFrameHeight - 1 - bottomFrozenRowsHeight).row
+                ? Math.max(this.getTargetRowAt(scrollTop + this.tableNoFrameHeight - 1 - bottomFrozenRowsHeight)?.row ?? -1, rowStart)
                 : this.rowCount - 1;
             const colEnd = this.getAllColsWidth() > this.tableNoFrameWidth
                 ? this.getColAt(scrollLeft + frozenColsOffset + this.tableNoFrameWidth - 1 - rightFrozenColsWidth).col
@@ -73836,11 +73875,11 @@
         }
         getBodyVisibleRowRange(start_deltaY = 0, end_deltaY = 0) {
             const { scrollTop } = this;
-            const frozenRowsHeight = this.getFrozenRowsHeight();
             const bottomFrozenRowsHeight = this.getBottomFrozenRowsHeight();
-            const { row: rowStart } = this.getRowAt(scrollTop + frozenRowsHeight + 1 + start_deltaY);
+            const rowStart = Math.max(this.getTargetRowAt(scrollTop + 1 + start_deltaY)?.row ?? -1, this.frozenRowCount);
             const rowEnd = this.getAllRowsHeight() > this.tableNoFrameHeight
-                ? this.getRowAt(scrollTop + this.tableNoFrameHeight - 1 - bottomFrozenRowsHeight + end_deltaY).row
+                ? Math.max(this.getTargetRowAt(scrollTop + this.tableNoFrameHeight - 1 - bottomFrozenRowsHeight + end_deltaY)?.row ??
+                    -1, rowStart)
                 : this.rowCount - 1;
             if (rowEnd < 0) {
                 return null;
@@ -75703,18 +75742,21 @@
             }, delay);
         }
         scrollToRow(row, animationOption) {
-            const targetRow = Math.min(Math.max(Math.floor(row), 0), this.rowCount - 1);
+            const targetRow = Math.min(Math.max(row, 0), this.rowCount - 1);
+            const targetRowInt = Math.floor(targetRow);
             this.clearCorrectTimer();
             if (!animationOption) {
-                this.scrollToCell({ row: targetRow });
-                this._scheduleScrollToRowCorrect(targetRow);
+                this.scrollToCell({ row: targetRowInt });
+                this._scheduleScrollToRowCorrect(targetRowInt);
                 return;
             }
             const duration = !isBoolean$2(animationOption) ? animationOption?.duration ?? 3000 : 3000;
             this.animationManager.scrollTo({ row: targetRow }, animationOption);
-            this._scrollToRowCorrectTimer = setTimeout(() => {
-                this.scrollToRow(targetRow, false);
-            }, duration);
+            if (targetRowInt === targetRow) {
+                this._scrollToRowCorrectTimer = setTimeout(() => {
+                    this.scrollToRow(targetRowInt, false);
+                }, duration);
+            }
         }
         scrollToCol(col, animationOption) {
             if (!animationOption) {
@@ -78150,7 +78192,13 @@
                             }
                         }
                     }
-                    const sourceColumns = this._columns.splice(sourceCellRange.start.col - this.leftRowSeriesNumberColumnCount, sourceSize);
+                    const sourceColIndex = sourceCellRange.start.col - this.leftRowSeriesNumberColumnCount;
+                    const targetColIndex = target.col >= source.col
+                        ? targetCellRange.end.col - this.leftRowSeriesNumberColumnCount
+                        : targetCellRange.start.col - this.leftRowSeriesNumberColumnCount;
+                    const sourceTotalIndex = this._columns[sourceColIndex]?.define?.startInTotal ?? sourceColIndex;
+                    const targetTotalIndex = this._columns[targetColIndex]?.define?.startInTotal ?? targetColIndex;
+                    const sourceColumns = this._columns.splice(sourceColIndex, sourceSize);
                     sourceColumns.unshift((targetIndex - this.leftRowSeriesNumberColumnCount), 0);
                     Array.prototype.splice.apply(this._columns, sourceColumns);
                     if (this._table.options.dragOrder?.maintainArrayDataOrder) {
@@ -78158,7 +78206,7 @@
                             this._columns[i].field = i;
                         }
                     }
-                    this.columnTree.movePosition(sourceCellRange.start.row, sourceCellRange.start.col - this.leftRowSeriesNumberColumnCount, targetIndex - this.leftRowSeriesNumberColumnCount);
+                    this.columnTree.movePosition(sourceCellRange.start.row, sourceTotalIndex, targetTotalIndex);
                     if (this._table.options.dragOrder?.maintainArrayDataOrder) {
                         for (let i = 0; i < this.columnTree.tree.children.length; i++) {
                             this.columnTree.tree.children[i].field = i;
@@ -78196,10 +78244,14 @@
                         sourceIds.unshift(targetIndex, 0);
                         Array.prototype.splice.apply(this._headerCellIds[row], sourceIds);
                     }
-                    const sourceColumns = this._columns.splice(sourceCellRange.start.row, sourceSize);
+                    const sourceRowIndex = sourceCellRange.start.row;
+                    const targetRowIndex = target.row >= source.row ? targetCellRange.end.row : targetCellRange.start.row;
+                    const sourceTotalIndex = this._columns[sourceRowIndex]?.define?.startInTotal ?? sourceRowIndex;
+                    const targetTotalIndex = this._columns[targetRowIndex]?.define?.startInTotal ?? targetRowIndex;
+                    const sourceColumns = this._columns.splice(sourceRowIndex, sourceSize);
                     sourceColumns.unshift(targetIndex, 0);
                     Array.prototype.splice.apply(this._columns, sourceColumns);
-                    this.columnTree.movePosition(sourceCellRange.start.col - this.leftRowSeriesNumberColumnCount, sourceCellRange.start.row, targetIndex + (target.row > source.row ? sourceCellRange.end.row - sourceCellRange.start.row : 0));
+                    this.columnTree.movePosition(sourceCellRange.start.col - this.leftRowSeriesNumberColumnCount, sourceTotalIndex, targetTotalIndex);
                     this.columnTree.reset(this.columnTree.tree.children);
                     this._cellRangeMap = new Map();
                     return {
@@ -80584,10 +80636,32 @@
                     }
                     adjustHeightResizedRowMap(moveContext, this);
                 }
+                this.syncColumnsStateFromLayoutMap();
                 return moveContext;
             }
             return null;
         }
+        syncColumnsStateFromLayoutMap() {
+            const nextColumns = cloneDeepSpec(this.internalProps.columns, ['children']);
+            const cleanColumns = (columns) => {
+                columns.forEach(col => {
+                    delete col.level;
+                    delete col.size;
+                    delete col.startInTotal;
+                    delete col.startIndex;
+                    delete col.id;
+                    delete col.hierarchyState;
+                    if (col.columns) {
+                        cleanColumns(col.columns);
+                    }
+                });
+            };
+            cleanColumns(nextColumns);
+            this.options.columns = nextColumns;
+            if (this.options.header) {
+                this.options.header = nextColumns;
+            }
+        }
         changeRecordOrder(sourceIndex, targetIndex) {
             if (this.transpose) {
                 sourceIndex = this.getRecordShowIndexByCell(sourceIndex, 0);
@@ -84829,7 +84903,18 @@
                 const titleRows = table.listTreeStickCellPlugin.titleRows;
                 const { shadowTarget } = e.pickParams;
                 const cellGroup = getTargetCell(shadowTarget);
-                const { col, row } = cellGroup;
+                if (!cellGroup) {
+                    return;
+                }
+                const iconInfo = getIconAndPositionFromTarget(shadowTarget);
+                const funcType = iconInfo?.icon?.attribute?.funcType;
+                if (funcType === IconFuncTypeEnum.collapse || funcType === IconFuncTypeEnum.expand) {
+                    const stickCellTop = getStickCellTop(cellGroup, table);
+                    table.toggleHierarchyState(cellGroup.col, cellGroup.row);
+                    keepRowAtVisiblePosition(cellGroup.col, cellGroup.row, stickCellTop, table);
+                    return;
+                }
+                const { row } = cellGroup;
                 const rowIndex = titleRows.indexOf(row);
                 scrollToRow(row - rowIndex, table);
             });
@@ -84850,7 +84935,18 @@
                 const titleRows = table.listTreeStickCellPlugin.titleRows;
                 const { shadowTarget } = e.pickParams;
                 const cellGroup = getTargetCell(shadowTarget);
-                const { col, row } = cellGroup;
+                if (!cellGroup) {
+                    return;
+                }
+                const iconInfo = getIconAndPositionFromTarget(shadowTarget);
+                const funcType = iconInfo?.icon?.attribute?.funcType;
+                if (funcType === IconFuncTypeEnum.collapse || funcType === IconFuncTypeEnum.expand) {
+                    const stickCellTop = getStickCellTop(cellGroup, table);
+                    table.toggleHierarchyState(cellGroup.col, cellGroup.row);
+                    keepRowAtVisiblePosition(cellGroup.col, cellGroup.row, stickCellTop, table);
+                    return;
+                }
+                const { row } = cellGroup;
                 const rowIndex = titleRows.indexOf(row);
                 scrollToRow(row - rowIndex, table);
             });
@@ -84870,6 +84966,15 @@
         }
         table.scenegraph.updateNextFrame();
     }
+    function getStickCellTop(cellGroup, table) {
+        return table.getFrozenRowsHeight() + (cellGroup.attribute?.y ?? 0);
+    }
+    function keepRowAtVisiblePosition(col, row, visibleTop, table) {
+        const drawRange = table.getDrawRange();
+        const targetScrollTop = Math.max(0, Math.min(table.getCellRect(col, row).top - visibleTop, table.getAllRowsHeight() - drawRange.height));
+        table.scrollTop = targetScrollTop;
+        table.scenegraph.updateNextFrame();
+    }
     const registerListTreeStickCellPlugin = () => {
         Factory.registerComponent('listTreeStickCellPlugin', ListTreeStickCellPlugin);
     };
@@ -94343,6 +94448,11 @@
         _refreshHierarchyState(col, row, recalculateColWidths = true, beforeUpdateCell) {
             this.frozenColCount;
             this.frozenRowCount;
+            const sizeTolerance = this.options.customConfig?._disableColumnAndRowSizeRound ? 1 : 0;
+            const getMaxScrollTop = () => Math.max(0, this.getAllRowsHeight() - (this.scenegraph?.height ?? this.tableNoFrameHeight) - sizeTolerance);
+            const oldMaxScrollTop = getMaxScrollTop();
+            const isScrollToBottom = oldMaxScrollTop > 0 && this.scrollTop >= oldMaxScrollTop - 1;
+            const oldScrollTop = this.scrollTop;
             const visibleStartRow = this.getBodyVisibleRowRange().rowStart;
             this.internalProps._oldRowCount = this.rowCount;
             this.internalProps._oldColCount = this.colCount;
@@ -94359,6 +94469,9 @@
                 }
             }
             const isChangeRowTree = this.internalProps.layoutMap.isRowHeader(col, row);
+            const oldHierarchyState = isChangeRowTree ? this.getHierarchyState(col, row) : undefined;
+            const shouldKeepBottomAfterToggle = isScrollToBottom && oldHierarchyState === 'expand';
+            const shouldKeepScrollAfterToggle = isChangeRowTree && !shouldKeepBottomAfterToggle;
             const result = isChangeRowTree
                 ? this.internalProps.layoutMap.toggleHierarchyState(col, row)
                 : this.internalProps.layoutMap.toggleHierarchyStateForColumnTree(col, row);
@@ -94380,8 +94493,26 @@
                 this.clearCellStyleCache();
                 this.scenegraph.createSceneGraph();
                 this.scrollToRow(visibleStartRow);
+                if (shouldKeepBottomAfterToggle) {
+                    this.clearCorrectTimer();
+                    this.setScrollTop(Number.MAX_SAFE_INTEGER);
+                }
+                else if (shouldKeepScrollAfterToggle) {
+                    this.clearCorrectTimer();
+                    this.setScrollTop(oldScrollTop);
+                }
             }
             this.reactCustomLayout?.updateAllCustomCell();
+            if (shouldKeepBottomAfterToggle) {
+                this.clearCorrectTimer();
+                this.setScrollTop(Number.MAX_SAFE_INTEGER);
+            }
+            else if (shouldKeepScrollAfterToggle &&
+                this.rowHierarchyType !== 'grid-tree' &&
+                this.columnHierarchyType !== 'grid-tree') {
+                this.clearCorrectTimer();
+                this.setScrollTop(oldScrollTop);
+            }
             if (checkHasChart) {
                 if (this.autoFillWidth && !notFillWidth) {
                     notFillWidth = this.getAllColsWidth() <= this.tableNoFrameWidth;
@@ -96861,7 +96992,7 @@
     }
 
     registerForVrender();
-    const version = "1.0.36";
+    const version = "1.0.37";
     function getIcons() {
         return get$2();
     }