@visactor/vtable 1.26.0 → 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++;
                     }
                 }
@@ -71934,7 +71962,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "1.26.0";
+        version = "1.26.1-alpha.0";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -93681,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
@@ -93697,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() {
@@ -93824,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)) {
@@ -96410,7 +96535,7 @@
     }
 
     registerForVrender();
-    const version = "1.26.0";
+    const version = "1.26.1-alpha.0";
     function getIcons() {
         return get$2();
     }