@visactor/vtable 1.25.1-alpha.1 → 1.26.1-alpha.0

package/dist/vtable.js

@@ -1789,6 +1789,20 @@
     function crossProduct(dir1, dir2) {
       return dir1[0] * dir2[1] - dir1[1] * dir2[0];
     }
+    function fixPrecision$1(num, precision = 10) {
+      return Math.round(num * precision) / precision;
+    }
+    function getDecimalPlaces(n) {
+      const dStr = n.toString().split(/[eE]/),
+        s = (dStr[0].split(".")[1] || "").length - (+dStr[1] || 0);
+      return s > 0 ? s : 0;
+    }
+    function precisionAdd(a, b) {
+      return fixPrecision$1(a + b, 10 ** Math.max(getDecimalPlaces(a), getDecimalPlaces(b)));
+    }
+    function precisionSub(a, b) {
+      return fixPrecision$1(a - b, 10 ** Math.max(getDecimalPlaces(a), getDecimalPlaces(b)));
+    }
 
     class Point {
       constructor(x = 0, y = 0, x1, y1) {
@@ -34217,25 +34231,25 @@
                 if (record.isAggregator && this.children) {
                     this.children.push(record);
                     const value = record.value();
-                    this.sum += value ?? 0;
+                    this.sum = precisionAdd(this.sum, value ?? 0);
                     if (this.needSplitPositiveAndNegativeForSum) {
                         if (value > 0) {
-                            this.positiveSum += value;
+                            this.positiveSum = precisionAdd(this.positiveSum, value);
                         }
                         else if (value < 0) {
-                            this.nagetiveSum += value;
+                            this.nagetiveSum = precisionAdd(this.nagetiveSum, value);
                         }
                     }
                 }
                 else if (this.field && !isNaN(parseFloat(record[this.field]))) {
                     const value = parseFloat(record[this.field]);
-                    this.sum += value;
+                    this.sum = precisionAdd(this.sum, value);
                     if (this.needSplitPositiveAndNegativeForSum) {
                         if (value > 0) {
-                            this.positiveSum += value;
+                            this.positiveSum = precisionAdd(this.positiveSum, value);
                         }
                         else if (value < 0) {
-                            this.nagetiveSum += value;
+                            this.nagetiveSum = precisionAdd(this.nagetiveSum, value);
                         }
                     }
                 }
@@ -34245,30 +34259,36 @@
         deleteRecord(record) {
             if (record) {
                 if (this.isRecord && this.records) {
-                    this.records = this.records.filter(item => item !== record);
+                    const index = this.records.indexOf(record);
+                    if (index !== -1) {
+                        this.records.splice(index, 1);
+                    }
                 }
                 if (record.isAggregator && this.children) {
-                    this.children = this.children.filter(item => item !== record);
+                    const index = this.children.indexOf(record);
+                    if (index !== -1) {
+                        this.children.splice(index, 1);
+                    }
                     const value = record.value();
-                    this.sum -= value ?? 0;
+                    this.sum = precisionSub(this.sum, value ?? 0);
                     if (this.needSplitPositiveAndNegativeForSum) {
                         if (value > 0) {
-                            this.positiveSum -= value;
+                            this.positiveSum = precisionSub(this.positiveSum, value);
                         }
                         else if (value < 0) {
-                            this.nagetiveSum -= value;
+                            this.nagetiveSum = precisionSub(this.nagetiveSum, value);
                         }
                     }
                 }
                 else if (this.field && !isNaN(parseFloat(record[this.field]))) {
                     const value = parseFloat(record[this.field]);
-                    this.sum -= value;
+                    this.sum = precisionSub(this.sum, value);
                     if (this.needSplitPositiveAndNegativeForSum) {
                         if (value > 0) {
-                            this.positiveSum -= value;
+                            this.positiveSum = precisionSub(this.positiveSum, value);
                         }
                         else if (value < 0) {
-                            this.nagetiveSum -= value;
+                            this.nagetiveSum = precisionSub(this.nagetiveSum, value);
                         }
                     }
                 }
@@ -34278,50 +34298,50 @@
         updateRecord(oldRecord, newRecord) {
             if (oldRecord && newRecord) {
                 if (this.isRecord && this.records) {
-                    this.records = this.records.map(item => {
-                        if (item === oldRecord) {
-                            return newRecord;
-                        }
-                        return item;
-                    });
+                    const index = this.records.indexOf(oldRecord);
+                    if (index !== -1) {
+                        this.records[index] = newRecord;
+                    }
                 }
                 if (oldRecord.isAggregator && this.children) {
                     const oldValue = oldRecord.value();
-                    this.children = this.children.filter(item => item !== oldRecord);
+                    const index = this.children.indexOf(oldRecord);
+                    if (index !== -1) {
+                        this.children[index] = newRecord;
+                    }
                     const newValue = newRecord.value();
-                    this.children.push(newRecord);
-                    this.sum += newValue - oldValue;
+                    this.sum = precisionAdd(this.sum, precisionSub(newValue, oldValue));
                     if (this.needSplitPositiveAndNegativeForSum) {
                         if (oldValue > 0) {
-                            this.positiveSum -= oldValue;
+                            this.positiveSum = precisionSub(this.positiveSum, oldValue);
                         }
                         else if (oldValue < 0) {
-                            this.nagetiveSum -= oldValue;
+                            this.nagetiveSum = precisionSub(this.nagetiveSum, oldValue);
                         }
                         if (newValue > 0) {
-                            this.positiveSum += newValue;
+                            this.positiveSum = precisionAdd(this.positiveSum, newValue);
                         }
                         else if (newValue < 0) {
-                            this.nagetiveSum += newValue;
+                            this.nagetiveSum = precisionAdd(this.nagetiveSum, newValue);
                         }
                     }
                 }
                 else if (this.field && !isNaN(parseFloat(oldRecord[this.field]))) {
                     const oldValue = parseFloat(oldRecord[this.field]);
                     const newValue = parseFloat(newRecord[this.field]);
-                    this.sum += newValue - oldValue;
+                    this.sum = precisionAdd(this.sum, precisionSub(newValue, oldValue));
                     if (this.needSplitPositiveAndNegativeForSum) {
                         if (oldValue > 0) {
-                            this.positiveSum -= oldValue;
+                            this.positiveSum = precisionSub(this.positiveSum, oldValue);
                         }
                         else if (oldValue < 0) {
-                            this.nagetiveSum -= oldValue;
+                            this.nagetiveSum = precisionSub(this.nagetiveSum, oldValue);
                         }
                         if (newValue > 0) {
-                            this.positiveSum += newValue;
+                            this.positiveSum = precisionAdd(this.positiveSum, newValue);
                         }
                         else if (newValue < 0) {
-                            this.nagetiveSum += newValue;
+                            this.nagetiveSum = precisionAdd(this.nagetiveSum, newValue);
                         }
                     }
                 }
@@ -34329,7 +34349,8 @@
             }
         }
         value() {
-            return this.changedValue ?? (this.records?.length >= 1 ? this.sum : undefined);
+            return (this.changedValue ??
+                (this.records && this.records.length >= 1 ? this.sum : this.isRecord === false ? this.sum : undefined));
         }
         positiveValue() {
             return this.positiveSum;
@@ -34350,13 +34371,13 @@
                     const child = this.children[i];
                     if (child.isAggregator) {
                         const value = child.value();
-                        this.sum += value ?? 0;
+                        this.sum = precisionAdd(this.sum, value ?? 0);
                         if (this.needSplitPositiveAndNegativeForSum) {
                             if (value > 0) {
-                                this.positiveSum += value;
+                                this.positiveSum = precisionAdd(this.positiveSum, value);
                             }
                             else if (value < 0) {
-                                this.nagetiveSum += value;
+                                this.nagetiveSum = precisionAdd(this.nagetiveSum, value);
                             }
                         }
                     }
@@ -34367,25 +34388,25 @@
                     const record = this.records[i];
                     if (record.isAggregator) {
                         const value = record.value();
-                        this.sum += value ?? 0;
+                        this.sum = precisionAdd(this.sum, value ?? 0);
                         if (this.needSplitPositiveAndNegativeForSum) {
                             if (value > 0) {
-                                this.positiveSum += value;
+                                this.positiveSum = precisionAdd(this.positiveSum, value);
                             }
                             else if (value < 0) {
-                                this.nagetiveSum += value;
+                                this.nagetiveSum = precisionAdd(this.nagetiveSum, value);
                             }
                         }
                     }
                     else if (this.field && !isNaN(parseFloat(record[this.field]))) {
                         const value = parseFloat(record[this.field]);
-                        this.sum += value;
+                        this.sum = precisionAdd(this.sum, value);
                         if (this.needSplitPositiveAndNegativeForSum) {
                             if (value > 0) {
-                                this.positiveSum += value;
+                                this.positiveSum = precisionAdd(this.positiveSum, value);
                             }
                             else if (value < 0) {
-                                this.nagetiveSum += value;
+                                this.nagetiveSum = precisionAdd(this.nagetiveSum, value);
                             }
                         }
                     }
@@ -34513,11 +34534,11 @@
                     if (this.children) {
                         this.children.push(record);
                     }
-                    this.sum += record.sum;
+                    this.sum = precisionAdd(this.sum, record.sum);
                     this.count += record.count;
                 }
                 else if (this.field && !isNaN(parseFloat(record[this.field]))) {
-                    this.sum += parseFloat(record[this.field]);
+                    this.sum = precisionAdd(this.sum, parseFloat(record[this.field]));
                     this.count++;
                 }
             }
@@ -34526,17 +34547,23 @@
         deleteRecord(record) {
             if (record) {
                 if (this.isRecord && this.records) {
-                    this.records = this.records.filter(item => item !== record);
+                    const index = this.records.indexOf(record);
+                    if (index !== -1) {
+                        this.records.splice(index, 1);
+                    }
                 }
                 if (record.isAggregator && record.type === AggregationType.AVG) {
                     if (this.children) {
-                        this.children = this.children.filter(item => item !== record);
+                        const index = this.children.indexOf(record);
+                        if (index !== -1) {
+                            this.children.splice(index, 1);
+                        }
                     }
-                    this.sum -= record.sum;
+                    this.sum = precisionSub(this.sum, record.sum);
                     this.count -= record.count;
                 }
                 else if (this.field && !isNaN(parseFloat(record[this.field]))) {
-                    this.sum -= parseFloat(record[this.field]);
+                    this.sum = precisionSub(this.sum, parseFloat(record[this.field]));
                     this.count--;
                 }
             }
@@ -34545,33 +34572,34 @@
         updateRecord(oldRecord, newRecord) {
             if (oldRecord && newRecord) {
                 if (this.isRecord && this.records) {
-                    this.records = this.records.map(item => {
-                        if (item === oldRecord) {
-                            return newRecord;
-                        }
-                        return item;
-                    });
+                    const index = this.records.indexOf(oldRecord);
+                    if (index !== -1) {
+                        this.records[index] = newRecord;
+                    }
                 }
                 if (oldRecord.isAggregator && oldRecord.type === AggregationType.AVG) {
                     if (this.children && newRecord.isAggregator) {
-                        this.children = this.children.map(item => {
-                            if (item === oldRecord) {
-                                return newRecord;
-                            }
-                            return item;
-                        });
+                        const index = this.children.indexOf(oldRecord);
+                        if (index !== -1) {
+                            this.children[index] = newRecord;
+                        }
                     }
-                    this.sum += newRecord.sum - oldRecord.sum;
+                    this.sum = precisionAdd(this.sum, precisionSub(newRecord.sum, oldRecord.sum));
                     this.count += newRecord.count - oldRecord.count;
                 }
                 else if (this.field && !isNaN(parseFloat(oldRecord[this.field]))) {
-                    this.sum += parseFloat(newRecord[this.field]) - parseFloat(oldRecord[this.field]);
+                    this.sum = precisionAdd(this.sum, precisionSub(parseFloat(newRecord[this.field]), parseFloat(oldRecord[this.field])));
                 }
                 this.clearCacheValue();
             }
         }
         value() {
-            return this.changedValue ?? (this.records?.length >= 1 ? this.sum / this.count : undefined);
+            return (this.changedValue ??
+                (this.records && this.records.length >= 1
+                    ? this.sum / this.count
+                    : this.isRecord === false && this.count > 0
+                        ? this.sum / this.count
+                        : undefined));
         }
         reset() {
             this.changedValue = undefined;
@@ -34589,7 +34617,7 @@
                     const child = this.children[i];
                     if (child.isAggregator && child.type === AggregationType.AVG) {
                         const childValue = child.value();
-                        this.sum += childValue * child.count;
+                        this.sum = precisionAdd(this.sum, childValue * child.count);
                         this.count += child.count;
                     }
                 }
@@ -34598,11 +34626,11 @@
                 for (let i = 0; i < this.records.length; i++) {
                     const record = this.records[i];
                     if (record.isAggregator && record.type === AggregationType.AVG) {
-                        this.sum += record.sum;
+                        this.sum = precisionAdd(this.sum, record.sum);
                         this.count += record.count;
                     }
                     else if (this.field && !isNaN(parseFloat(record[this.field]))) {
-                        this.sum += parseFloat(record[this.field]);
+                        this.sum = precisionAdd(this.sum, parseFloat(record[this.field]));
                         this.count++;
                     }
                 }
@@ -45727,8 +45755,7 @@
         }
         else if (type === 'checkbox') {
             const isAggregation = 'isAggregation' in table.internalProps.layoutMap && table.internalProps.layoutMap.isAggregation(col, row);
-            const isSeriesNumber = table.internalProps.layoutMap.isSeriesNumber(col, row);
-            if (isAggregation && isSeriesNumber) {
+            if (isAggregation) {
                 const createTextCellGroup = Factory.getFunction('createTextCellGroup');
                 cellGroup = createTextCellGroup(table, value, columnGroup, 0, y, col, row, colWidth, cellWidth, cellHeight, padding, textAlign, textBaseline, false, undefined, true, cellTheme, range, isAsync);
             }
@@ -45738,8 +45765,15 @@
             }
         }
         else if (type === 'radio') {
-            const createRadioCellGroup = Factory.getFunction('createRadioCellGroup');
-            cellGroup = createRadioCellGroup(null, columnGroup, 0, y, col, row, colWidth, cellWidth, cellHeight, padding, textAlign, textBaseline, table, cellTheme, define, range);
+            const isAggregation = 'isAggregation' in table.internalProps.layoutMap && table.internalProps.layoutMap.isAggregation(col, row);
+            if (isAggregation) {
+                const createTextCellGroup = Factory.getFunction('createTextCellGroup');
+                cellGroup = createTextCellGroup(table, value, columnGroup, 0, y, col, row, colWidth, cellWidth, cellHeight, padding, textAlign, textBaseline, false, undefined, true, cellTheme, range, isAsync);
+            }
+            else {
+                const createRadioCellGroup = Factory.getFunction('createRadioCellGroup');
+                cellGroup = createRadioCellGroup(null, columnGroup, 0, y, col, row, colWidth, cellWidth, cellHeight, padding, textAlign, textBaseline, table, cellTheme, define, range);
+            }
         }
         else if (type === 'switch') {
             const createSwitchCellGroup = Factory.getFunction('createSwitchCellGroup');
@@ -61176,6 +61210,10 @@
         }
         else if ((interactionState === InteractionState.grabing || table.eventManager.isDraging) &&
             !table.stateManager.isResizeCol()) {
+            if (col >= 0 && row >= 0 && isCellDisableSelect(table, col, row)) {
+                scenegraph.updateNextFrame();
+                return;
+            }
             let extendSelectRange = isValid$1(skipBodyMerge) ? !skipBodyMerge : true;
             if (cellPos.col === -1) {
                 cellPos.col = col;
@@ -62917,7 +62955,21 @@
             this.setSelectState();
             this.setFrozenState();
         }
+        endResizeIfResizing() {
+            if (this.columnResize.resizing) {
+                this.table.scenegraph.component.hideResizeCol();
+                this.columnResize.resizing = false;
+            }
+            if (this.rowResize.resizing) {
+                this.table.scenegraph.component.hideResizeRow();
+                this.rowResize.resizing = false;
+            }
+            if (this.interactionState === InteractionState.grabing) {
+                this.interactionState = InteractionState.default;
+            }
+        }
         _updateOptionSetState() {
+            this.endResizeIfResizing();
             this.interactionState = InteractionState.default;
             this.hoverIcon = {
                 col: -1,
@@ -64883,12 +64935,14 @@
                 stateManager.updateInteractionState(InteractionState.default);
                 stateManager.updateCursor();
             }
-            if ((table.theme.scrollStyle.horizontalVisible && table.theme.scrollStyle.horizontalVisible === 'focus') ||
-                (!table.theme.scrollStyle.horizontalVisible && table.theme.scrollStyle.visible === 'focus')) {
+            const scrollStyle = table.theme.scrollStyle;
+            const horizontalVisible = scrollStyle?.horizontalVisible ?? scrollStyle?.visible;
+            const verticalVisible = scrollStyle?.verticalVisible ?? scrollStyle?.visible;
+            const barToSide = scrollStyle?.barToSide ?? false;
+            if (!barToSide && horizontalVisible === 'focus') {
                 stateManager.hideHorizontalScrollBar();
             }
-            if ((table.theme.scrollStyle.verticalVisible && table.theme.scrollStyle.verticalVisible === 'focus') ||
-                (!table.theme.scrollStyle.verticalVisible && table.theme.scrollStyle.visible === 'focus')) {
+            if (!barToSide && verticalVisible === 'focus') {
                 stateManager.hideVerticalScrollBar();
             }
             if (table.hasListeners(TABLE_EVENT_TYPE.MOUSELEAVE_CELL)) {
@@ -65304,6 +65358,52 @@
                 stateManager.endSelectCells();
             }
         });
+        const scrollStyle = table.theme.scrollStyle;
+        const barToSide = scrollStyle?.barToSide ?? false;
+        const horizontalVisible = scrollStyle?.horizontalVisible ?? scrollStyle?.visible;
+        const verticalVisible = scrollStyle?.verticalVisible ?? scrollStyle?.visible;
+        const shouldShowScrollOnCanvasHover = barToSide && horizontalVisible === 'focus';
+        const shouldShowVScrollOnCanvasHover = barToSide && verticalVisible === 'focus';
+        if (shouldShowScrollOnCanvasHover || shouldShowVScrollOnCanvasHover) {
+            table.scenegraph.stage.addEventListener('pointerenter', (e) => {
+                const target = e.target;
+                const isEventFromCurrentTableCanvas = target === table.scenegraph.stage || target?.isDescendantsOf?.(table.scenegraph.stage);
+                if (!isEventFromCurrentTableCanvas) {
+                    return;
+                }
+                if (shouldShowScrollOnCanvasHover) {
+                    const relativeX = e.x - table.tableX;
+                    const target = table.options.scrollFrozenCols &&
+                        table.getFrozenColsOffset?.() > 0 &&
+                        relativeX >= 0 &&
+                        relativeX < table.getFrozenColsWidth()
+                        ? 'frozen'
+                        : table.options.scrollRightFrozenCols &&
+                            table.getRightFrozenColsOffset?.() > 0 &&
+                            relativeX > table.tableNoFrameWidth - table.getRightFrozenColsWidth()
+                            ? 'rightFrozen'
+                            : 'body';
+                    stateManager.showHorizontalScrollBar(false, target);
+                }
+                if (shouldShowVScrollOnCanvasHover) {
+                    stateManager.showVerticalScrollBar();
+                }
+            });
+            table.scenegraph.stage.addEventListener('pointerleave', (e) => {
+                const relatedTarget = e.relatedTarget;
+                const isLeavingCanvas = !relatedTarget ||
+                    (relatedTarget !== table.scenegraph.stage && !relatedTarget.isDescendantsOf?.(table.scenegraph.stage));
+                if (!isLeavingCanvas) {
+                    return;
+                }
+                if (shouldShowScrollOnCanvasHover) {
+                    stateManager.hideHorizontalScrollBar();
+                }
+                if (shouldShowVScrollOnCanvasHover) {
+                    stateManager.hideVerticalScrollBar();
+                }
+            });
+        }
         table.scenegraph.stage.addEventListener('pointermove', (e) => {
             const eventArgsSet = getCellEventArgsSetWithTable(e, table);
             const isEventFromCurrentTable = e.target?.isDescendantsOf?.(table.scenegraph.tableGroup) ?? false;
@@ -66389,6 +66489,9 @@
                         const targetCol = table.getTargetColAtConsiderRightFrozen(selectX, considerFrozenX);
                         const targetRow = table.getTargetRowAtConsiderBottomFrozen(selectY, considerFrozenY);
                         if (!table.options.select?.disableDragSelect && isValid$1(targetCol) && isValid$1(targetRow)) {
+                            if (isCellDisableSelect(table, targetCol.col, targetRow.row)) {
+                                return;
+                            }
                             table.stateManager.updateSelectPos(table.stateManager.select.selectInline === 'row' ? table.colCount - 1 : targetCol.col, table.stateManager.select.selectInline === 'col' ? table.rowCount - 1 : targetRow.row, false, false, false, false);
                         }
                     });
@@ -69627,6 +69730,8 @@
                     return TextHeaderStyle;
                 case 'checkbox':
                     return CheckboxStyle;
+                default:
+                    return TextHeaderStyle;
             }
         }
         setTableColumnsEditor() {
@@ -71857,7 +71962,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "1.25.1-alpha.1";
+        version = "1.26.1-alpha.0";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -74206,7 +74311,8 @@
         getCellType(col, row) {
             let cellType;
             if (this.isSeriesNumberInHeader(col, row)) {
-                return this.internalProps.layoutMap.getSeriesNumberHeader(col, row).cellType;
+                const seriesHeaderCellType = this.internalProps.layoutMap.getSeriesNumberHeader(col, row).cellType;
+                return seriesHeaderCellType === 'radio' ? 'text' : seriesHeaderCellType;
             }
             else if (this.isHeader(col, row)) {
                 cellType = this.internalProps.layoutMap.getHeader(col, row).headerType;
@@ -80507,6 +80613,7 @@
             this.setCellCheckboxState(col, row, checked);
         }
         setRecords(records, option) {
+            this.stateManager.endResizeIfResizing();
             clearChartRenderQueue();
             this.internalProps.dataSource?.release();
             this.internalProps.releaseList = this.internalProps.releaseList?.filter((item) => !item.dataSourceObj);
@@ -93602,6 +93709,7 @@
             for (let i = 0; i < sortRules.length; i++) {
                 const sortRule = sortRules[i];
                 const dimensions = [];
+                const sortType = sortRule.sortType ? sortRule.sortType.toUpperCase() : 'ASC';
                 if (sortRule.sortByIndicator &&
                     sortRule.sortField ===
                         (this.dataset.indicatorsAsCol
@@ -93618,19 +93726,58 @@
                         value: this.internalProps.layoutMap.getIndicatorInfo(sortRule.sortByIndicator)?.title ??
                             sortRule.sortByIndicator
                     });
+                    this.pivotSortState.push({
+                        dimensions,
+                        order: SortType[sortType]
+                    });
                 }
                 else {
-                    dimensions.push({
-                        dimensionKey: sortRule.sortField,
-                        isPivotCorner: true,
-                        value: sortRule.sortField
-                    });
+                    const sortField = sortRule.sortField;
+                    const rowIndex = this.dataset.rows.indexOf(sortField);
+                    const colIndex = this.dataset.columns.indexOf(sortField);
+                    let pushed = false;
+                    if (rowIndex >= 0) {
+                        const rowDimensions = [];
+                        for (let k = 0; k <= rowIndex; k++) {
+                            rowDimensions.push({
+                                dimensionKey: this.dataset.rows[k],
+                                isPivotCorner: true,
+                                value: this.dataset.rows[k]
+                            });
+                        }
+                        this.pivotSortState.push({
+                            dimensions: rowDimensions,
+                            order: SortType[sortType]
+                        });
+                        pushed = true;
+                    }
+                    if (colIndex >= 0) {
+                        const colDimensions = [];
+                        for (let k = 0; k <= colIndex; k++) {
+                            colDimensions.push({
+                                dimensionKey: this.dataset.columns[k],
+                                isPivotCorner: true,
+                                value: this.dataset.columns[k]
+                            });
+                        }
+                        this.pivotSortState.push({
+                            dimensions: colDimensions,
+                            order: SortType[sortType]
+                        });
+                        pushed = true;
+                    }
+                    if (!pushed) {
+                        dimensions.push({
+                            dimensionKey: sortField,
+                            isPivotCorner: true,
+                            value: sortField
+                        });
+                        this.pivotSortState.push({
+                            dimensions,
+                            order: SortType[sortType]
+                        });
+                    }
                 }
-                const sortType = sortRule.sortType ? sortRule.sortType.toUpperCase() : 'ASC';
-                this.pivotSortState.push({
-                    dimensions,
-                    order: SortType[sortType]
-                });
             }
         }
         _filterHideIndicatorNode() {
@@ -93745,6 +93892,63 @@
             for (let i = 0; i < this.pivotSortState.length; i++) {
                 const pivotState = this.pivotSortState[i];
                 const dimensions = pivotState.dimensions;
+                if (this.isCornerHeader(col, row)) {
+                    const layoutMap = this.internalProps.layoutMap;
+                    const header = layoutMap.getHeader(col, row);
+                    if (header && header.pivotInfo && dimensions && dimensions.length > 0) {
+                        let cellPathKeys = [];
+                        const leftSnCount = layoutMap.leftRowSeriesNumberColumnCount ?? 0;
+                        if (layoutMap.cornerSetting.titleOnDimension === 'row') {
+                            const dimIndex = col - leftSnCount;
+                            cellPathKeys = layoutMap.rowDimensionKeys.slice(0, dimIndex + 1);
+                        }
+                        else if (layoutMap.cornerSetting.titleOnDimension === 'column') {
+                            const dimIndex = row;
+                            cellPathKeys = layoutMap.colDimensionKeys.slice(0, dimIndex + 1);
+                        }
+                        else if (layoutMap.cornerSetting.titleOnDimension === 'all') {
+                            if (layoutMap.indicatorsAsCol) {
+                                let indicatorAtIndex = layoutMap.colDimensionKeys.indexOf(layoutMap.indicatorDimensionKey);
+                                if (indicatorAtIndex === -1) {
+                                    indicatorAtIndex = layoutMap.columnHeaderLevelCount - 1;
+                                }
+                                if (row === indicatorAtIndex) {
+                                    const dimIndex = col - leftSnCount;
+                                    cellPathKeys = layoutMap.rowDimensionKeys.slice(0, dimIndex + 1);
+                                }
+                                else {
+                                    const dimIndex = row;
+                                    cellPathKeys = layoutMap.colDimensionKeys.slice(0, dimIndex + 1);
+                                }
+                            }
+                            else {
+                                let indicatorAtIndex = layoutMap.rowDimensionKeys.indexOf(layoutMap.indicatorDimensionKey);
+                                if (indicatorAtIndex === -1) {
+                                    indicatorAtIndex = layoutMap.rowHeaderLevelCount - 1;
+                                }
+                                if (col - leftSnCount === indicatorAtIndex) {
+                                    const dimIndex = row;
+                                    cellPathKeys = layoutMap.colDimensionKeys.slice(0, dimIndex + 1);
+                                }
+                                else {
+                                    const dimIndex = col - leftSnCount;
+                                    cellPathKeys = layoutMap.rowDimensionKeys.slice(0, dimIndex + 1);
+                                }
+                            }
+                        }
+                        if (cellPathKeys.length > 0 && dimensions.length === cellPathKeys.length) {
+                            const isMatch = dimensions.every((dim, idx) => {
+                                const isCorner = dim.isPivotCorner || (!isValid$1(dim.isPivotCorner) && dim.dimensionKey && !dim.value);
+                                const keyMatch = dim.dimensionKey === cellPathKeys[idx] || dim.value === cellPathKeys[idx];
+                                return isCorner && keyMatch;
+                            });
+                            if (isMatch) {
+                                return pivotState.order;
+                            }
+                        }
+                    }
+                    continue;
+                }
                 const cell = this.getCellAddressByHeaderPaths(dimensions);
                 const order = pivotState.order;
                 if (cell && cellInRange(cellRange, cell.col, cell.row)) {
@@ -93921,6 +94125,7 @@
             return result;
         }
         setRecords(records) {
+            this.stateManager.endResizeIfResizing();
             clearChartRenderQueue();
             const oldHoverState = { col: this.stateManager.hover.cellPos.col, row: this.stateManager.hover.cellPos.row };
             this.options.records = this.internalProps.records = records;
@@ -95647,6 +95852,7 @@
             return undefined;
         }
         setRecords(records) {
+            this.stateManager.endResizeIfResizing();
             this.internalProps.layoutMap.release();
             clearChartRenderQueue();
             this.scenegraph.updateChartState(null, undefined);
@@ -96329,7 +96535,7 @@
     }
 
     registerForVrender();
-    const version = "1.25.1-alpha.1";
+    const version = "1.26.1-alpha.0";
     function getIcons() {
         return get$2();
     }