@visactor/vtable 0.9.0-alpha.0-alpha.0

package/es/dataset/dataset.js

@@ -0,0 +1,482 @@
+import { AggregationType, SortType } from "../ts-types";
+
+export class Dataset {
+    constructor(dataConfig, rows, columns, indicators, records) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
+        this.tree = {}, this.colFlatKeys = {}, this.rowFlatKeys = {}, this.colKeys = [], 
+        this.rowKeys = [], this.rowOrder = "key_a_to_z", this.colOrder = "key_a_to_z", this.sorted = !1, 
+        this.indicatorStatistics = [], this.aggregators = {}, this.stringJoinChar = String.fromCharCode(0), 
+        this.rowsIsTotal = [], this.colsIsTotal = [], this.registerAggregators(), this.dataConfig = dataConfig, 
+        this.sortRules = this.dataConfig.sortRules, this.aggregationRules = this.dataConfig.aggregationRules, 
+        this.derivedFieldRules = this.dataConfig.derivedFieldRules, this.mappingRules = this.dataConfig.mappingRules, 
+        this.totals = dataConfig.totals, this.rows = rows, this.columns = columns, this.indicators = indicators, 
+        this.colGrandTotalLabel = null !== (_c = null === (_b = null === (_a = this.totals) || void 0 === _a ? void 0 : _a.column) || void 0 === _b ? void 0 : _b.grandTotalLabel) && void 0 !== _c ? _c : "总计", 
+        this.colSubTotalLabel = null !== (_f = null === (_e = null === (_d = this.totals) || void 0 === _d ? void 0 : _d.column) || void 0 === _e ? void 0 : _e.subTotalLabel) && void 0 !== _f ? _f : "小计", 
+        this.rowGrandTotalLabel = null !== (_j = null === (_h = null === (_g = this.totals) || void 0 === _g ? void 0 : _g.row) || void 0 === _h ? void 0 : _h.grandTotalLabel) && void 0 !== _j ? _j : "总计", 
+        this.rowSubTotalLabel = null !== (_m = null === (_l = null === (_k = this.totals) || void 0 === _k ? void 0 : _k.row) || void 0 === _l ? void 0 : _l.subTotalLabel) && void 0 !== _m ? _m : "小计", 
+        this.rowsIsTotal = new Array(this.rows.length).fill(!1), this.colsIsTotal = new Array(this.columns.length).fill(!1);
+        for (let i = 0, len = null === (_q = null === (_p = null === (_o = this.totals) || void 0 === _o ? void 0 : _o.row) || void 0 === _p ? void 0 : _p.subTotalsDimensions) || void 0 === _q ? void 0 : _q.length; i < len; i++) {
+            const dimension = this.totals.row.subTotalsDimensions[i], dimensionIndex = this.rows.indexOf(dimension);
+            this.rowsIsTotal[dimensionIndex] = !0;
+        }
+        for (let i = 0, len = null === (_t = null === (_s = null === (_r = this.totals) || void 0 === _r ? void 0 : _r.column) || void 0 === _s ? void 0 : _s.subTotalsDimensions) || void 0 === _t ? void 0 : _t.length; i < len; i++) {
+            const dimension = this.totals.column.subTotalsDimensions[i], dimensionIndex = this.columns.indexOf(dimension);
+            this.colsIsTotal[dimensionIndex] = !0;
+        }
+        if (records) {
+            this.records = records;
+            const t0 = "undefined" != typeof window ? window.performance.now() : 0;
+            this.setRecords(records);
+            const t1 = "undefined" != typeof window ? window.performance.now() : 0;
+            console.log("processRecords:", t1 - t0);
+            const t4 = "undefined" != typeof window ? window.performance.now() : 0;
+            this.totalStatistics();
+            const t5 = "undefined" != typeof window ? window.performance.now() : 0;
+            console.log("totalStatistics:", t5 - t4);
+            const t2 = "undefined" != typeof window ? window.performance.now() : 0;
+            this.sortKeys();
+            const t3 = "undefined" != typeof window ? window.performance.now() : 0;
+            console.log("sortKeys:", t3 - t2);
+            const t7 = "undefined" != typeof window ? window.performance.now() : 0;
+            this.rowKeysPath = this.TreeToArr(this.ArrToTree(this.rowKeys, this.rowsIsTotal, (null === (_v = null === (_u = null == this ? void 0 : this.totals) || void 0 === _u ? void 0 : _u.row) || void 0 === _v ? void 0 : _v.showGrandTotals) || 0 === this.columns.length, this.rowGrandTotalLabel, this.rowSubTotalLabel)), 
+            this.colKeysPath = this.TreeToArr(this.ArrToTree(this.colKeys, this.colsIsTotal, (null === (_x = null === (_w = this.totals) || void 0 === _w ? void 0 : _w.column) || void 0 === _x ? void 0 : _x.showGrandTotals) || 0 === this.rows.length, this.colGrandTotalLabel, this.colSubTotalLabel));
+            const t8 = "undefined" != typeof window ? window.performance.now() : 0;
+            console.log("TreeToArr:", t8 - t7);
+        }
+        delete this.rowFlatKeys, delete this.colFlatKeys;
+    }
+    registerAggregator(type, aggregator) {
+        this.aggregators[type] = aggregator;
+    }
+    registerAggregators() {
+        this.registerAggregator(AggregationType.SUM, SumAggregator), this.registerAggregator(AggregationType.COUNT, CountAggregator), 
+        this.registerAggregator(AggregationType.MAX, MaxAggregator), this.registerAggregator(AggregationType.MIN, MinAggregator), 
+        this.registerAggregator(AggregationType.AVG, AvgAggregator);
+    }
+    setRecords(records) {
+        this.processRecords();
+    }
+    processRecords() {
+        for (let i = 0, len = this.records.length; i < len; i++) {
+            const record = this.records[i];
+            this.filterRecord(record) && this.processRecord(record);
+        }
+    }
+    filterRecord(record) {
+        var _a, _b;
+        let isReserved = !0;
+        for (let i = 0; i < (null === (_a = this.dataConfig.filterRules) || void 0 === _a ? void 0 : _a.length); i++) {
+            const filterRule = this.dataConfig.filterRules[i];
+            if (!(null === (_b = filterRule.filterFunc) || void 0 === _b ? void 0 : _b.call(filterRule, record))) {
+                isReserved = !1;
+                break;
+            }
+        }
+        return isReserved;
+    }
+    processRecord(record) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        null === (_a = this.derivedFieldRules) || void 0 === _a || _a.forEach(((derivedFieldRule, i) => {
+            record[derivedFieldRule.fieldName] = derivedFieldRule.derivedFunc(record);
+        }));
+        const colKey = [], rowKey = [];
+        for (let l = 0, len1 = this.rows.length; l < len1; l++) {
+            const rowAttr = this.rows[l];
+            rowKey.push(record[rowAttr]);
+        }
+        for (let n = 0, len2 = this.columns.length; n < len2; n++) {
+            const colAttr = this.columns[n];
+            colKey.push(record[colAttr]);
+        }
+        const flatRowKey = rowKey.join(this.stringJoinChar), flatColKey = colKey.join(this.stringJoinChar);
+        if (0 !== rowKey.length && (this.rowFlatKeys[flatRowKey] || (this.rowKeys.push(rowKey), 
+        this.rowFlatKeys[flatRowKey] = 1)), 0 !== colKey.length && (this.colFlatKeys[flatColKey] || (this.colKeys.push(colKey), 
+        this.colFlatKeys[flatColKey] = 1)), 0 !== colKey.length || 0 !== rowKey.length) {
+            this.tree[flatRowKey] || (this.tree[flatRowKey] = {}), (null === (_b = this.tree[flatRowKey]) || void 0 === _b ? void 0 : _b[flatColKey]) || (this.tree[flatRowKey][flatColKey] = []);
+            for (let i = 0; i < this.indicators.length; i++) {
+                if (!(null === (_d = null === (_c = this.tree[flatRowKey]) || void 0 === _c ? void 0 : _c[flatColKey]) || void 0 === _d ? void 0 : _d[i])) {
+                    const aggRule = this.getAggregatorRule(this.indicators[i]);
+                    this.tree[flatRowKey][flatColKey][i] = new this.aggregators[null !== (_e = null == aggRule ? void 0 : aggRule.aggregationType) && void 0 !== _e ? _e : AggregationType.SUM](null !== (_f = null == aggRule ? void 0 : aggRule.field) && void 0 !== _f ? _f : this.indicators[i], null == aggRule ? void 0 : aggRule.formatFun);
+                }
+                null === (_h = null === (_g = this.tree[flatRowKey]) || void 0 === _g ? void 0 : _g[flatColKey]) || void 0 === _h || _h[i].push(record);
+            }
+        }
+        if (this.mappingRules) for (let i = 0; i < this.indicators.length; i++) {
+            if (!this.indicatorStatistics[i]) {
+                const aggRule = this.getAggregatorRule(this.indicators[i]);
+                this.indicatorStatistics[i] = {
+                    max: new this.aggregators[AggregationType.MAX](this.indicators[i]),
+                    min: new this.aggregators[AggregationType.MIN](this.indicators[i]),
+                    total: new this.aggregators[null !== (_j = null == aggRule ? void 0 : aggRule.aggregationType) && void 0 !== _j ? _j : AggregationType.SUM](null !== (_k = null == aggRule ? void 0 : aggRule.field) && void 0 !== _k ? _k : this.indicators[i], null == aggRule ? void 0 : aggRule.formatFun)
+                };
+            }
+            this.indicatorStatistics[i].max.push(null === (_m = null === (_l = this.tree[flatRowKey]) || void 0 === _l ? void 0 : _l[flatColKey]) || void 0 === _m ? void 0 : _m[i].value()), 
+            this.indicatorStatistics[i].min.push(null === (_p = null === (_o = this.tree[flatRowKey]) || void 0 === _o ? void 0 : _o[flatColKey]) || void 0 === _p ? void 0 : _p[i].value()), 
+            this.indicatorStatistics[i].total.push(record);
+        }
+    }
+    updateSortRules(sortRules) {
+        var _a, _b, _c, _d;
+        this.sorted = !1, this.sortRules = sortRules, this.sortKeys(), this.rowKeysPath = this.TreeToArr(this.ArrToTree(this.rowKeys, this.rowsIsTotal, (null === (_b = null === (_a = null == this ? void 0 : this.totals) || void 0 === _a ? void 0 : _a.row) || void 0 === _b ? void 0 : _b.showGrandTotals) || 0 === this.columns.length, this.rowGrandTotalLabel, this.rowSubTotalLabel)), 
+        this.colKeysPath = this.TreeToArr(this.ArrToTree(this.colKeys, this.colsIsTotal, (null === (_d = null === (_c = this.totals) || void 0 === _c ? void 0 : _c.column) || void 0 === _d ? void 0 : _d.showGrandTotals) || 0 === this.rows.length, this.colGrandTotalLabel, this.colSubTotalLabel));
+    }
+    getAggregatorRule(indicatorKey) {
+        var _a;
+        return null === (_a = this.aggregationRules) || void 0 === _a ? void 0 : _a.find(((value, index) => indicatorKey === value.indicatorKey));
+    }
+    getAggregator(rowKey = [], colKey = [], indicator) {
+        var _a, _b;
+        const indicatorIndex = this.indicators.indexOf(indicator);
+        let agg, flatRowKey, flatColKey;
+        return flatRowKey = "string" == typeof rowKey ? rowKey : rowKey.join(this.stringJoinChar), 
+        flatColKey = "string" == typeof colKey ? colKey : colKey.join(this.stringJoinChar), 
+        0 === rowKey.length && 0 === colKey.length || (agg = null === (_b = null === (_a = this.tree[flatRowKey]) || void 0 === _a ? void 0 : _a[flatColKey]) || void 0 === _b ? void 0 : _b[indicatorIndex]), 
+        agg || {
+            className: "",
+            push() {},
+            value: () => null,
+            formatValue: () => ""
+        };
+    }
+    sortKeys() {
+        const that = this;
+        if (!this.sorted) {
+            this.sorted = !0;
+            const getValue = function(rowKey, colKey) {
+                return that.getAggregator(rowKey, colKey, "").value();
+            };
+            switch (this.rowOrder) {
+              case "value_a_to_z":
+                this.rowKeys.sort((function(a, b) {
+                    return naturalSort(getValue(a, []), getValue(b, []));
+                }));
+                break;
+
+              case "value_z_to_a":
+                this.rowKeys.sort((function(a, b) {
+                    return -naturalSort(getValue(a, []), getValue(b, []));
+                }));
+                break;
+
+              default:
+                this.rowKeys.sort(this.arrSort(this.rows, !0));
+            }
+            switch (this.colOrder) {
+              case "value_a_to_z":
+                this.colKeys.sort((function(a, b) {
+                    return naturalSort(getValue([], a), getValue([], b));
+                }));
+                break;
+
+              case "value_z_to_a":
+                this.colKeys.sort((function(a, b) {
+                    return -naturalSort(getValue([], a), getValue([], b));
+                }));
+                break;
+
+              default:
+                const sortfun = this.arrSort(this.columns, !1);
+                this.colKeys.sort(sortfun);
+            }
+        }
+    }
+    arrSort(fieldArr, isRow) {
+        let field;
+        const that = this, sortersArr = function(_this) {
+            const results = [];
+            for (let l = 0, len1 = fieldArr.length; l < len1; l++) {
+                field = fieldArr[l];
+                let isHasSortRule = !1;
+                if (that.sortRules) for (let m = 0, len2 = that.sortRules.length; m < len2; m++) that.sortRules[m].sortField === field && (isHasSortRule = !0, 
+                results.push({
+                    field: field,
+                    fieldIndex: l,
+                    sortRule: that.sortRules[m],
+                    func: that.getSort(that.sortRules[m], isRow)
+                }));
+                isHasSortRule || results.push({
+                    field: field,
+                    fieldIndex: l,
+                    func: naturalSort
+                });
+            }
+            return results;
+        }.call(this);
+        return function(a, b) {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+            let comparison, sorter;
+            for (let i = 0; i < sortersArr.length; i++) {
+                if (sorter = sortersArr[i], null === (_a = sorter.sortRule) || void 0 === _a ? void 0 : _a.sortByIndicator) {
+                    let aChanged = a, bChanged = b;
+                    sorter.fieldIndex < fieldArr.length - 1 && (aChanged = a.slice(0, sorter.fieldIndex + 1), 
+                    aChanged.push(isRow ? null === (_c = null === (_b = that.totals) || void 0 === _b ? void 0 : _b.row) || void 0 === _c ? void 0 : _c.subTotalLabel : null === (_e = null === (_d = that.totals) || void 0 === _d ? void 0 : _d.column) || void 0 === _e ? void 0 : _e.subTotalLabel), 
+                    bChanged = b.slice(0, sorter.fieldIndex + 1), bChanged.push(isRow ? null === (_g = null === (_f = that.totals) || void 0 === _f ? void 0 : _f.row) || void 0 === _g ? void 0 : _g.subTotalLabel : null === (_j = null === (_h = that.totals) || void 0 === _h ? void 0 : _h.column) || void 0 === _j ? void 0 : _j.subTotalLabel)), 
+                    comparison = sorter.func(aChanged, bChanged);
+                } else comparison = sorter.func(a[sorter.fieldIndex], b[sorter.fieldIndex]);
+                if (0 !== comparison) return comparison * ((null === (_k = sorter.sortRule) || void 0 === _k ? void 0 : _k.sortType) === SortType.DESC ? -1 : 1);
+            }
+            return 0;
+        };
+    }
+    getSort(sortRule, isSortRow) {
+        const that = this;
+        return sortRule.sortByIndicator ? (a, b) => {
+            const getValue = function(rowKey, colKey) {
+                return rowKey.length < that.rows.length && rowKey[rowKey.length - 1] !== that.rowSubTotalLabel && rowKey[rowKey.length - 1] !== that.rowGrandTotalLabel && rowKey.push(that.rowSubTotalLabel), 
+                colKey.length < that.columns.length && colKey[colKey.length - 1] !== that.colSubTotalLabel && colKey[colKey.length - 1] !== that.colGrandTotalLabel && colKey.push(that.colSubTotalLabel), 
+                that.getAggregator(rowKey, colKey, sortRule.sortByIndicator).value();
+            };
+            return isSortRow ? naturalSort(getValue(a, sortRule.query), getValue(b, sortRule.query)) : naturalSort(getValue(sortRule.query, a), getValue(sortRule.query, b));
+        } : sortRule.sortBy ? sortBy(sortRule.sortBy) : sortRule.sortType ? typeSort : sortRule.sortFunc ? sortRule.sortFunc : naturalSort;
+    }
+    totalStatistics() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        const that = this;
+        if ((null === (_b = null === (_a = null == that ? void 0 : that.totals) || void 0 === _a ? void 0 : _a.column) || void 0 === _b ? void 0 : _b.showSubTotals) && (null === (_e = null === (_d = null === (_c = null == that ? void 0 : that.totals) || void 0 === _c ? void 0 : _c.column) || void 0 === _d ? void 0 : _d.subTotalsDimensions) || void 0 === _e ? void 0 : _e.length) >= 1 || (null === (_g = null === (_f = null == that ? void 0 : that.totals) || void 0 === _f ? void 0 : _f.row) || void 0 === _g ? void 0 : _g.showSubTotals) && (null === (_k = null === (_j = null === (_h = null == that ? void 0 : that.totals) || void 0 === _h ? void 0 : _h.row) || void 0 === _j ? void 0 : _j.subTotalsDimensions) || void 0 === _k ? void 0 : _k.length) >= 1 || (null === (_m = null === (_l = null == that ? void 0 : that.totals) || void 0 === _l ? void 0 : _l.column) || void 0 === _m ? void 0 : _m.showGrandTotals) || (null === (_p = null === (_o = null == that ? void 0 : that.totals) || void 0 === _o ? void 0 : _o.row) || void 0 === _p ? void 0 : _p.showGrandTotals) || 0 === that.rows.length || 0 === that.columns.length) {
+            const rowTotalKeys = [], colCompute = (flatRowKey, flatColKey) => {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+                const colKey = flatColKey.split(this.stringJoinChar);
+                for (let i = 0, len = null === (_c = null === (_b = null === (_a = that.totals) || void 0 === _a ? void 0 : _a.column) || void 0 === _b ? void 0 : _b.subTotalsDimensions) || void 0 === _c ? void 0 : _c.length; i < len; i++) {
+                    const dimension = that.totals.column.subTotalsDimensions[i], dimensionIndex = that.columns.indexOf(dimension);
+                    if (dimensionIndex >= 0) {
+                        const colTotalKey = colKey.slice(0, dimensionIndex + 1);
+                        colTotalKey.push(null !== (_f = null === (_e = null === (_d = that.totals) || void 0 === _d ? void 0 : _d.column) || void 0 === _e ? void 0 : _e.subTotalLabel) && void 0 !== _f ? _f : "小计");
+                        const flatColTotalKey = colTotalKey.join(this.stringJoinChar);
+                        this.tree[flatRowKey][flatColTotalKey] || (this.tree[flatRowKey][flatColTotalKey] = []);
+                        for (let i = 0; i < this.indicators.length; i++) {
+                            if (!this.tree[flatRowKey][flatColTotalKey][i]) {
+                                const aggRule = this.getAggregatorRule(this.indicators[i]);
+                                this.tree[flatRowKey][flatColTotalKey][i] = new this.aggregators[null !== (_g = null == aggRule ? void 0 : aggRule.aggregationType) && void 0 !== _g ? _g : AggregationType.SUM](null !== (_h = null == aggRule ? void 0 : aggRule.field) && void 0 !== _h ? _h : this.indicators[i], null == aggRule ? void 0 : aggRule.formatFun);
+                            }
+                            this.tree[flatRowKey][flatColTotalKey][i].push(null === (_k = null === (_j = that.tree[flatRowKey]) || void 0 === _j ? void 0 : _j[flatColKey]) || void 0 === _k ? void 0 : _k[i]);
+                        }
+                    }
+                }
+                if ((null === (_m = null === (_l = that.totals) || void 0 === _l ? void 0 : _l.column) || void 0 === _m ? void 0 : _m.showGrandTotals) || 0 === this.rows.length) {
+                    const flatColTotalKey = that.colGrandTotalLabel;
+                    this.tree[flatRowKey][flatColTotalKey] || (this.tree[flatRowKey][flatColTotalKey] = []);
+                    for (let i = 0; i < this.indicators.length; i++) {
+                        if (!this.tree[flatRowKey][flatColTotalKey][i]) {
+                            const aggRule = this.getAggregatorRule(this.indicators[i]);
+                            this.tree[flatRowKey][flatColTotalKey][i] = new this.aggregators[null !== (_o = null == aggRule ? void 0 : aggRule.aggregationType) && void 0 !== _o ? _o : AggregationType.SUM](null !== (_p = null == aggRule ? void 0 : aggRule.field) && void 0 !== _p ? _p : this.indicators[i], null == aggRule ? void 0 : aggRule.formatFun);
+                        }
+                        this.tree[flatRowKey][flatColTotalKey][i].push(null === (_r = null === (_q = that.tree[flatRowKey]) || void 0 === _q ? void 0 : _q[flatColKey]) || void 0 === _r ? void 0 : _r[i]);
+                    }
+                }
+            };
+            Object.keys(that.tree).forEach((flatRowKey => {
+                const rowKey = flatRowKey.split(this.stringJoinChar);
+                Object.keys(that.tree[flatRowKey]).forEach((flatColKey => {
+                    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+                    for (let i = 0, len = null === (_c = null === (_b = null === (_a = that.totals) || void 0 === _a ? void 0 : _a.row) || void 0 === _b ? void 0 : _b.subTotalsDimensions) || void 0 === _c ? void 0 : _c.length; i < len; i++) {
+                        const dimension = that.totals.row.subTotalsDimensions[i], dimensionIndex = that.rows.indexOf(dimension);
+                        if (dimensionIndex >= 0) {
+                            const rowTotalKey = rowKey.slice(0, dimensionIndex + 1);
+                            rowTotalKey.push(null !== (_f = null === (_e = null === (_d = that.totals) || void 0 === _d ? void 0 : _d.row) || void 0 === _e ? void 0 : _e.subTotalLabel) && void 0 !== _f ? _f : "小计");
+                            const flatRowTotalKey = rowTotalKey.join(this.stringJoinChar);
+                            if (this.tree[flatRowTotalKey] || (this.tree[flatRowTotalKey] = {}, rowTotalKeys.push(flatRowTotalKey)), 
+                            !this.tree[flatRowTotalKey][flatColKey]) {
+                                this.tree[flatRowTotalKey][flatColKey] = [];
+                                for (let i = 0; i < this.indicators.length; i++) {
+                                    if (!this.tree[flatRowTotalKey][flatColKey][i]) {
+                                        const aggRule = this.getAggregatorRule(this.indicators[i]);
+                                        this.tree[flatRowTotalKey][flatColKey][i] = new this.aggregators[null !== (_g = null == aggRule ? void 0 : aggRule.aggregationType) && void 0 !== _g ? _g : AggregationType.SUM](null !== (_h = null == aggRule ? void 0 : aggRule.field) && void 0 !== _h ? _h : this.indicators[i], null == aggRule ? void 0 : aggRule.formatFun);
+                                    }
+                                    this.tree[flatRowTotalKey][flatColKey][i].push(null === (_k = null === (_j = that.tree[flatRowKey]) || void 0 === _j ? void 0 : _j[flatColKey]) || void 0 === _k ? void 0 : _k[i]);
+                                }
+                            }
+                        }
+                        if ((null === (_m = null === (_l = that.totals) || void 0 === _l ? void 0 : _l.row) || void 0 === _m ? void 0 : _m.showGrandTotals) || 0 === this.columns.length) {
+                            const flatRowTotalKey = that.rowGrandTotalLabel;
+                            this.tree[flatRowTotalKey] || (this.tree[flatRowTotalKey] = {}, rowTotalKeys.push(flatRowTotalKey)), 
+                            this.tree[flatRowTotalKey][flatColKey] || (this.tree[flatRowTotalKey][flatColKey] = []);
+                            for (let i = 0; i < this.indicators.length; i++) {
+                                if (!this.tree[flatRowTotalKey][flatColKey][i]) {
+                                    const aggRule = this.getAggregatorRule(this.indicators[i]);
+                                    this.tree[flatRowTotalKey][flatColKey][i] = new this.aggregators[null !== (_o = null == aggRule ? void 0 : aggRule.aggregationType) && void 0 !== _o ? _o : AggregationType.SUM](null !== (_p = null == aggRule ? void 0 : aggRule.field) && void 0 !== _p ? _p : this.indicators[i], null == aggRule ? void 0 : aggRule.formatFun);
+                                }
+                                this.tree[flatRowTotalKey][flatColKey][i].push(null === (_r = null === (_q = that.tree[flatRowKey]) || void 0 === _q ? void 0 : _q[flatColKey]) || void 0 === _r ? void 0 : _r[i]);
+                            }
+                        }
+                        colCompute(flatRowKey, flatColKey);
+                    }
+                }));
+            })), rowTotalKeys.forEach((flatRowKey => {
+                Object.keys(that.tree[flatRowKey]).forEach((flatColKey => {
+                    colCompute(flatRowKey, flatColKey);
+                }));
+            }));
+        }
+    }
+    ArrToTree(arr, subTotalFlags, isGrandTotal, grandTotalLabel, subTotalLabel) {
+        const result = [], concatStr = this.stringJoinChar, map = new Map;
+        if (arr.forEach((item => function(list) {
+            const path = [];
+            let node;
+            list.forEach(((value, index) => {
+                path.push(value);
+                const flatKey = path.join(concatStr);
+                let item = map.get(flatKey);
+                if (!item) {
+                    if (item = {
+                        id: flatKey,
+                        child: []
+                    }, subTotalFlags[index]) {
+                        let curChild = item.child;
+                        for (let i = index; i < list.length - 1; i++) {
+                            const totalChild = {
+                                id: `${flatKey}${concatStr}${subTotalLabel}`,
+                                child: []
+                            };
+                            curChild.push(totalChild), curChild = totalChild.child;
+                        }
+                    }
+                    map.set(flatKey, item), node ? subTotalFlags[index - 1] ? node.child.splice(node.child.length - 1, 0, item) : node.child.push(item) : result.push(item);
+                }
+                node = item;
+            }));
+        }(item))), isGrandTotal) {
+            const node = {
+                id: grandTotalLabel,
+                child: []
+            };
+            let curChild = node.child;
+            for (let i = 1; i < subTotalFlags.length; i++) {
+                const totalChild = {
+                    id: grandTotalLabel,
+                    child: []
+                };
+                curChild.push(totalChild), curChild = totalChild.child;
+            }
+            result.push(node);
+        }
+        return result;
+    }
+    TreeToArr(tree) {
+        const result = [];
+        function getPath(node, arr) {
+            var _a;
+            arr.push(node.id), node.child.length > 0 ? null === (_a = node.child) || void 0 === _a || _a.forEach((childItem => getPath(childItem, [ ...arr ]))) : result.push(arr);
+        }
+        return tree.forEach((treeNode => getPath(treeNode, []))), result;
+    }
+}
+
+class Aggregator {
+    constructor(dimension, formatFun, isRecord) {
+        this.className = "Aggregator", this.isRecord = !0, this.records = [], this.field = dimension, 
+        this.formatFun = formatFun, this.isRecord = null != isRecord ? isRecord : this.isRecord;
+    }
+    formatValue() {
+        return this._formatedValue || (this.formatFun ? this._formatedValue = this.formatFun(this.value()) : this._formatedValue = this.value()), 
+        this._formatedValue;
+    }
+}
+
+class SumAggregator extends Aggregator {
+    constructor() {
+        super(...arguments), this.type = AggregationType.SUM, this.sum = 0;
+    }
+    push(record) {
+        this.isRecord && ("Aggregator" === record.className ? this.records.push(...record.records) : this.records.push(record)), 
+        "Aggregator" === record.className ? this.sum += record.value() : isNaN(parseFloat(record[this.field])) || (this.sum += parseFloat(record[this.field]));
+    }
+    value() {
+        return this.sum;
+    }
+}
+
+class CountAggregator extends Aggregator {
+    constructor() {
+        super(...arguments), this.type = AggregationType.COUNT, this.count = 0;
+    }
+    push(record) {
+        this.isRecord && ("Aggregator" === record.className ? this.records.push(...record.records) : this.records.push(record)), 
+        "Aggregator" === record.className ? this.count += record.value() : this.count++;
+    }
+    value() {
+        return this.count;
+    }
+}
+
+class AvgAggregator extends Aggregator {
+    constructor() {
+        super(...arguments), this.type = AggregationType.AVG, this.sum = 0, this.count = 0;
+    }
+    push(record) {
+        this.isRecord && ("Aggregator" === record.className ? this.records.push(...record.records) : this.records.push(record)), 
+        "Aggregator" === record.className && record.type === AggregationType.AVG ? (this.sum += record.sum, 
+        this.count += record.count) : isNaN(parseFloat(record[this.field])) || (this.sum += parseFloat(record[this.field]), 
+        this.count++);
+    }
+    value() {
+        return this.sum / this.count;
+    }
+}
+
+class MaxAggregator extends Aggregator {
+    constructor() {
+        super(...arguments), this.type = AggregationType.MAX, this.max = Number.MIN_SAFE_INTEGER, 
+        this.isRecord = !1;
+    }
+    push(record) {
+        this.isRecord && ("Aggregator" === record.className ? this.records.push(...record.records) : this.records.push(record)), 
+        "number" == typeof record ? this.max = record > this.max ? record : this.max : "number" == typeof record[this.field] ? this.max = record[this.field] > this.max ? record[this.field] : this.max : isNaN(record[this.field]) || (this.max = parseFloat(record[this.field]) > this.max ? parseFloat(record[this.field]) : this.max);
+    }
+    value() {
+        return this.max;
+    }
+}
+
+class MinAggregator extends Aggregator {
+    constructor() {
+        super(...arguments), this.type = AggregationType.MIN, this.min = Number.MAX_SAFE_INTEGER, 
+        this.isRecord = !1;
+    }
+    push(record) {
+        this.isRecord && ("Aggregator" === record.className ? this.records.push(...record.records) : this.records.push(record)), 
+        "number" == typeof record ? this.min = record < this.min ? record : this.min : "number" == typeof record[this.field] && (this.min = record[this.field] < this.min ? record[this.field] : this.min);
+    }
+    value() {
+        return this.min;
+    }
+}
+
+function indicatorSort(a, b) {
+    return a && b ? a.toString().localeCompare(b.toString(), "zh") : a ? 1 : -1;
+}
+
+function typeSort(a, b) {
+    return a && b ? a.toString().localeCompare(b.toString(), "zh") : a ? 1 : -1;
+}
+
+function naturalSort(as, bs) {
+    const rx = /(\d+)|(\D+)/g, rd = /\d/, rz = /^0/;
+    let a, a1, b, b1, nas = 0, nbs = 0;
+    if (null !== bs && null === as) return -1;
+    if (null !== as && null === bs) return 1;
+    if ("number" == typeof as && isNaN(as)) return -1;
+    if ("number" == typeof bs && isNaN(bs)) return 1;
+    if (nas = +as, nbs = +bs, nas < nbs) return -1;
+    if (nas > nbs) return 1;
+    if ("number" == typeof as && "number" != typeof bs) return -1;
+    if ("number" == typeof bs && "number" != typeof as) return 1;
+    if ("number" == typeof as && "number" == typeof bs) return 0;
+    if (isNaN(nbs) && !isNaN(nas)) return -1;
+    if (isNaN(nas) && !isNaN(nbs)) return 1;
+    if (a = String(as), b = String(bs), a === b) return 0;
+    if (!rd.test(a) || !rd.test(b)) return a > b ? 1 : -1;
+    for (a = a.match(rx), b = b.match(rx); a.length && b.length; ) if (a1 = a.shift(), 
+    b1 = b.shift(), a1 !== b1) return rd.test(a1) && rd.test(b1) ? a1.replace(rz, ".0") - b1.replace(rz, ".0") : a1 > b1 ? 1 : -1;
+    return a.length - b.length;
+}
+
+function sortBy(order) {
+    let x;
+    const mapping = {}, lowercase_mapping = {};
+    for (let i = 0; i < order.length; i++) x = order[i], mapping[x] = i, "string" == typeof x && (lowercase_mapping[x.toLowerCase()] = i);
+    return function(a, b) {
+        return null !== mapping[a] && void 0 !== mapping[a] && null !== mapping[b] && void 0 !== mapping[b] ? mapping[a] - mapping[b] : null !== mapping[a] && void 0 !== mapping[a] ? -1 : null !== mapping[b] && void 0 !== mapping[b] ? 1 : null !== lowercase_mapping[a] && void 0 !== mapping[a] && null !== lowercase_mapping[b] && void 0 !== mapping[b] ? lowercase_mapping[a] - lowercase_mapping[b] : null === lowercase_mapping[a] || void 0 === mapping[a] || null === lowercase_mapping[b] || void 0 === mapping[b] ? 0 : null !== lowercase_mapping[a] && void 0 !== mapping[a] ? -1 : null !== lowercase_mapping[b] && void 0 !== mapping[b] ? 1 : naturalSort(a, b);
+    };
+}
+//# sourceMappingURL=dataset.js.map