@visactor/vtable 1.2.1-alpha.0 → 1.2.1-alpha.2

package/es/PivotTable.d.ts

@@ -1,4 +1,4 @@
-import type { FieldData, FieldDef, PivotTableAPI, SortRules, CellAddress, ICellHeaderPaths, DropDownMenuEventInfo, FieldKeyDef, PivotTableConstructorOptions, IHeaderTreeDefine, IDimensionInfo, SortOrder, IPagination, CellLocation } from './ts-types';
+import type { FieldData, FieldDef, PivotTableAPI, SortRules, PivotSortState, 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,10 +14,7 @@ export declare class PivotTable extends BaseTable implements PivotTableAPI {
     };
     internalProps: PivotTableProtected;
     options: PivotTableConstructorOptions;
-    pivotSortState: {
-        dimensions: IDimensionInfo[];
-        order: SortOrder;
-    }[];
+    pivotSortState: PivotSortState[];
     editorManager: EditManeger;
     dataset?: Dataset;
     flatDataToObjects?: FlatDataToObjects;
@@ -49,12 +46,10 @@ 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, SortType } from "./ts-types";
+import { HierarchyState } 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, _q, _r;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
         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._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(), 
+            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(), 
             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, _s, _t;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
         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._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 => {
+        return this.pivotSortState = [], options.pivotSortState && this.updatePivotSortState(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,94 +465,26 @@ export class PivotTable extends BaseTable {
         }
     }
     updateSortRules(sortRules) {
-        this.internalProps.dataConfig ? this.internalProps.dataConfig.sortRules = sortRules : this.internalProps.dataConfig = {
-            sortRules: sortRules
-        }, this.dataset.updateSortRules(sortRules), this._changePivotSortStateBySortRules(), 
+        this.internalProps.dataConfig.sortRules = sortRules, this.dataset.updateSortRules(sortRules), 
         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) {
-        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);
+        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
+            });
         }
     }
     getPivotSortState(col, row) {
         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;
-            if (cell && cellInRange(cellRange, cell.col, cell.row)) return order;
+            const {col: sortCol, row: sortRow, order: order} = this.pivotSortState[i];
+            if (cellInRange(cellRange, sortCol, sortRow)) return order;
         }
     }
     _moveHeaderPosition(source, target) {
@@ -670,7 +602,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.pivotSortState = options.pivotSortState);
+            this.pivotSortState = [], options.pivotSortState && this.updatePivotSortState(options.pivotSortState);
         }
         this.refreshHeader(), this.scenegraph.clearCells(), this.clearCellStyleCache(), 
         this.scenegraph.createSceneGraph(), this.stateManager.updateHoverPos(oldHoverState.col, oldHoverState.row),