@visactor/vtable 1.26.0 → 1.26.1-alpha.0

package/es/PivotTable.js

@@ -514,7 +514,7 @@ export class PivotTable extends BaseTable {
         this.pivotSortState = [];
         const sortRules = null !== (_b = null === (_a = this.internalProps.dataConfig) || void 0 === _a ? void 0 : _a.sortRules) && void 0 !== _b ? _b : [];
         for (let i = 0; i < sortRules.length; i++) {
-            const sortRule = sortRules[i], dimensions = [];
+            const sortRule = sortRules[i], dimensions = [], sortType = sortRule.sortType ? sortRule.sortType.toUpperCase() : "ASC";
             if (sortRule.sortByIndicator && sortRule.sortField === (this.dataset.indicatorsAsCol ? this.dataset.rows[this.dataset.rows.length - 1] : this.dataset.columns[this.dataset.columns.length - 1])) {
                 for (let j = 0; j < sortRule.query.length; j++) dimensions.push({
                     dimensionKey: this.dataset.indicatorsAsCol ? this.dataset.columns[j] : this.dataset.rows[j],
@@ -523,17 +523,46 @@ export class PivotTable extends BaseTable {
                 dimensions.push({
                     indicatorKey: sortRule.sortByIndicator,
                     value: null !== (_d = null === (_c = this.internalProps.layoutMap.getIndicatorInfo(sortRule.sortByIndicator)) || void 0 === _c ? void 0 : _c.title) && void 0 !== _d ? _d : sortRule.sortByIndicator
+                }), this.pivotSortState.push({
+                    dimensions: dimensions,
+                    order: SortType[sortType]
                 });
-            } else dimensions.push({
-                dimensionKey: sortRule.sortField,
-                isPivotCorner: !0,
-                value: sortRule.sortField
-            });
-            const sortType = sortRule.sortType ? sortRule.sortType.toUpperCase() : "ASC";
-            this.pivotSortState.push({
-                dimensions: dimensions,
-                order: SortType[sortType]
-            });
+            } else {
+                const sortField = sortRule.sortField, rowIndex = this.dataset.rows.indexOf(sortField), colIndex = this.dataset.columns.indexOf(sortField);
+                let pushed = !1;
+                if (rowIndex >= 0) {
+                    const rowDimensions = [];
+                    for (let k = 0; k <= rowIndex; k++) rowDimensions.push({
+                        dimensionKey: this.dataset.rows[k],
+                        isPivotCorner: !0,
+                        value: this.dataset.rows[k]
+                    });
+                    this.pivotSortState.push({
+                        dimensions: rowDimensions,
+                        order: SortType[sortType]
+                    }), pushed = !0;
+                }
+                if (colIndex >= 0) {
+                    const colDimensions = [];
+                    for (let k = 0; k <= colIndex; k++) colDimensions.push({
+                        dimensionKey: this.dataset.columns[k],
+                        isPivotCorner: !0,
+                        value: this.dataset.columns[k]
+                    });
+                    this.pivotSortState.push({
+                        dimensions: colDimensions,
+                        order: SortType[sortType]
+                    }), pushed = !0;
+                }
+                pushed || (dimensions.push({
+                    dimensionKey: sortField,
+                    isPivotCorner: !0,
+                    value: sortField
+                }), this.pivotSortState.push({
+                    dimensions: dimensions,
+                    order: SortType[sortType]
+                }));
+            }
         }
     }
     _filterHideIndicatorNode() {
@@ -594,10 +623,53 @@ export class PivotTable extends BaseTable {
         }
     }
     getPivotSortState(col, row) {
+        var _a;
         if (!this.pivotSortState) return;
         const cellRange = this.getCellRange(col, row);
         for (let i = 0; i < this.pivotSortState.length; i++) {
-            const pivotState = this.pivotSortState[i], dimensions = pivotState.dimensions, cell = this.getCellAddressByHeaderPaths(dimensions), order = pivotState.order;
+            const pivotState = this.pivotSortState[i], dimensions = pivotState.dimensions;
+            if (this.isCornerHeader(col, row)) {
+                const layoutMap = this.internalProps.layoutMap, header = layoutMap.getHeader(col, row);
+                if (header && header.pivotInfo && dimensions && dimensions.length > 0) {
+                    let cellPathKeys = [];
+                    const leftSnCount = null !== (_a = layoutMap.leftRowSeriesNumberColumnCount) && void 0 !== _a ? _a : 0;
+                    if ("row" === layoutMap.cornerSetting.titleOnDimension) {
+                        const dimIndex = col - leftSnCount;
+                        cellPathKeys = layoutMap.rowDimensionKeys.slice(0, dimIndex + 1);
+                    } else if ("column" === layoutMap.cornerSetting.titleOnDimension) {
+                        const dimIndex = row;
+                        cellPathKeys = layoutMap.colDimensionKeys.slice(0, dimIndex + 1);
+                    } else if ("all" === layoutMap.cornerSetting.titleOnDimension) if (layoutMap.indicatorsAsCol) {
+                        let indicatorAtIndex = layoutMap.colDimensionKeys.indexOf(layoutMap.indicatorDimensionKey);
+                        if (-1 === indicatorAtIndex && (indicatorAtIndex = layoutMap.columnHeaderLevelCount - 1), 
+                        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 (-1 === indicatorAtIndex && (indicatorAtIndex = layoutMap.rowHeaderLevelCount - 1), 
+                        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) {
+                        if (dimensions.every(((dim, idx) => {
+                            const isCorner = dim.isPivotCorner || !isValid(dim.isPivotCorner) && dim.dimensionKey && !dim.value, keyMatch = dim.dimensionKey === cellPathKeys[idx] || dim.value === cellPathKeys[idx];
+                            return isCorner && keyMatch;
+                        }))) return pivotState.order;
+                    }
+                }
+                continue;
+            }
+            const cell = this.getCellAddressByHeaderPaths(dimensions), order = pivotState.order;
             if (cell && cellInRange(cellRange, cell.col, cell.row)) return order;
         }
     }