k-vtable 1.0.34 → 1.0.35

package/es/PivotTable.d.ts

@@ -52,6 +52,7 @@ export declare class PivotTable extends BaseTable implements PivotTableAPI {
     getCellRawRecord(col: number, row: number): any;
     updateSortRules(sortRules: SortRules, col?: number, row?: number): void;
     _changePivotSortStateBySortRules(): void;
+    _filterHideIndicatorNode(): void;
     updatePivotSortState(pivotSortStateConfig: {
         dimensions: IDimensionInfo[];
         order: SortOrder;

package/es/PivotTable.js

@@ -500,7 +500,8 @@ export class PivotTable extends BaseTable {
     updateSortRules(sortRules, col, row) {
         this.internalProps.dataConfig ? this.internalProps.dataConfig.sortRules = sortRules : this.internalProps.dataConfig = {
             sortRules: sortRules
-        }, this.dataset.updateSortRules(sortRules), this._changePivotSortStateBySortRules();
+        }, this.dataset.updateSortRules(sortRules), this._changePivotSortStateBySortRules(), 
+        this._filterHideIndicatorNode();
         const {layoutMap: layoutMap} = this.internalProps;
         layoutMap.resetHeaderTree(), this.scenegraph.clearCells(), isNumber(col) && isNumber(row) ? (this.isRowHeader(col, row) ? (this.setMinMaxLimitWidth(!0), 
         this.internalProps._widthResizedColMap.clear()) : this.isCornerHeader(col, row) ? "column" === layoutMap.cornerSetting.titleOnDimension ? (this.setMinMaxLimitWidth(!0), 
@@ -513,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],
@@ -522,19 +523,53 @@ 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() {
+        const options = this.options;
+        !1 !== options.indicatorsAsCol && options.indicators && this.dataset.colHeaderTree && deleteHideIndicatorNode(this.dataset.colHeaderTree, options.indicators, !1, this), 
+        !1 === options.indicatorsAsCol && this.dataset.rowHeaderTree && options.indicators && deleteHideIndicatorNode(this.dataset.rowHeaderTree, options.indicators, !1, this);
+    }
     updatePivotSortState(pivotSortStateConfig) {
         this.pivotSortState = pivotSortStateConfig;
     }
@@ -588,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;
         }
     }
@@ -699,7 +777,7 @@ export class PivotTable extends BaseTable {
     }
     setRecords(records) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-        clearChartRenderQueue();
+        this.stateManager.endResizeIfResizing(), clearChartRenderQueue();
         const oldHoverState = {
             col: this.stateManager.hover.cellPos.col,
             row: this.stateManager.hover.cellPos.row
@@ -957,7 +1035,7 @@ export class PivotTable extends BaseTable {
     }
     updateFilterRules(filterRules, isResetTree = !1) {
         this.internalProps.dataConfig.filterRules = filterRules, isResetTree ? (this.dataset.updateFilterRules(filterRules, !0), 
-        this.internalProps.layoutMap.resetHeaderTree()) : this.dataset.updateFilterRules(filterRules), 
+        this._filterHideIndicatorNode(), this.internalProps.layoutMap.resetHeaderTree()) : this.dataset.updateFilterRules(filterRules), 
         this.renderWithRecreateCells();
     }
     getFilteredRecords() {