k-vtable 1.0.35 → 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]];
         }
-        else if (paddingOrigin &&
-            (isFinite(paddingOrigin.bottom) ||
-                isFinite(paddingOrigin.left) ||
-                isFinite(paddingOrigin.right) ||
-                isFinite(paddingOrigin.top))) {
+        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);
+        }
+        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,
@@ -47259,6 +47286,10 @@
             if (cell.role === 'empty') {
                 continue;
             }
+            const mergeInfo = getCellMergeInfo(scene.table, col, row);
+            if (mergeInfo && mergeInfo.start.col !== col) {
+                continue;
+            }
             const height = cell.attribute.height;
             updateCellHeightForRow(scene, cell, col, row, height + detaY, detaY, scene.table.isHeader(col, row));
             scene.updateCellContentWhileResize(col, row);
@@ -48344,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()) -
@@ -48748,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;
@@ -48789,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({
@@ -48853,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,
@@ -53744,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,
@@ -54590,6 +54620,9 @@
 
     async function dynamicSetX(x, screenLeft, isEnd, proxy) {
         if (!screenLeft) {
+            proxy.updateDeltaX(x);
+            proxy.table.scenegraph.setBodyAndColHeaderX(-x + proxy.deltaX);
+            proxy.table.scenegraph.updateNextFrame();
             return;
         }
         const screenLeftCol = screenLeft.col;
@@ -54900,6 +54933,9 @@
 
     async function dynamicSetY(y, screenTop, isEnd, proxy) {
         if (!screenTop) {
+            proxy.updateDeltaY(y);
+            proxy.updateBody(y - proxy.deltaY);
+            proxy.table.scenegraph.updateNextFrame();
             return;
         }
         const screenTopRow = screenTop.row;
@@ -55818,7 +55854,7 @@
         async setY(y, isEnd = false) {
             const yLimitTop = this.table.getRowsHeight(this.bodyTopRow, this.bodyTopRow + (this.rowEnd - this.rowStart + 1)) / 2;
             const yLimitBottom = this.table.getAllRowsHeight() - yLimitTop;
-            const screenTop = this.table.getTargetRowAt(y + this.table.scenegraph.colHeaderGroup.attribute.height);
+            const screenTop = this.resolveTargetRowInfo(y + this.table.scenegraph.colHeaderGroup.attribute.height);
             if (screenTop) {
                 this.screenTopRow = screenTop.row;
             }
@@ -55846,7 +55882,7 @@
         async setX(x, isEnd = false) {
             const xLimitLeft = this.table.getColsWidth(this.bodyLeftCol, this.bodyLeftCol + (this.colEnd - this.colStart + 1)) / 2;
             const xLimitRight = this.table.getAllColsWidth() - xLimitLeft;
-            const screenLeft = this.table.getTargetColAt(x + this.table.scenegraph.rowHeaderGroup.attribute.width + (this.table.getFrozenColsOffset?.() ?? 0));
+            const screenLeft = this.resolveTargetColInfo(x + this.table.scenegraph.rowHeaderGroup.attribute.width + (this.table.getFrozenColsOffset?.() ?? 0));
             if (screenLeft) {
                 this.screenLeftCol = screenLeft.col;
             }
@@ -55874,6 +55910,26 @@
         async dynamicSetX(x, screenLeft, isEnd = false) {
             dynamicSetX(x, screenLeft, isEnd, this);
         }
+        resolveTargetColInfo(absoluteX) {
+            const offsets = [0, -1, 1, -2, 2];
+            for (let i = 0; i < offsets.length; i++) {
+                const screenLeft = this.table.getTargetColAt(absoluteX + offsets[i]);
+                if (screenLeft) {
+                    return screenLeft;
+                }
+            }
+            return null;
+        }
+        resolveTargetRowInfo(absoluteY) {
+            const offsets = [0, -1, 1, -2, 2];
+            for (let i = 0; i < offsets.length; i++) {
+                const screenTop = this.table.getTargetRowAt(absoluteY + offsets[i]);
+                if (screenTop) {
+                    return screenTop;
+                }
+            }
+            return null;
+        }
         updateBody(y) {
             this.table.scenegraph.setBodyAndRowHeaderY(-y);
         }
@@ -57504,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) => {
@@ -57531,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) => {
@@ -60022,8 +60082,13 @@
             this.table.scenegraph.proxy.setY(-y, isEnd);
         }
         setBodyAndRowHeaderY(y) {
-            const firstBodyCell = this.bodyGroup.firstChild?.firstChild ?? this.rowHeaderGroup.firstChild?.firstChild;
-            const lastBodyCell = this.bodyGroup.firstChild?.lastChild ?? this.rowHeaderGroup.firstChild?.lastChild;
+            const firstBodyColGroup = this.bodyGroup.firstChild;
+            const firstRowHeaderColGroup = this.rowHeaderGroup.firstChild;
+            const firstBodyCell = firstBodyColGroup?.firstChild ?? firstRowHeaderColGroup?.firstChild;
+            let lastBodyCell = (firstBodyColGroup?.lastChild ?? firstRowHeaderColGroup?.lastChild);
+            if (lastBodyCell && lastBodyCell.type !== 'group') {
+                lastBodyCell = lastBodyCell._prev;
+            }
             if (y === 0 &&
                 firstBodyCell &&
                 firstBodyCell.row === this.table.frozenRowCount &&
@@ -60067,7 +60132,10 @@
         }
         setBodyAndColHeaderX(x) {
             const firstBodyCol = this.bodyGroup.firstChild;
-            const lastBodyCol = this.bodyGroup.lastChild;
+            let lastBodyCol = this.bodyGroup.lastChild;
+            if (lastBodyCol && lastBodyCol.type !== 'group') {
+                lastBodyCol = lastBodyCol._prev;
+            }
             if (x === 0 && firstBodyCol && firstBodyCol.col === this.table.frozenColCount && firstBodyCol.attribute.x + x < 0) {
                 x = -firstBodyCol.attribute.x;
             }
@@ -60083,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;
             }
@@ -60198,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);
@@ -61280,6 +61357,8 @@
                 if (!enableShiftSelectMode) {
                     currentRange.end = currentRange.start;
                 }
+                cellPos.col = col;
+                cellPos.row = row;
                 scenegraph.deleteLastSelectedRangeComponents();
                 scenegraph.updateCellSelectBorder(currentRange);
             }
@@ -63964,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;
@@ -64078,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);
@@ -65360,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);
                 }
@@ -65398,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 &&
@@ -65892,6 +65969,9 @@
         });
     }
     function dblclickHandler(e, table) {
+        if (typeof e.button === 'number' && e.button !== 0) {
+            return;
+        }
         const eventArgsSet = getCellEventArgsSetWithTable(e, table);
         let col = -1;
         let row = -1;
@@ -66253,6 +66333,18 @@
         const table = eventManager.table;
         const stateManager = table.stateManager;
         const handler = table.internalProps.handler;
+        const focusEditingInput = () => {
+            table.editorManager?.editingEditor?.getInputElement?.()?.focus?.();
+        };
+        const afterCompleteEdit = (completeEditResult, onSuccess) => {
+            getPromiseValue(completeEditResult, (isCompleteEdit) => {
+                if (isCompleteEdit === false) {
+                    focusEditingInput();
+                    return;
+                }
+                onSuccess();
+            });
+        };
         handler.on(table.getElement(), 'blur', (e) => {
             const relatedTarget = e.relatedTarget;
             if (relatedTarget) {
@@ -66355,15 +66447,17 @@
                     return;
                 }
                 const isEditingCell = !!table.editorManager?.editingEditor;
-                table.editorManager?.completeEdit();
-                table.getElement().focus();
-                const enableShiftSelectMode = table.options.keyboardOptions?.shiftMultiSelect ?? true;
-                table.selectCell(targetCol, targetRow, e.shiftKey && enableShiftSelectMode);
-                if ((table.options.keyboardOptions?.moveEditCellOnArrowKeys ?? false) && isEditingCell) {
-                    if (table.getEditor(targetCol, targetRow)) {
-                        table.editorManager?.startEditCell(targetCol, targetRow);
+                const completeEditResult = table.editorManager?.completeEdit();
+                afterCompleteEdit(completeEditResult, () => {
+                    table.getElement().focus();
+                    const enableShiftSelectMode = table.options.keyboardOptions?.shiftMultiSelect ?? true;
+                    table.selectCell(targetCol, targetRow, e.shiftKey && enableShiftSelectMode);
+                    if ((table.options.keyboardOptions?.moveEditCellOnArrowKeys ?? false) && isEditingCell) {
+                        if (table.getEditor(targetCol, targetRow)) {
+                            table.editorManager?.startEditCell(targetCol, targetRow);
+                        }
                     }
-                }
+                });
             }
             else if (e.key === 'Escape') {
                 table.editorManager?.cancelEdit();
@@ -66372,17 +66466,19 @@
             else if (e.key === 'Enter') {
                 if (table.editorManager?.editingEditor) {
                     handleKeydownListener(e);
-                    table.editorManager?.completeEdit();
-                    table.getElement().focus();
-                    if (table.options.keyboardOptions?.moveFocusCellOnEnter === true) {
-                        const targetCol = stateManager.select.cellPos.col;
-                        const targetRow = Math.min(table.rowCount - 1, Math.max(0, stateManager.select.cellPos.row + 1));
-                        if (isCellDisableSelect(table, targetCol, targetRow)) {
-                            return;
+                    const completeEditResult = table.editorManager?.completeEdit();
+                    afterCompleteEdit(completeEditResult, () => {
+                        table.getElement().focus();
+                        if (table.options.keyboardOptions?.moveFocusCellOnEnter === true) {
+                            const targetCol = stateManager.select.cellPos.col;
+                            const targetRow = Math.min(table.rowCount - 1, Math.max(0, stateManager.select.cellPos.row + 1));
+                            if (isCellDisableSelect(table, targetCol, targetRow)) {
+                                return;
+                            }
+                            const enableShiftSelectMode = table.options.keyboardOptions?.shiftMultiSelect ?? true;
+                            table.selectCell(targetCol, targetRow, e.shiftKey && enableShiftSelectMode);
                         }
-                        const enableShiftSelectMode = table.options.keyboardOptions?.shiftMultiSelect ?? true;
-                        table.selectCell(targetCol, targetRow, e.shiftKey && enableShiftSelectMode);
-                    }
+                    });
                     return;
                 }
                 if (table.options.keyboardOptions?.moveFocusCellOnEnter === true) {
@@ -66430,14 +66526,16 @@
                             return;
                         }
                         const isEditingCell = !!table.editorManager?.editingEditor;
-                        table.editorManager?.completeEdit();
-                        table.getElement().focus();
-                        table.selectCell(targetCol, targetRow);
-                        if (isEditingCell) {
-                            if (table.getEditor(targetCol, targetRow)) {
-                                table.editorManager?.startEditCell(targetCol, targetRow);
+                        const completeEditResult = table.editorManager?.completeEdit();
+                        afterCompleteEdit(completeEditResult, () => {
+                            table.getElement().focus();
+                            table.selectCell(targetCol, targetRow);
+                            if (isEditingCell) {
+                                if (table.getEditor(targetCol, targetRow)) {
+                                    table.editorManager?.startEditCell(targetCol, targetRow);
+                                }
                             }
-                        }
+                        });
                     }
                 }
             }
@@ -67623,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;
@@ -72225,7 +72326,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "1.0.35";
+        version = "1.0.37";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -73755,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
@@ -73775,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;
@@ -75642,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) {
@@ -78089,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) {
@@ -78097,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;
@@ -78135,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 {
@@ -80523,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);
@@ -84768,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);
             });
@@ -84789,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);
             });
@@ -84809,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);
     };
@@ -94282,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;
@@ -94298,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);
@@ -94319,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;
@@ -96800,7 +96992,7 @@
     }
 
     registerForVrender();
-    const version = "1.0.35";
+    const version = "1.0.37";
     function getIcons() {
         return get$2();
     }