@visactor/vtable 1.2.1-alpha.2 → 1.3.0

package/es/PivotTable.d.ts

@@ -1,4 +1,4 @@
-import type { FieldData, FieldDef, PivotTableAPI, SortRules, PivotSortState, CellAddress, ICellHeaderPaths, DropDownMenuEventInfo, FieldKeyDef, PivotTableConstructorOptions, IHeaderTreeDefine, IDimensionInfo, SortOrder, IPagination, CellLocation } from './ts-types';
+import type { FieldData, FieldDef, PivotTableAPI, SortRules, CellAddress, ICellHeaderPaths, DropDownMenuEventInfo, FieldKeyDef, PivotTableConstructorOptions, IHeaderTreeDefine, IDimensionInfo, SortOrder, IPagination, CellLocation } from './ts-types';
 import { HierarchyState } from './ts-types';
 import { FlatDataToObjects } from './dataset/flatDataToObject';
 import { PIVOT_TABLE_EVENT_TYPE } from './ts-types/pivot-table/PIVOT_TABLE_EVENT_TYPE';
@@ -14,7 +14,10 @@ export declare class PivotTable extends BaseTable implements PivotTableAPI {
     };
     internalProps: PivotTableProtected;
     options: PivotTableConstructorOptions;
-    pivotSortState: PivotSortState[];
+    pivotSortState: {
+        dimensions: IDimensionInfo[];
+        order: SortOrder;
+    }[];
     editorManager: EditManeger;
     dataset?: Dataset;
     flatDataToObjects?: FlatDataToObjects;
@@ -46,10 +49,12 @@ export declare class PivotTable extends BaseTable implements PivotTableAPI {
     getCellOriginRecord(col: number, row: number): any;
     getCellRawRecord(col: number, row: number): any;
     updateSortRules(sortRules: SortRules): void;
+    _changePivotSortStateBySortRules(): void;
     updatePivotSortState(pivotSortStateConfig: {
         dimensions: IDimensionInfo[];
         order: SortOrder;
     }[]): void;
+    sort(col: number, row: number, order: SortOrder): void;
     getPivotSortState(col: number, row: number): SortOrder;
     _moveHeaderPosition(source: CellAddress, target: CellAddress): {
         sourceIndex: number;

package/es/PivotTable.js

@@ -1,4 +1,4 @@
-import { HierarchyState } from "./ts-types";
+import { HierarchyState, SortType } from "./ts-types";
 
 import { PivotHeaderLayoutMap } from "./layout/pivot-header-layout";
 
@@ -40,7 +40,7 @@ import { EmptyTip } from "./components/empty-tip/empty-tip";
 
 export class PivotTable extends BaseTable {
     constructor(container, options) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
         if ("node" === Env.mode ? (options = container, container = null) : container instanceof HTMLElement || (options = container, 
         container = container.container ? container.container : null), super(container, options), 
         this.layoutNodeId = {
@@ -78,9 +78,9 @@ export class PivotTable extends BaseTable {
                 rowDimensionTree = new DimensionTree(null !== (_o = this.dataset.rowHeaderTree) && void 0 !== _o ? _o : [], this.layoutNodeId, this.options.rowHierarchyType, "tree" === this.options.rowHierarchyType ? null !== (_p = this.options.rowExpandLevel) && void 0 !== _p ? _p : 1 : void 0)), 
                 this.internalProps.layoutMap = new PivotHeaderLayoutMap(this, this.dataset, columnDimensionTree, rowDimensionTree);
             }
-            this.pivotSortState = [], options.pivotSortState && this.updatePivotSortState(options.pivotSortState), 
-            "node" !== Env.mode && (this.editorManager = new EditManeger(this)), this.refreshHeader(), 
-            this.stateManager.initCheckedState(records), this.scenegraph.createSceneGraph(), 
+            this._changePivotSortStateBySortRules(), (null !== (_r = null === (_q = options.pivotSortState) || void 0 === _q ? void 0 : _q.length) && void 0 !== _r ? _r : 0) > 0 && (this.pivotSortState = [], 
+            this.pivotSortState = options.pivotSortState), "node" !== Env.mode && (this.editorManager = new EditManeger(this)), 
+            this.refreshHeader(), this.stateManager.initCheckedState(records), this.scenegraph.createSceneGraph(), 
             options.title && (this.internalProps.title = new Title(options.title, this), this.scenegraph.resize()), 
             this.options.emptyTip && (this.internalProps.emptyTip || (this.internalProps.emptyTip = new EmptyTip(this.options.emptyTip, this)), 
             this.internalProps.emptyTip.resetVisible()), setTimeout((() => {
@@ -116,7 +116,7 @@ export class PivotTable extends BaseTable {
         return ifCan;
     }
     updateOption(options) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
         const internalProps = this.internalProps;
         if (super.updateOption(options), this.layoutNodeId = {
             seqId: 0
@@ -161,8 +161,8 @@ export class PivotTable extends BaseTable {
             rowDimensionTree = new DimensionTree(null !== (_q = this.dataset.rowHeaderTree) && void 0 !== _q ? _q : [], this.layoutNodeId, this.options.rowHierarchyType, "tree" === this.options.rowHierarchyType ? null !== (_r = this.options.rowExpandLevel) && void 0 !== _r ? _r : 1 : void 0)), 
             internalProps.layoutMap = new PivotHeaderLayoutMap(this, this.dataset, columnDimensionTree, rowDimensionTree);
         }
-        return this.pivotSortState = [], options.pivotSortState && this.updatePivotSortState(options.pivotSortState), 
-        this.refreshHeader(), internalProps.releaseList && (internalProps.releaseList.forEach((releaseObj => {
+        return this._changePivotSortStateBySortRules(), (null !== (_t = null === (_s = options.pivotSortState) || void 0 === _s ? void 0 : _s.length) && void 0 !== _t ? _t : 0) > 0 && (this.pivotSortState = [], 
+        this.pivotSortState = options.pivotSortState), this.refreshHeader(), internalProps.releaseList && (internalProps.releaseList.forEach((releaseObj => {
             var _a;
             return null === (_a = null == releaseObj ? void 0 : releaseObj.release) || void 0 === _a ? void 0 : _a.call(releaseObj);
         })), internalProps.releaseList = null), this.scenegraph.clearCells(), this.scenegraph.createSceneGraph(), 
@@ -465,26 +465,94 @@ export class PivotTable extends BaseTable {
         }
     }
     updateSortRules(sortRules) {
-        this.internalProps.dataConfig.sortRules = sortRules, this.dataset.updateSortRules(sortRules), 
+        this.internalProps.dataConfig ? this.internalProps.dataConfig.sortRules = sortRules : this.internalProps.dataConfig = {
+            sortRules: sortRules
+        }, this.dataset.updateSortRules(sortRules), this._changePivotSortStateBySortRules(), 
         this.internalProps.layoutMap.resetHeaderTree(), this.scenegraph.clearCells(), this.refreshHeader(), 
         this.scenegraph.createSceneGraph(), this.render();
     }
+    _changePivotSortStateBySortRules() {
+        var _a, _b, _c, _d;
+        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];
+            if (sortRule.sortType) {
+                const dimensions = [];
+                if (sortRule.sortByIndicator) {
+                    if (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],
+                            value: sortRule.query[j]
+                        });
+                        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
+                        });
+                    }
+                } else dimensions.push({
+                    dimensionKey: sortRule.sortField,
+                    isPivotCorner: !0,
+                    value: sortRule.sortField
+                });
+                this.pivotSortState.push({
+                    dimensions: dimensions,
+                    order: sortRule.sortType
+                });
+            }
+        }
+    }
     updatePivotSortState(pivotSortStateConfig) {
-        for (let i = 0; i < pivotSortStateConfig.length; i++) {
-            const {dimensions: dimensions, order: order} = pivotSortStateConfig[i], cellAddress = this.internalProps.layoutMap.getPivotCellAdress(dimensions);
-            cellAddress && this.pivotSortState.push({
-                col: cellAddress.col,
-                row: cellAddress.row,
-                order: order
-            });
+        this.pivotSortState = pivotSortStateConfig;
+    }
+    sort(col, row, order) {
+        let dimensions;
+        if (this.isCornerHeader(col, row)) {
+            const dimensionInfo = this.getHeaderDefine(col, row);
+            dimensions = [];
+            const dimension = {
+                isPivotCorner: !0,
+                dimensionKey: dimensionInfo.value,
+                value: dimensionInfo.value
+            };
+            dimensions.push(dimension);
+        } else dimensions = this.isColumnHeader(col, row) ? this.getCellHeaderPaths(col, row).colHeaderPaths : this.getCellHeaderPaths(col, row).rowHeaderPaths;
+        const sortIndicator = dimensions[dimensions.length - 1].indicatorKey, headerDefine = this.getHeaderDefine(col, row);
+        if (headerDefine.sort) {
+            if (this.dataset.sortRules) {
+                for (let i = this.dataset.sortRules.length - 1; i >= 0; i--) {
+                    const sortRule = this.dataset.sortRules[i];
+                    (headerDefine.dimensionKey && sortRule.sortField === headerDefine.dimensionKey || sortIndicator && sortRule.sortField === (this.dataset.indicatorsAsCol ? this.dataset.rows[this.dataset.rows.length - 1] : this.dataset.columns[this.dataset.columns.length - 1])) && this.dataset.sortRules.splice(i, 1);
+                }
+                sortIndicator ? this.dataset.sortRules.push({
+                    sortField: this.dataset.indicatorsAsCol ? this.dataset.rows[this.dataset.rows.length - 1] : this.dataset.columns[this.dataset.columns.length - 1],
+                    sortType: SortType[order],
+                    sortByIndicator: sortIndicator,
+                    query: dimensions.reduce(((arr, dimension) => (dimension.dimensionKey && arr.push(dimension.value), 
+                    arr)), [])
+                }) : this.dataset.sortRules.push({
+                    sortField: headerDefine.dimensionKey,
+                    sortType: SortType[order]
+                });
+            } else this.dataset.sortRules = sortIndicator ? [ {
+                sortField: this.dataset.indicatorsAsCol ? this.dataset.rows[this.dataset.rows.length - 1] : this.dataset.columns[this.dataset.columns.length - 1],
+                sortType: SortType[order],
+                sortByIndicator: sortIndicator,
+                query: dimensions.reduce(((arr, dimension) => (dimension.dimensionKey && arr.push(dimension.value), 
+                arr)), [])
+            } ] : [ {
+                sortField: headerDefine.dimensionKey,
+                sortType: SortType[order]
+            } ];
+            this.updateSortRules(this.dataset.sortRules);
         }
     }
     getPivotSortState(col, row) {
         if (!this.pivotSortState) return;
         const cellRange = this.getCellRange(col, row);
         for (let i = 0; i < this.pivotSortState.length; i++) {
-            const {col: sortCol, row: sortRow, order: order} = this.pivotSortState[i];
-            if (cellInRange(cellRange, sortCol, sortRow)) return order;
+            const pivotState = this.pivotSortState[i], dimensions = pivotState.dimensions, cell = this.getCellAddressByHeaderPaths(dimensions), order = pivotState.order;
+            if (cell && cellInRange(cellRange, cell.col, cell.row)) return order;
         }
     }
     _moveHeaderPosition(source, target) {
@@ -602,7 +670,7 @@ export class PivotTable extends BaseTable {
             this.dataset.setRecords(records), columnDimensionTree = options.columnTree ? internalProps.layoutMap.columnDimensionTree : new DimensionTree(null !== (_c = this.dataset.colHeaderTree) && void 0 !== _c ? _c : [], this.layoutNodeId), 
             rowDimensionTree = options.rowTree ? internalProps.layoutMap.rowDimensionTree : new DimensionTree(null !== (_d = this.dataset.rowHeaderTree) && void 0 !== _d ? _d : [], this.layoutNodeId, this.options.rowHierarchyType, "tree" === this.options.rowHierarchyType ? null !== (_e = this.options.rowExpandLevel) && void 0 !== _e ? _e : 1 : void 0), 
             internalProps.layoutMap = new PivotHeaderLayoutMap(this, this.dataset, columnDimensionTree, rowDimensionTree), 
-            this.pivotSortState = [], options.pivotSortState && this.updatePivotSortState(options.pivotSortState);
+            this.pivotSortState = [], options.pivotSortState && (this.pivotSortState = options.pivotSortState);
         }
         this.refreshHeader(), this.scenegraph.clearCells(), this.clearCellStyleCache(), 
         this.scenegraph.createSceneGraph(), this.stateManager.updateHoverPos(oldHoverState.col, oldHoverState.row),