@visactor/vtable 1.26.0 → 1.26.1

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++;
                     }
                 }
@@ -54359,6 +54387,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;
@@ -54669,6 +54700,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;
@@ -55583,7 +55617,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;
             }
@@ -55611,7 +55645,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;
             }
@@ -55639,6 +55673,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);
         }
@@ -59763,8 +59817,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 &&
@@ -59808,7 +59867,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;
             }
@@ -65601,6 +65663,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;
@@ -65962,6 +66027,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) {
@@ -66064,15 +66141,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();
@@ -66081,17 +66160,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) {
@@ -66139,14 +66220,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);
+                                }
                             }
-                        }
+                        });
                     }
                 }
             }
@@ -71934,7 +72017,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "1.26.0";
+        version = "1.26.1";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -93681,6 +93764,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
@@ -93697,19 +93781,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() {
@@ -93824,6 +93947,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)) {
@@ -96410,7 +96590,7 @@
     }
 
     registerForVrender();
-    const version = "1.26.0";
+    const version = "1.26.1";
     function getIcons() {
         return get$2();
     }