@visactor/vtable 0.19.2-alpha.3 → 0.20.0

package/dist/vtable.js

@@ -21455,6 +21455,7 @@
         AggregationType["MAX"] = "MAX";
         AggregationType["AVG"] = "AVG";
         AggregationType["COUNT"] = "COUNT";
+        AggregationType["CUSTOM"] = "CUSTOM";
     })(AggregationType || (AggregationType = {}));
     var SortType;
     (function (SortType) {
@@ -30945,6 +30946,506 @@
         return true;
     }
 
+    class Aggregator {
+        className = 'Aggregator';
+        isRecord = true;
+        records = [];
+        type;
+        field;
+        formatFun;
+        _formatedValue;
+        constructor(dimension, formatFun, isRecord) {
+            this.field = dimension;
+            this.formatFun = formatFun;
+            this.isRecord = isRecord ?? this.isRecord;
+        }
+        clearCacheValue() {
+            this._formatedValue = undefined;
+        }
+        formatValue(col, row, table) {
+            if (!this._formatedValue) {
+                if (this.formatFun) {
+                    this._formatedValue = this.formatFun(this.value(), col, row, table);
+                }
+                else {
+                    this._formatedValue = this.value();
+                }
+            }
+            return this._formatedValue;
+        }
+        reset() {
+            this.records = [];
+        }
+    }
+    class RecordAggregator extends Aggregator {
+        type = AggregationType.RECORD;
+        isRecord = true;
+        push(record) {
+            if (this.isRecord) {
+                if (record.className === 'Aggregator') {
+                    this.records.push(...record.records);
+                }
+                else {
+                    this.records.push(record);
+                }
+            }
+        }
+        value() {
+            return this.records;
+        }
+        reset() {
+            this.records = [];
+        }
+        recalculate() {
+        }
+    }
+    class NoneAggregator extends Aggregator {
+        type = AggregationType.NONE;
+        isRecord = true;
+        fieldValue;
+        push(record) {
+            if (this.isRecord) {
+                this.records = [record];
+            }
+            this.fieldValue = record[this.field];
+        }
+        value() {
+            return this.fieldValue;
+        }
+        reset() {
+            this.records = [];
+            this.fieldValue = undefined;
+        }
+        recalculate() {
+        }
+    }
+    class CustomAggregator extends Aggregator {
+        type = AggregationType.CUSTOM;
+        isRecord = true;
+        aggregationFun;
+        values = [];
+        fieldValue;
+        constructor(dimension, formatFun, isRecord, aggregationFun) {
+            super(dimension, formatFun, isRecord);
+            this.aggregationFun = aggregationFun;
+        }
+        push(record) {
+            if (this.isRecord) {
+                if (record.className === 'Aggregator') {
+                    this.records.push(...record.records);
+                }
+                else {
+                    this.records.push(record);
+                }
+            }
+            this.values.push(record[this.field]);
+        }
+        value() {
+            if (!this.fieldValue) {
+                this.fieldValue = this.aggregationFun?.(this.values, this.records, this.field);
+            }
+            return this.fieldValue;
+        }
+        reset() {
+            this.records = [];
+            this.fieldValue = undefined;
+        }
+        recalculate() {
+        }
+    }
+    class SumAggregator extends Aggregator {
+        type = AggregationType.SUM;
+        sum = 0;
+        positiveSum = 0;
+        nagetiveSum = 0;
+        needSplitPositiveAndNegativeForSum = false;
+        constructor(dimension, formatFun, isRecord, needSplitPositiveAndNegative) {
+            super(dimension, formatFun, isRecord);
+            this.needSplitPositiveAndNegativeForSum = needSplitPositiveAndNegative ?? false;
+        }
+        push(record) {
+            if (this.isRecord) {
+                if (record.className === 'Aggregator') {
+                    this.records.push(...record.records);
+                }
+                else {
+                    this.records.push(record);
+                }
+            }
+            if (record.className === 'Aggregator') {
+                const value = record.value();
+                this.sum += value;
+                if (this.needSplitPositiveAndNegativeForSum) {
+                    if (value > 0) {
+                        this.positiveSum += value;
+                    }
+                    else if (value < 0) {
+                        this.nagetiveSum += value;
+                    }
+                }
+            }
+            else if (!isNaN(parseFloat(record[this.field]))) {
+                const value = parseFloat(record[this.field]);
+                this.sum += value;
+                if (this.needSplitPositiveAndNegativeForSum) {
+                    if (value > 0) {
+                        this.positiveSum += value;
+                    }
+                    else if (value < 0) {
+                        this.nagetiveSum += value;
+                    }
+                }
+            }
+        }
+        value() {
+            return this.sum;
+        }
+        positiveValue() {
+            return this.positiveSum;
+        }
+        negativeValue() {
+            return this.nagetiveSum;
+        }
+        reset() {
+            this.records = [];
+            this.sum = 0;
+        }
+        recalculate() {
+            this.sum = 0;
+            this._formatedValue = undefined;
+            for (let i = 0; i < this.records.length; i++) {
+                const record = this.records[i];
+                if (record.className === 'Aggregator') {
+                    const value = record.value();
+                    this.sum += value;
+                    if (this.needSplitPositiveAndNegativeForSum) {
+                        if (value > 0) {
+                            this.positiveSum += value;
+                        }
+                        else if (value < 0) {
+                            this.nagetiveSum += value;
+                        }
+                    }
+                }
+                else if (!isNaN(parseFloat(record[this.field]))) {
+                    const value = parseFloat(record[this.field]);
+                    this.sum += value;
+                    if (this.needSplitPositiveAndNegativeForSum) {
+                        if (value > 0) {
+                            this.positiveSum += value;
+                        }
+                        else if (value < 0) {
+                            this.nagetiveSum += value;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    class CountAggregator extends Aggregator {
+        type = AggregationType.COUNT;
+        count = 0;
+        push(record) {
+            if (this.isRecord) {
+                if (record.className === 'Aggregator') {
+                    this.records.push(...record.records);
+                }
+                else {
+                    this.records.push(record);
+                }
+            }
+            if (record.className === 'Aggregator') {
+                this.count += record.value();
+            }
+            else {
+                this.count++;
+            }
+        }
+        value() {
+            return this.count;
+        }
+        reset() {
+            this.records = [];
+            this.count = 0;
+        }
+        recalculate() {
+            this.count = 0;
+            this._formatedValue = undefined;
+            for (let i = 0; i < this.records.length; i++) {
+                const record = this.records[i];
+                if (record.className === 'Aggregator') {
+                    this.count += record.value();
+                }
+                else {
+                    this.count++;
+                }
+            }
+        }
+    }
+    class AvgAggregator extends Aggregator {
+        type = AggregationType.AVG;
+        sum = 0;
+        count = 0;
+        push(record) {
+            if (this.isRecord) {
+                if (record.className === 'Aggregator') {
+                    this.records.push(...record.records);
+                }
+                else {
+                    this.records.push(record);
+                }
+            }
+            if (record.className === 'Aggregator' && record.type === AggregationType.AVG) {
+                this.sum += record.sum;
+                this.count += record.count;
+            }
+            else if (!isNaN(parseFloat(record[this.field]))) {
+                this.sum += parseFloat(record[this.field]);
+                this.count++;
+            }
+        }
+        value() {
+            return this.sum / this.count;
+        }
+        reset() {
+            this.records = [];
+            this.sum = 0;
+            this.count = 0;
+        }
+        recalculate() {
+            this.sum = 0;
+            this.count = 0;
+            this._formatedValue = undefined;
+            for (let i = 0; i < this.records.length; i++) {
+                const record = this.records[i];
+                if (record.className === 'Aggregator' && record.type === AggregationType.AVG) {
+                    this.sum += record.sum;
+                    this.count += record.count;
+                }
+                else if (!isNaN(parseFloat(record[this.field]))) {
+                    this.sum += parseFloat(record[this.field]);
+                    this.count++;
+                }
+            }
+        }
+    }
+    class MaxAggregator extends Aggregator {
+        type = AggregationType.MAX;
+        max = Number.MIN_SAFE_INTEGER;
+        push(record) {
+            if (this.isRecord) {
+                if (record.className === 'Aggregator') {
+                    this.records.push(...record.records);
+                }
+                else {
+                    this.records.push(record);
+                }
+            }
+            if (record.className === 'Aggregator') {
+                this.max = record.max > this.max ? record.max : this.max;
+            }
+            else if (typeof record === 'number') {
+                this.max = record > this.max ? record : this.max;
+            }
+            else if (typeof record[this.field] === 'number') {
+                this.max = record[this.field] > this.max ? record[this.field] : this.max;
+            }
+            else if (!isNaN(record[this.field])) {
+                this.max = parseFloat(record[this.field]) > this.max ? parseFloat(record[this.field]) : this.max;
+            }
+        }
+        value() {
+            return this.max;
+        }
+        reset() {
+            this.records = [];
+            this.max = Number.MIN_SAFE_INTEGER;
+        }
+        recalculate() {
+            this.max = Number.MIN_SAFE_INTEGER;
+            this._formatedValue = undefined;
+            for (let i = 0; i < this.records.length; i++) {
+                const record = this.records[i];
+                if (record.className === 'Aggregator') {
+                    this.max = record.max > this.max ? record.max : this.max;
+                }
+                else if (typeof record === 'number') {
+                    this.max = record > this.max ? record : this.max;
+                }
+                else if (typeof record[this.field] === 'number') {
+                    this.max = record[this.field] > this.max ? record[this.field] : this.max;
+                }
+                else if (!isNaN(record[this.field])) {
+                    this.max = parseFloat(record[this.field]) > this.max ? parseFloat(record[this.field]) : this.max;
+                }
+            }
+        }
+    }
+    class MinAggregator extends Aggregator {
+        type = AggregationType.MIN;
+        min = Number.MAX_SAFE_INTEGER;
+        push(record) {
+            if (this.isRecord) {
+                if (record.className === 'Aggregator') {
+                    this.records.push(...record.records);
+                }
+                else {
+                    this.records.push(record);
+                }
+            }
+            if (record.className === 'Aggregator') {
+                this.min = record.min < this.min ? record.min : this.min;
+            }
+            else if (typeof record === 'number') {
+                this.min = record < this.min ? record : this.min;
+            }
+            else if (typeof record[this.field] === 'number') {
+                this.min = record[this.field] < this.min ? record[this.field] : this.min;
+            }
+        }
+        value() {
+            return this.min;
+        }
+        reset() {
+            this.records = [];
+            this.min = Number.MAX_SAFE_INTEGER;
+        }
+        recalculate() {
+            this.min = Number.MAX_SAFE_INTEGER;
+            this._formatedValue = undefined;
+            for (let i = 0; i < this.records.length; i++) {
+                const record = this.records[i];
+                if (record.className === 'Aggregator') {
+                    this.min = record.min < this.min ? record.min : this.min;
+                }
+                else if (typeof record === 'number') {
+                    this.min = record < this.min ? record : this.min;
+                }
+                else if (typeof record[this.field] === 'number') {
+                    this.min = record[this.field] < this.min ? record[this.field] : this.min;
+                }
+            }
+        }
+    }
+    function typeSort(a, b) {
+        if (a && b) {
+            return a.toString().localeCompare(b.toString(), 'zh');
+        }
+        if (a) {
+            return 1;
+        }
+        return -1;
+    }
+    function naturalSort(as, bs) {
+        const rx = /(\d+)|(\D+)/g;
+        const rd = /\d/;
+        const rz = /^0/;
+        let a;
+        let a1;
+        let b;
+        let b1;
+        let nas = 0;
+        let nbs = 0;
+        if (bs !== null && as === null) {
+            return -1;
+        }
+        if (as !== null && bs === null) {
+            return 1;
+        }
+        if (typeof as === 'number' && isNaN(as)) {
+            return -1;
+        }
+        if (typeof bs === 'number' && isNaN(bs)) {
+            return 1;
+        }
+        nas = +as;
+        nbs = +bs;
+        if (nas < nbs) {
+            return -1;
+        }
+        if (nas > nbs) {
+            return 1;
+        }
+        if (typeof as === 'number' && typeof bs !== 'number') {
+            return -1;
+        }
+        if (typeof bs === 'number' && typeof as !== 'number') {
+            return 1;
+        }
+        if (typeof as === 'number' && typeof bs === 'number') {
+            return 0;
+        }
+        if (isNaN(nbs) && !isNaN(nas)) {
+            return -1;
+        }
+        if (isNaN(nas) && !isNaN(nbs)) {
+            return 1;
+        }
+        a = String(as);
+        b = String(bs);
+        if (a === b) {
+            return 0;
+        }
+        if (!(rd.test(a) && rd.test(b))) {
+            return a > b ? 1 : -1;
+        }
+        a = a.match(rx);
+        b = b.match(rx);
+        while (a.length && b.length) {
+            a1 = a.shift();
+            b1 = b.shift();
+            if (a1 !== b1) {
+                if (rd.test(a1) && rd.test(b1)) {
+                    return a1.replace(rz, '.0') - b1.replace(rz, '.0');
+                }
+                return a1 > b1 ? 1 : -1;
+            }
+        }
+        return a.length - b.length;
+    }
+    function sortBy(order) {
+        let x;
+        const mapping = {};
+        const lowercase_mapping = {};
+        for (let i = 0; i < order.length; i++) {
+            x = order[i];
+            mapping[x] = i;
+            if (typeof x === 'string') {
+                lowercase_mapping[x.toLowerCase()] = i;
+            }
+        }
+        return function (a, b) {
+            if (mapping[a] !== null && mapping[a] !== undefined && mapping[b] !== null && mapping[b] !== undefined) {
+                return mapping[a] - mapping[b];
+            }
+            else if (mapping[a] !== null && mapping[a] !== undefined) {
+                return -1;
+            }
+            else if (mapping[b] !== null && mapping[b] !== undefined) {
+                return 1;
+            }
+            else if (lowercase_mapping[a] !== null &&
+                mapping[a] !== undefined &&
+                lowercase_mapping[b] !== null &&
+                mapping[b] !== undefined) {
+                return lowercase_mapping[a] - lowercase_mapping[b];
+            }
+            else if (lowercase_mapping[a] === null ||
+                mapping[a] === undefined ||
+                lowercase_mapping[b] === null ||
+                mapping[b] === undefined) {
+                return 0;
+            }
+            else if (lowercase_mapping[a] !== null && mapping[a] !== undefined) {
+                return -1;
+            }
+            else if (lowercase_mapping[b] !== null && mapping[b] !== undefined) {
+                return 1;
+            }
+            return naturalSort(a, b);
+        };
+    }
+
     function isFieldAssessor(field) {
         if (obj.isObject(field)) {
             const a = field;
@@ -31006,6 +31507,8 @@
         return isValid$1(mapIndex) ? mapIndex : index;
     }
     class DataSource extends EventTarget$1 {
+        dataConfig;
+        dataSourceObj;
         _get;
         _sourceLength;
         _source;
@@ -31023,11 +31526,18 @@
         }
         treeDataHierarchyState = new Map();
         beforeChangedRecordsMap = [];
-        constructor(obj, pagination, hierarchyExpandLevel) {
+        registedAggregators = {};
+        fieldAggregators = [];
+        layoutColumnObjects = [];
+        constructor(dataSourceObj, dataConfig, pagination, columnObjs, hierarchyExpandLevel) {
             super();
-            this._get = obj?.get.bind(obj) || undefined;
-            this._sourceLength = obj?.length || 0;
-            this._source = obj?.source ?? obj;
+            this.registerAggregators();
+            this.dataSourceObj = dataSourceObj;
+            this.dataConfig = dataConfig;
+            this._get = dataSourceObj?.get.bind(dataSourceObj) || undefined;
+            this.layoutColumnObjects = columnObjs;
+            this._source = this.processRecords(dataSourceObj?.source ?? dataSourceObj);
+            this._sourceLength = this._source?.length || 0;
             this.sortedIndexMap = new Map();
             this._currentPagerIndexedData = [];
             this.userPagination = pagination;
@@ -31061,6 +31571,76 @@
             }
             this.updatePagerData();
         }
+        registerAggregator(type, aggregator) {
+            this.registedAggregators[type] = aggregator;
+        }
+        registerAggregators() {
+            this.registerAggregator(AggregationType.RECORD, RecordAggregator);
+            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);
+            this.registerAggregator(AggregationType.NONE, NoneAggregator);
+            this.registerAggregator(AggregationType.CUSTOM, CustomAggregator);
+        }
+        _generateFieldAggragations() {
+            const columnObjs = this.layoutColumnObjects;
+            for (let i = 0; i < columnObjs?.length; i++) {
+                columnObjs[i].aggregator = null;
+                const field = columnObjs[i].field;
+                const aggragation = columnObjs[i].aggregation;
+                if (!aggragation) {
+                    continue;
+                }
+                if (Array.isArray(aggragation)) {
+                    for (let j = 0; j < aggragation.length; j++) {
+                        const item = aggragation[j];
+                        const aggregator = new this.registedAggregators[item.aggregationType](field, item.formatFun, true, item.aggregationFun);
+                        this.fieldAggregators.push(aggregator);
+                        if (!columnObjs[i].aggregator) {
+                            columnObjs[i].aggregator = [];
+                        }
+                        columnObjs[i].aggregator.push(aggregator);
+                    }
+                }
+                else {
+                    const aggregator = new this.registedAggregators[aggragation.aggregationType](field, aggragation.formatFun, true, aggragation.aggregationFun);
+                    this.fieldAggregators.push(aggregator);
+                    columnObjs[i].aggregator = aggregator;
+                }
+            }
+        }
+        processRecords(records) {
+            this._generateFieldAggragations();
+            const filteredRecords = [];
+            const isHasAggregation = this.fieldAggregators.length >= 1;
+            const isHasFilterRule = this.dataConfig?.filterRules?.length >= 1;
+            if (isHasFilterRule || isHasAggregation) {
+                for (let i = 0, len = records.length; i < len; i++) {
+                    const record = records[i];
+                    if (isHasFilterRule) {
+                        if (this.filterRecord(record)) {
+                            filteredRecords.push(record);
+                            isHasAggregation && this.processRecord(record);
+                        }
+                    }
+                    else if (isHasAggregation) {
+                        this.processRecord(record);
+                    }
+                }
+                if (isHasFilterRule) {
+                    return filteredRecords;
+                }
+            }
+            return records;
+        }
+        processRecord(record) {
+            for (let i = 0; i < this.fieldAggregators.length; i++) {
+                const aggregator = this.fieldAggregators[i];
+                aggregator.push(record);
+            }
+        }
         initChildrenNodeHierarchy(indexKey, hierarchyExpandLevel, currentLevel, nodeData) {
             if (currentLevel > hierarchyExpandLevel) {
                 return 0;
@@ -31422,6 +32002,49 @@
             this.updatePagerData();
             this.fireListeners(EVENT_TYPE.CHANGE_ORDER, null);
         }
+        filterRecord(record) {
+            let isReserved = true;
+            for (let i = 0; i < this.dataConfig.filterRules.length; i++) {
+                const filterRule = this.dataConfig?.filterRules[i];
+                if (filterRule.filterKey) {
+                    const filterValue = record[filterRule.filterKey];
+                    if (filterRule.filteredValues.indexOf(filterValue) === -1) {
+                        isReserved = false;
+                        break;
+                    }
+                }
+                else if (!filterRule.filterFunc?.(record)) {
+                    isReserved = false;
+                    break;
+                }
+            }
+            return isReserved;
+        }
+        updateFilterRulesForSorted(filterRules) {
+            this.dataConfig.filterRules = filterRules;
+            this._source = this.processRecords(this.dataSourceObj?.source ?? this.dataSourceObj);
+            this._sourceLength = this._source?.length || 0;
+            this.sortedIndexMap.clear();
+            this.currentIndexedData = Array.from({ length: this._sourceLength }, (_, i) => i);
+            if (!this.userPagination) {
+                this.pagination.perPageCount = this._sourceLength;
+                this.pagination.totalCount = this._sourceLength;
+            }
+        }
+        updateFilterRules(filterRules) {
+            this.dataConfig.filterRules = filterRules;
+            this._source = this.processRecords(this.dataSourceObj?.source ?? this.dataSourceObj);
+            this._sourceLength = this._source?.length || 0;
+            this.currentIndexedData = Array.from({ length: this._sourceLength }, (_, i) => i);
+            if (this.userPagination) {
+                this.updatePagerData();
+            }
+            else {
+                this.pagination.perPageCount = this._sourceLength;
+                this.pagination.totalCount = this._sourceLength;
+                this.updatePagerData();
+            }
+        }
         clearSortedIndexMap() {
             if (this.lastOrderField && this.lastOrder) {
                 this.sortedIndexMap.forEach((sortMap, key) => {
@@ -31482,6 +32105,9 @@
             this.currentPagerIndexedData.length = 0;
         }
         getOriginalRecord(dataIndex) {
+            if (this.dataConfig?.filterRules) {
+                return this.source[dataIndex];
+            }
             return getValue(this._get(dataIndex), (val) => {
                 this.recordPromiseCallBack(dataIndex, val);
             });
@@ -31543,7 +32169,7 @@
         static get EVENT_TYPE() {
             return DataSource.EVENT_TYPE;
         }
-        static ofArray(array, pagination, hierarchyExpandLevel) {
+        static ofArray(array, dataConfig, pagination, columnObjs, hierarchyExpandLevel) {
             return new CachedDataSource({
                 get: (index) => {
                     if (Array.isArray(index)) {
@@ -31553,10 +32179,10 @@
                 },
                 length: array.length,
                 source: array
-            }, pagination, hierarchyExpandLevel);
+            }, dataConfig, pagination, columnObjs, hierarchyExpandLevel);
         }
-        constructor(opt, pagination, hierarchyExpandLevel) {
-            super(opt, pagination, hierarchyExpandLevel);
+        constructor(opt, dataConfig, pagination, columnObjs, hierarchyExpandLevel) {
+            super(opt, dataConfig, pagination, columnObjs, hierarchyExpandLevel);
             this._recordCache = {};
             this._fieldCache = {};
         }
@@ -32076,7 +32702,7 @@
         _dealWithUpdateDataSource(table, () => {
             const data = records;
             table.internalProps.records = records;
-            const newDataSource = (table.internalProps.dataSource = CachedDataSource.ofArray(data, table.pagination, table.options.hierarchyExpandLevel ?? (table._hasHierarchyTreeHeader?.() ? 1 : undefined)));
+            const newDataSource = (table.internalProps.dataSource = CachedDataSource.ofArray(data, table.internalProps.dataConfig, table.pagination, table.internalProps.layoutMap.columnObjects, table.options.hierarchyExpandLevel ?? (table._hasHierarchyTreeHeader?.() ? 1 : undefined)));
             table.addReleaseObj(newDataSource);
         });
     }
@@ -32266,24 +32892,17 @@
         if (table.sortState) {
             let order;
             let field;
-            let fieldKey;
             if (Array.isArray(table.sortState)) {
                 if (table.sortState.length !== 0) {
-                    ({ order, field, fieldKey } = table.sortState?.[0]);
+                    ({ order, field } = table.sortState?.[0]);
                 }
             }
             else {
-                ({ order, field, fieldKey } = table.sortState);
+                ({ order, field } = table.sortState);
             }
             if (order && field && order !== 'normal') {
-                const sortFunc = table._getSortFuncFromHeaderOption(undefined, field, fieldKey);
-                let hd;
-                if (fieldKey) {
-                    hd = table.internalProps.layoutMap.headerObjects.find((col) => col && col.fieldKey === fieldKey);
-                }
-                else {
-                    hd = table.internalProps.layoutMap.headerObjects.find((col) => col && col.field === field);
-                }
+                const sortFunc = table._getSortFuncFromHeaderOption(undefined, field);
+                const hd = table.internalProps.layoutMap.headerObjects.find((col) => col && col.field === field);
                 table.dataSource.sort(hd.field, order, sortFunc ?? defaultOrderFn);
             }
         }
@@ -32602,11 +33221,13 @@
         activeChartInstance;
         active;
         cacheCanvas;
-        constructor(params) {
+        isShareChartSpec;
+        constructor(isShareChartSpec, params) {
             super(params);
             this.numberType = CHART_NUMBER_TYPE;
+            this.isShareChartSpec = isShareChartSpec;
             if (!params.chartInstance) {
-                params.chartInstance = this.chartInstance = new params.ClassType(params.spec, {
+                const chartInstance = new params.ClassType(params.spec, {
                     renderCanvas: params.canvas,
                     mode: this.attribute.mode === 'node' ? 'node' : 'desktop-browser',
                     modeParams: this.attribute.modeParams,
@@ -32617,7 +33238,8 @@
                     animation: false,
                     autoFit: false
                 });
-                this.chartInstance.renderSync();
+                chartInstance.renderSync();
+                params.chartInstance = this.chartInstance = chartInstance;
             }
             else {
                 this.chartInstance = params.chartInstance;
@@ -32742,7 +33364,7 @@
         return extend(builtin, chartTypes);
     }
 
-    function createChartCellGroup(cellGroup, columnGroup, xOrigin, yOrigin, col, row, width, height, padding, dataValue, chartModule, chartSpec, chartInstance, dataId, table, cellTheme) {
+    function createChartCellGroup(cellGroup, columnGroup, xOrigin, yOrigin, col, row, width, height, padding, dataValue, chartModule, chartSpec, chartInstance, dataId, table, cellTheme, isShareChartSpec) {
         const registerCharts = get$2();
         const ClassType = registerCharts[chartModule];
         const headerStyle = table._getCellStyle(col, row);
@@ -32773,7 +33395,7 @@
             columnGroup?.addCellGroup(cellGroup);
         }
         cellGroup.AABBBounds.width();
-        const chartGroup = new Chart({
+        const chartGroup = new Chart(isShareChartSpec, {
             stroke: false,
             x: padding[3],
             y: padding[0],
@@ -33177,7 +33799,9 @@
             if (image.resources &&
                 image.resources.has(image.attribute.image) &&
                 image.resources.get(image.attribute.image).state === 'success') {
-                updateAutoSizingAndKeepAspectRatio(imageAutoSizing, keepAspectRatio, padding, textAlign, textBaseline, image, cellGroup, table);
+                setTimeout(() => {
+                    updateAutoSizingAndKeepAspectRatio(imageAutoSizing, keepAspectRatio, padding, textAlign, textBaseline, image, cellGroup, table);
+                }, 0);
             }
             else {
                 image.successCallback = () => {
@@ -33205,11 +33829,10 @@
         cellGroup.appendChild(image);
         return cellGroup;
     }
-    function _adjustWidthHeight(col, row, width, height, scene, padding) {
+    function _adjustWidthHeight(col, row, width, height, scene, padding, cellGroup) {
         let needInvalidate = false;
         let targetWidth = null;
         let targetHeight = null;
-        const cellGroup = scene.getCell(col, row, true);
         const { width: cellWidth, height: cellHeight, isMerge } = getCellRange(cellGroup, scene.table);
         if (cellWidth < width + padding[1] + padding[3]) {
             targetWidth = width + padding[1] + padding[3];
@@ -33247,6 +33870,9 @@
     }
     function updateImageCellContentWhileResize(cellGroup, col, row, table) {
         const image = cellGroup.getChildByName('image');
+        if (!image) {
+            return;
+        }
         const originImage = (typeof image.attribute.image !== 'string' && image.attribute.image) ||
             image.resources?.get(image.attribute.image).data;
         if (!originImage) {
@@ -33329,7 +33955,7 @@
         const originImage = image.resources.get(image.attribute.image).data;
         const { col, row } = cellGroup;
         if (imageAutoSizing && !isDamagePic(image)) {
-            _adjustWidthHeight(col, row, originImage.width, originImage.height, table.scenegraph, padding);
+            _adjustWidthHeight(col, row, originImage.width, originImage.height, table.scenegraph, padding, cellGroup);
         }
         if (keepAspectRatio || isDamagePic(image)) {
             const { width: cellWidth, height: cellHeight, isMerge } = getCellRange(cellGroup, table);
@@ -34797,7 +35423,7 @@
         const video = document.createElement('video');
         video.addEventListener('loadeddata', () => {
             if (imageAutoSizing) {
-                _adjustWidthHeight(col, row, video.videoWidth, video.videoHeight, table.scenegraph, padding);
+                _adjustWidthHeight(col, row, video.videoWidth, video.videoHeight, table.scenegraph, padding, cellGroup);
             }
             const width = cellGroup.attribute.width;
             const height = cellGroup.attribute.height;
@@ -35123,9 +35749,7 @@
         }
         else if (type === 'chart') {
             const chartInstance = table.internalProps.layoutMap.getChartInstance(col, row);
-            cellGroup = createChartCellGroup(null, columnGroup, 0, y, col, row, cellWidth, cellHeight, padding, value, define.chartModule, table.isPivotChart()
-                ? table.internalProps.layoutMap.getChartSpec(col, row)
-                : define.chartSpec, chartInstance, table.internalProps.layoutMap?.getChartDataId(col, row) ?? 'data', table, cellTheme);
+            cellGroup = createChartCellGroup(null, columnGroup, 0, y, col, row, cellWidth, cellHeight, padding, value, define.chartModule, table.internalProps.layoutMap.getChartSpec(col, row), chartInstance, table.internalProps.layoutMap.getChartDataId(col, row) ?? 'data', table, cellTheme, table.internalProps.layoutMap.isShareChartSpec(col, row));
         }
         else if (type === 'progressbar') {
             const style = table._getCellStyle(col, row);
@@ -35243,9 +35867,8 @@
                     dx: hierarchyOffset,
                     x
                 };
-                const oldText = textMark.attribute.text;
                 textMark.setAttributes(cellTheme.text ? Object.assign({}, cellTheme.text, attribute) : attribute);
-                if (!oldText && textMark.attribute.text) {
+                if (textMark.attribute.text) {
                     const textBaseline = cellTheme.text.textBaseline;
                     const height = cellHeight - (padding[0] + padding[2]);
                     let y = 0;
@@ -35273,8 +35896,8 @@
             : table.getBodyColumnType(col, row);
         const mayHaveIcon = cellLocation !== 'body' ? true : !!define?.icon || !!define?.tree;
         const padding = cellTheme._vtable.padding;
-        const textAlign = cellTheme._vtable.textAlign;
-        const textBaseline = cellTheme._vtable.textBaseline;
+        const textAlign = cellTheme.text.textAlign;
+        const textBaseline = cellTheme.text.textBaseline;
         let newCellGroup;
         let bgColorFunc;
         if (table.internalProps?.dataConfig?.mappingRules && !table.isHeader(col, row)) {
@@ -35304,13 +35927,11 @@
             newCellGroup = updateCellContent(type, value, define, table, col, row, bgColorFunc, cellWidth, cellHeight, oldCellGroup, padding, textAlign, textBaseline, mayHaveIcon, addNew, cellTheme, range, customResult);
         }
         if (isMerge) {
-            const rangeHeight = table.getRowHeight(row);
-            const rangeWidth = table.getColWidth(col);
             const { width: contentWidth } = newCellGroup.attribute;
             const { height: contentHeight } = newCellGroup.attribute;
             newCellGroup.contentWidth = contentWidth;
             newCellGroup.contentHeight = contentHeight;
-            resizeCellGroup(newCellGroup, rangeWidth, rangeHeight, range, table);
+            dealWithMergeCellSize(range, cellWidth, cellHeight, padding, textAlign, textBaseline, table);
         }
         return newCellGroup;
     }
@@ -35349,6 +35970,24 @@
         }
         return false;
     }
+    function dealWithMergeCellSize(range, cellWidth, cellHeight, padding, textAlign, textBaseline, table) {
+        for (let col = range.start.col; col <= range.end.col; col++) {
+            for (let row = range.start.row; row <= range.end.row; row++) {
+                const cellGroup = table.scenegraph.getCell(col, row, true);
+                if (range.start.row !== range.end.row) {
+                    updateCellContentHeight(cellGroup, cellHeight, cellHeight, table.heightMode === 'autoHeight', padding, textAlign, textBaseline);
+                }
+                if (range.start.col !== range.end.col) {
+                    updateCellContentWidth(cellGroup, cellWidth, cellHeight, 0, table.heightMode === 'autoHeight', padding, textAlign, textBaseline, table.scenegraph);
+                }
+                cellGroup.contentWidth = cellWidth;
+                cellGroup.contentHeight = cellHeight;
+                const rangeHeight = table.getRowHeight(row);
+                const rangeWidth = table.getColWidth(col);
+                resizeCellGroup(cellGroup, rangeWidth, rangeHeight, range, table);
+            }
+        }
+    }
 
     function createComplexColumn(columnGroup, col, colWidth, rowStart, rowEnd, mergeMap, defaultRowHeight, table, cellLocation, rowLimit) {
         let padding;
@@ -35377,7 +36016,8 @@
                     range = customMergeRange;
                     isMerge = range.start.col !== range.end.col || range.start.row !== range.end.row;
                     if (isMerge) {
-                        const mergeSize = dealMerge(range, mergeMap, table);
+                        const needUpdateRange = rowStart > range.start.row;
+                        const mergeSize = dealMerge(range, mergeMap, table, needUpdateRange);
                         cellWidth = mergeSize.cellWidth;
                         cellHeight = mergeSize.cellHeight;
                     }
@@ -35402,7 +36042,8 @@
                 range = table.getCellRange(col, row);
                 isMerge = range.start.col !== range.end.col || range.start.row !== range.end.row;
                 if (isMerge) {
-                    const mergeSize = dealMerge(range, mergeMap, table);
+                    const needUpdateRange = rowStart > range.start.row;
+                    const mergeSize = dealMerge(range, mergeMap, table, needUpdateRange);
                     cellWidth = mergeSize.cellWidth;
                     cellHeight = mergeSize.cellHeight;
                 }
@@ -35503,11 +36144,11 @@
             heightChange
         };
     }
-    function dealMerge(range, mergeMap, table) {
+    function dealMerge(range, mergeMap, table, forceUpdate) {
         let cellWidth = 0;
         let cellHeight = 0;
         const mergeResult = mergeMap.get(`${range.start.col},${range.start.row};${range.end.col},${range.end.row}`);
-        if (!mergeResult) {
+        if (!mergeResult || forceUpdate) {
             for (let col = range.start.col; col <= range.end.col; col++) {
                 cellWidth += table.getColWidth(col);
             }
@@ -39221,6 +39862,11 @@
         const { viewWidth, viewHeight } = stage;
         if (viewWidth < cacheCanvasSizeLimit && viewHeight < cacheCanvasSizeLimit) {
             chart.cacheCanvas = stage.toCanvas();
+            if (!chart.isShareChartSpec) {
+                chart.chartInstance?.release();
+                chart.chartInstance = null;
+                chart.setAttribute('chartInstance', null);
+            }
             return;
         }
         const rows = Math.ceil(viewHeight / cacheCanvasSizeLimit);
@@ -39258,7 +39904,7 @@
             const { dataId, data, spec } = chart.attribute;
             chart.getViewBox();
             const { width = groupAttribute.width, height = groupAttribute.height } = chart.attribute;
-            const { chartInstance, active, cacheCanvas, activeChartInstance } = chart;
+            const { active, cacheCanvas, activeChartInstance } = chart;
             if (!active && cacheCanvas) {
                 if (isArray$1(cacheCanvas)) {
                     cacheCanvas.forEach(singleCacheCanvas => {
@@ -39288,7 +39934,7 @@
                                 : data ?? [],
                             fields: series?.data?.fields
                         });
-                        if (!chartInstance.updateFullDataSync) {
+                        if (!activeChartInstance.updateFullDataSync) {
                             activeChartInstance.updateDataSync(dataIdStr, dataIdAndField
                                 ? data?.filter((item) => {
                                     return item.hasOwnProperty(dataIdAndField);
@@ -41249,7 +41895,12 @@
             syncTopRow = Math.max(proxy.bodyTopRow, proxy.screenTopRow - proxy.screenRowCount * 1);
             syncBottomRow = Math.min(proxy.bodyBottomRow, proxy.screenTopRow + proxy.screenRowCount * 2);
         }
+        const oldBodyHeight = proxy.table.getAllRowsHeight();
         computeRowsHeight(proxy.table, syncTopRow, syncBottomRow);
+        const newBodyHeight = proxy.table.getAllRowsHeight();
+        if (oldBodyHeight !== newBodyHeight) {
+            proxy.table.scenegraph.updateContainerHeight(proxy.table.frozenRowCount, newBodyHeight - oldBodyHeight);
+        }
         updateRowContent(syncTopRow, syncBottomRow, proxy);
         if (proxy.table.heightMode === 'autoHeight') {
             updateAutoRow(proxy.bodyLeftCol, proxy.bodyRightCol, syncTopRow, syncBottomRow, proxy.table, proxy.rowEnd > proxy.bodyBottomRow - (proxy.rowEnd - proxy.rowStart + 1) ? 'down' : 'up');
@@ -44248,7 +44899,7 @@
             initSceneGraph(this);
         }
         clearCells() {
-            if (this.table.isPivotChart() || this.table.hasCustomRenderOrLayout()) {
+            if (this.table.isPivotChart() || this.table._hasCustomRenderOrLayout()) {
                 this.stage.pluginService.findPluginsByName('poptipForText').forEach(plugin => {
                     plugin.deactivate(this.stage.pluginService);
                 });
@@ -44348,7 +44999,7 @@
             this.component.updateStyle();
         }
         createSceneGraph() {
-            if (this.table.isPivotChart() || this.table.hasCustomRenderOrLayout()) {
+            if (this.table.isPivotChart() || this.table._hasCustomRenderOrLayout()) {
                 this.stage.pluginService.autoEnablePlugins.getContributions().forEach((p) => {
                     if (p.name === 'poptipForText') {
                         this.stage.pluginService.register(p);
@@ -45088,11 +45739,7 @@
         updateContainer() {
             this.updateContainerAttrWidthAndX();
             this.updateTableSize();
-            const oldHorizontalBarPos = this.table.stateManager.scroll.horizontalBarPos;
-            const oldVerticalBarPos = this.table.stateManager.scroll.verticalBarPos;
             this.component.updateScrollBar();
-            this.table.stateManager.setScrollLeft(oldHorizontalBarPos);
-            this.table.stateManager.setScrollTop(oldVerticalBarPos);
             this.updateNextFrame();
         }
         updateCellContentWhileResize(col, row) {
@@ -45540,7 +46187,6 @@
         }
         else if (headerC?.sort) {
             tableState = {
-                fieldKey: table.getHeaderFieldKey(col, row),
                 field: table.getHeaderField(col, row),
                 order: 'asc'
             };
@@ -45548,7 +46194,6 @@
         else if (isTargetCell && headerC?.showSort) ;
         else {
             tableState = {
-                fieldKey: table.getHeaderFieldKey(col, row),
                 field: table.getHeaderField(col, row),
                 order: 'normal'
             };
@@ -45567,13 +46212,7 @@
         table.stateManager.updateSelectPos(-1, -1);
     }
     function executeSort(newState, table, headerDefine) {
-        let hd;
-        if (newState.fieldKey) {
-            hd = table.internalProps.layoutMap.headerObjects.find((col) => col && col.fieldKey === newState.fieldKey);
-        }
-        else {
-            hd = table.internalProps.layoutMap.headerObjects.find((col) => col && col.field === newState.field);
-        }
+        const hd = table.internalProps.layoutMap.headerObjects.find((col) => col && col.field === newState.field);
         if (!hd) {
             return;
         }
@@ -46462,7 +47101,6 @@
         }
         setSortState(sortState) {
             this.sort.field = sortState?.field;
-            this.sort.fieldKey = sortState?.fieldKey;
             this.sort.order = sortState?.order;
         }
         setFrozenState() {
@@ -51570,6 +52208,7 @@
             return this.data.size;
         }
         clear() {
+            this._keys = [];
             this.data.clear();
             this.cumulativeSum.clear();
             this.difference.clear();
@@ -51814,7 +52453,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "0.19.2-alpha.3";
+        version = "0.20.0";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -53214,6 +53853,9 @@
             this.setScrollTop(scrollTop);
             this.setScrollLeft(scrollLeft);
         }
+        get recordsCount() {
+            return this.records?.length;
+        }
         get allowFrozenColCount() {
             return this.internalProps.allowFrozenColCount;
         }
@@ -53297,9 +53939,6 @@
         getHeaderField(col, row) {
             return this.internalProps.layoutMap.getHeaderField(col, row);
         }
-        getHeaderFieldKey(col, row) {
-            return this.internalProps.layoutMap.getHeaderFieldKey(col, row);
-        }
         getHeaderDefine(col, row) {
             const hd = this.internalProps.layoutMap.getHeader(col, row);
             return hd?.define;
@@ -53349,13 +53988,7 @@
         }
         _getHeaderCellBySortState(sortState) {
             const { layoutMap } = this.internalProps;
-            let hd;
-            if (sortState.fieldKey) {
-                hd = layoutMap.headerObjects.find((col) => col && col.fieldKey === sortState.fieldKey);
-            }
-            else {
-                hd = layoutMap.headerObjects.find((col) => col && col.field === sortState.field);
-            }
+            const hd = layoutMap.headerObjects.find((col) => col && col.field === sortState.field);
             if (hd) {
                 const headercell = layoutMap.getHeaderCellAdressById(hd.id);
                 return headercell;
@@ -54333,8 +54966,36 @@
             indicatorObj = layout.columnObjects.find(indicator => indicator.indicatorKey === indicatorKey);
         }
         const chartSpec = indicatorObj?.chartSpec;
+        if (typeof chartSpec === 'function') {
+            const arg = {
+                col,
+                row,
+                dataValue: layout._table.getCellOriginValue(col, row) || '',
+                value: layout._table.getCellValue(col, row) || '',
+                rect: layout._table.getCellRangeRelativeRect(layout._table.getCellRange(col, row)),
+                table: layout._table
+            };
+            return chartSpec(arg);
+        }
         return chartSpec;
     }
+    function isShareChartSpec(col, row, layout) {
+        const paths = layout.getCellHeaderPaths(col, row);
+        let indicatorObj;
+        if (layout.indicatorsAsCol) {
+            const indicatorKey = paths.colHeaderPaths.find(colPath => colPath.indicatorKey)?.indicatorKey;
+            indicatorObj = layout.columnObjects.find(indicator => indicator.indicatorKey === indicatorKey);
+        }
+        else {
+            const indicatorKey = paths.rowHeaderPaths.find(rowPath => rowPath.indicatorKey)?.indicatorKey;
+            indicatorObj = layout.columnObjects.find(indicator => indicator.indicatorKey === indicatorKey);
+        }
+        const chartSpec = indicatorObj?.chartSpec;
+        if (typeof chartSpec === 'function') {
+            return false;
+        }
+        return true;
+    }
     function checkHasCartesianChart(layout) {
         let isHasCartesianChart = false;
         for (let i = 0; i < layout.indicatorsDefine.length; i++) {
@@ -54394,16 +55055,19 @@
     function getChartSpec(col, row, layout) {
         let chartSpec = layout.getRawChartSpec(col, row);
         if (chartSpec) {
-            chartSpec = cloneDeep(chartSpec);
-            chartSpec.sortDataByAxis = true;
-            if (isArray$1(chartSpec.series)) {
-                chartSpec.series.forEach((serie) => {
-                    serie.sortDataByAxis = true;
-                });
+            if (layout._table.isPivotChart()) {
+                chartSpec = cloneDeep(chartSpec);
+                chartSpec.sortDataByAxis = true;
+                if (isArray$1(chartSpec.series)) {
+                    chartSpec.series.forEach((serie) => {
+                        serie.sortDataByAxis = true;
+                    });
+                }
+                chartSpec.axes = layout.getChartAxes(col, row);
+                chartSpec.padding = 0;
+                chartSpec.dataZoom = [];
+                return chartSpec;
             }
-            chartSpec.axes = layout.getChartAxes(col, row);
-            chartSpec.padding = 0;
-            chartSpec.dataZoom = [];
             return chartSpec;
         }
         return null;
@@ -54589,6 +55253,49 @@
         return isHasChart;
     }
 
+    function checkHasAggregation(layoutMap) {
+        const columnObjects = layoutMap.columnObjects;
+        for (let i = 0; i < columnObjects.length; i++) {
+            const column = columnObjects[i];
+            if (column?.aggregation) {
+                return true;
+            }
+        }
+        return false;
+    }
+    function checkHasAggregationOnTop(layoutMap) {
+        const columnObjects = layoutMap.columnObjects;
+        let count = 0;
+        for (let i = 0; i < columnObjects.length; i++) {
+            const column = columnObjects[i];
+            if (column?.aggregation) {
+                if (Array.isArray(column?.aggregation)) {
+                    count = Math.max(count, column.aggregation.filter(item => item.showOnTop === true).length);
+                }
+                else if (column.aggregation.showOnTop === true) {
+                    count = Math.max(count, 1);
+                }
+            }
+        }
+        return count;
+    }
+    function checkHasAggregationOnBottom(layoutMap) {
+        const columnObjects = layoutMap.columnObjects;
+        let count = 0;
+        for (let i = 0; i < columnObjects.length; i++) {
+            const column = columnObjects[i];
+            if (column?.aggregation) {
+                if (Array.isArray(column?.aggregation)) {
+                    count = Math.max(count, column.aggregation.filter(item => item.showOnTop === false).length);
+                }
+                else if (column.aggregation.showOnTop === false) {
+                    count = Math.max(count, 1);
+                }
+            }
+        }
+        return count;
+    }
+
     class DimensionTree {
         sharedVar;
         sizeIncludeParent = false;
@@ -55014,6 +55721,9 @@
         _showHeader = true;
         _recordsCount = 0;
         _table;
+        _hasAggregation = false;
+        _hasAggregationOnTopCount = 0;
+        _hasAggregationOnBottomCount = 0;
         _cellRangeMap;
         constructor(table, columns, showHeader, hierarchyIndent) {
             this._cellRangeMap = new Map();
@@ -55028,6 +55738,9 @@
                 o[e.id] = e;
                 return o;
             }, {});
+            this._hasAggregation = checkHasAggregation(this);
+            this._hasAggregationOnBottomCount = checkHasAggregationOnBottom(this);
+            this._hasAggregationOnTopCount = checkHasAggregationOnTop(this);
         }
         get transpose() {
             return this._transpose;
@@ -55050,6 +55763,153 @@
             }
             return false;
         }
+        isAggregation(col, row) {
+            if (this.hasAggregation) {
+                if (this.hasAggregationOnBottomCount) {
+                    if (this.transpose) {
+                        if (col >= this.colCount - this.hasAggregationOnBottomCount) {
+                            return true;
+                        }
+                    }
+                    else {
+                        if (row >= this.rowCount - this.hasAggregationOnBottomCount) {
+                            return true;
+                        }
+                    }
+                }
+                if (this.hasAggregationOnTopCount) {
+                    if (this.transpose) {
+                        if (col >= this.rowHeaderLevelCount && col < this.rowHeaderLevelCount + this.hasAggregationOnTopCount) {
+                            return true;
+                        }
+                    }
+                    else {
+                        if (row >= this.columnHeaderLevelCount && row < this.columnHeaderLevelCount + this.hasAggregationOnTopCount) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+        isTopAggregation(col, row) {
+            if (this.hasAggregationOnTopCount) {
+                if (this.transpose) {
+                    if (col >= this.rowHeaderLevelCount && col < this.rowHeaderLevelCount + this.hasAggregationOnTopCount) {
+                        return true;
+                    }
+                }
+                else {
+                    if (row >= this.columnHeaderLevelCount && row < this.columnHeaderLevelCount + this.hasAggregationOnTopCount) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        isBottomAggregation(col, row) {
+            if (this.hasAggregationOnBottomCount) {
+                if (this.transpose) {
+                    if (col >= this.colCount - this.hasAggregationOnBottomCount) {
+                        return true;
+                    }
+                }
+                else {
+                    if (row >= this.rowCount - this.hasAggregationOnBottomCount) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        get hasAggregation() {
+            return this._hasAggregation;
+        }
+        get hasAggregationOnTopCount() {
+            return this._hasAggregationOnTopCount;
+        }
+        get hasAggregationOnBottomCount() {
+            return this._hasAggregationOnBottomCount;
+        }
+        getAggregators(col, row) {
+            const column = this.getBody(col, row);
+            const aggregators = column.aggregator;
+            return aggregators;
+        }
+        getAggregatorOnTop(col, row) {
+            const column = this.getBody(col, row);
+            const aggregators = column.aggregator;
+            const aggregation = column.aggregation;
+            if (Array.isArray(aggregation)) {
+                const topAggregationIndexs = aggregation.reduce((indexs, agg, index) => {
+                    if (agg.showOnTop) {
+                        indexs.push(index);
+                    }
+                    return indexs;
+                }, []);
+                const topAggregators = topAggregationIndexs.map(index => aggregators[index]);
+                if (this.transpose) {
+                    return topAggregators[col - this.rowHeaderLevelCount];
+                }
+                return topAggregators[row - this.columnHeaderLevelCount];
+            }
+            if (this.transpose && col - this.rowHeaderLevelCount === 0) {
+                return aggregation?.showOnTop ? aggregators : null;
+            }
+            else if (!this.transpose && row - this.columnHeaderLevelCount === 0) {
+                return aggregation?.showOnTop ? aggregators : null;
+            }
+            return null;
+        }
+        getAggregatorOnBottom(col, row) {
+            const column = this.getBody(col, row);
+            const aggregators = column.aggregator;
+            const aggregation = column.aggregation;
+            if (Array.isArray(aggregation)) {
+                const bottomAggregationIndexs = aggregation.reduce((indexs, agg, index) => {
+                    if (agg.showOnTop === false) {
+                        indexs.push(index);
+                    }
+                    return indexs;
+                }, []);
+                const bottomAggregators = bottomAggregationIndexs.map(index => aggregators[index]);
+                if (this.transpose) {
+                    return bottomAggregators[col - (this.colCount - this.hasAggregationOnBottomCount)];
+                }
+                return bottomAggregators[row - (this.rowCount - this.hasAggregationOnBottomCount)];
+            }
+            if (this.transpose && col - (this.colCount - this.hasAggregationOnBottomCount) === 0) {
+                return aggregation?.showOnTop === false ? aggregators : null;
+            }
+            else if (!this.transpose && row - (this.rowCount - this.hasAggregationOnBottomCount) === 0) {
+                return aggregation?.showOnTop === false ? aggregators : null;
+            }
+            return null;
+        }
+        getCellAddressHasAggregator(col, row) {
+            const cellAddrs = [];
+            if (this.transpose) {
+                const topCount = this.hasAggregationOnTopCount;
+                for (let i = 0; i < topCount; i++) {
+                    cellAddrs.push({ col: this.headerLevelCount + i, row });
+                }
+                const bottomCount = this.hasAggregationOnBottomCount;
+                for (let i = 0; i < bottomCount; i++) {
+                    cellAddrs.push({ col: this.rowCount - bottomCount + i, row });
+                }
+            }
+            else {
+                const topCount = this.hasAggregationOnTopCount;
+                for (let i = 0; i < topCount; i++) {
+                    cellAddrs.push({ col, row: this.headerLevelCount + i });
+                }
+                const bottomCount = this.hasAggregationOnBottomCount;
+                for (let i = 0; i < bottomCount; i++) {
+                    cellAddrs.push({ col, row: this.rowCount - bottomCount + i });
+                }
+            }
+            return cellAddrs;
+        }
         getCellLocation(col, row) {
             if (this.isHeader(col, row)) {
                 if (this.transpose) {
@@ -55319,11 +56179,6 @@
             const id = this.getCellId(col, row);
             return this._headerObjectMap[id];
         }
-        getHeaderFieldKey(col, row) {
-            const id = this.getCellId(col, row);
-            return (this._headerObjectMap[id]?.fieldKey ||
-                (this.transpose ? this._columns[row]?.fieldKey : this._columns[col]?.fieldKey));
-        }
         getHeaderField(col, row) {
             const id = this.getCellId(col, row);
             return (this._headerObjectMap[id]?.field ||
@@ -55531,19 +56386,21 @@
                 range1.end.row === range2.end.row);
         }
         getRecordIndexByCell(col, row) {
+            const skipRowCount = this.hasAggregationOnTopCount ? this.headerLevelCount + 1 : this.headerLevelCount;
             if (this.transpose) {
-                if (col < this.headerLevelCount) {
+                if (col < skipRowCount) {
                     return -1;
                 }
-                return col - this.headerLevelCount;
+                return col - skipRowCount;
             }
-            if (row < this.headerLevelCount) {
+            if (row < skipRowCount) {
                 return -1;
             }
-            return row - this.headerLevelCount;
+            return row - skipRowCount;
         }
         getRecordStartRowByRecordIndex(index) {
-            return this.headerLevelCount + index;
+            const skipRowCount = this.hasAggregationOnTopCount ? this.headerLevelCount + 1 : this.headerLevelCount;
+            return skipRowCount + index;
         }
         _addHeaders(row, column, roots, hideColumnsSubHeader) {
             const results = [];
@@ -55556,8 +56413,6 @@
                     title: hd.title ?? hd.caption,
                     headerIcon: hd.headerIcon,
                     field: hd.field,
-                    fieldKey: hd?.fieldKey,
-                    fieldFormat: hd.fieldFormat,
                     style: hd.headerStyle,
                     headerType: hd.headerType ?? 'text',
                     dropDownMenu: hd.dropDownMenu,
@@ -55582,7 +56437,6 @@
                     this._columns.push({
                         id: this.seqId++,
                         field: colDef.field,
-                        fieldKey: colDef.fieldKey,
                         fieldFormat: colDef.fieldFormat,
                         width: colDef.width,
                         minWidth: colDef.minWidth,
@@ -55595,7 +56449,8 @@
                         style: colDef.style,
                         define: colDef,
                         columnWidthComputeMode: colDef.columnWidthComputeMode,
-                        disableColumnResize: colDef?.disableColumnResize
+                        disableColumnResize: colDef?.disableColumnResize,
+                        aggregation: this._getAggregationForColumn(colDef, col)
                     });
                     for (let r = row + 1; r < this._headerCellIds.length; r++) {
                         this._headerCellIds[r][col] = id;
@@ -55604,6 +56459,35 @@
             });
             return results;
         }
+        _getAggregationForColumn(colDef, col) {
+            let aggregation;
+            if (colDef.aggregation) {
+                aggregation = colDef.aggregation;
+            }
+            else if (this._table.options.aggregation) {
+                if (typeof this._table.options.aggregation === 'function') {
+                    aggregation = this._table.options.aggregation({
+                        col: col,
+                        field: colDef.field
+                    });
+                }
+                else {
+                    aggregation = this._table.options.aggregation;
+                }
+            }
+            if (aggregation) {
+                if (Array.isArray(aggregation)) {
+                    return aggregation.map(item => {
+                        if (!isValid$1(item.showOnTop)) {
+                            item.showOnTop = false;
+                        }
+                        return item;
+                    });
+                }
+                return Object.assign({ showOnTop: false }, aggregation);
+            }
+            return null;
+        }
         _newRow(row, hideColumnsSubHeader = false) {
             if (this._headerCellIds[row]) {
                 const prev = this._headerCellIds[row - 1];
@@ -55764,6 +56648,9 @@
         }
         setChartInstance(_col, _row, chartInstance) {
             const columnObj = this.transpose ? this._columns[_row] : this._columns[_col];
+            if (typeof columnObj.chartSpec === 'function') {
+                return;
+            }
             columnObj.chartInstance = chartInstance;
         }
         getChartInstance(_col, _row) {
@@ -55785,9 +56672,32 @@
         getChartAxes(col, row) {
             return [];
         }
+        isShareChartSpec(col, row) {
+            const body = this.getBody(col, row);
+            const chartSpec = body?.chartSpec;
+            if (typeof chartSpec === 'function') {
+                return false;
+            }
+            return true;
+        }
+        getChartSpec(col, row) {
+            return this.getRawChartSpec(col, row);
+        }
         getRawChartSpec(col, row) {
             const body = this.getBody(col, row);
-            return body?.chartSpec;
+            const chartSpec = body?.chartSpec;
+            if (typeof chartSpec === 'function') {
+                const arg = {
+                    col,
+                    row,
+                    dataValue: this._table.getCellOriginValue(col, row) || '',
+                    value: this._table.getCellValue(col, row) || '',
+                    rect: this._table.getCellRangeRelativeRect(this._table.getCellRange(col, row)),
+                    table: this._table
+                };
+                return chartSpec(arg);
+            }
+            return chartSpec;
         }
         getChartDataId(col, row) {
             return getChartDataId(col, row, this);
@@ -55807,6 +56717,15 @@
             define.title = title;
             define.define.title = title;
         }
+        getColumnByField(field) {
+            const result = this.columnObjects?.reduce((pre, cur, index) => {
+                if (cur.field === field) {
+                    pre.push({ col: index, columnDefine: cur });
+                }
+                return pre;
+            }, []);
+            return result;
+        }
     }
 
     class Title {
@@ -55993,6 +56912,9 @@
                         return;
                     }
                 }
+                if (this.table.internalProps.layoutMap?.isAggregation?.(col, row)) {
+                    return;
+                }
                 this.editingEditor = editor;
                 this.editCell = { col, row };
                 const dataValue = this.table.getCellOriginValue(col, row);
@@ -56069,6 +56991,7 @@
             internalProps.frozenColDragHeaderMode = options.frozenColDragHeaderMode;
             this.pagination = options.pagination;
             internalProps.sortState = options.sortState;
+            internalProps.dataConfig = {};
             internalProps.columns = options.columns
                 ? cloneDeep(options.columns)
                 : options.header
@@ -56114,6 +57037,12 @@
         get sortState() {
             return this.internalProps.sortState;
         }
+        get records() {
+            return this.dataSource.source;
+        }
+        get recordsCount() {
+            return this.dataSource.source.length;
+        }
         updateColumns(columns) {
             const oldHoverState = { col: this.stateManager.hover.cellPos.col, row: this.stateManager.hover.cellPos.row };
             this.internalProps.columns = cloneDeep(columns);
@@ -56174,6 +57103,16 @@
                 const { title } = table.internalProps.layoutMap.getHeader(col, row);
                 return typeof title === 'function' ? title() : title;
             }
+            else if (table.internalProps.layoutMap.isAggregation(col, row)) {
+                if (table.internalProps.layoutMap.isTopAggregation(col, row)) {
+                    const aggregator = table.internalProps.layoutMap.getAggregatorOnTop(col, row);
+                    return aggregator?.formatValue ? aggregator.formatValue(col, row, this) : '';
+                }
+                else if (table.internalProps.layoutMap.isBottomAggregation(col, row)) {
+                    const aggregator = table.internalProps.layoutMap.getAggregatorOnBottom(col, row);
+                    return aggregator?.formatValue ? aggregator.formatValue(col, row, this) : '';
+                }
+            }
             const { field, fieldFormat } = table.internalProps.layoutMap.getBody(col, row);
             return table.getFieldData(fieldFormat || field, col, row);
         }
@@ -56186,6 +57125,16 @@
                 const { title } = table.internalProps.layoutMap.getHeader(col, row);
                 return typeof title === 'function' ? title() : title;
             }
+            else if (table.internalProps.layoutMap.isAggregation(col, row)) {
+                if (table.internalProps.layoutMap.isTopAggregation(col, row)) {
+                    const aggregator = table.internalProps.layoutMap.getAggregatorOnTop(col, row);
+                    return aggregator?.value();
+                }
+                else if (table.internalProps.layoutMap.isBottomAggregation(col, row)) {
+                    const aggregator = table.internalProps.layoutMap.getAggregatorOnBottom(col, row);
+                    return aggregator?.value();
+                }
+            }
             const { field } = table.internalProps.layoutMap.getBody(col, row);
             return table.getFieldData(field, col, row);
         }
@@ -56258,6 +57207,7 @@
             super.updateOption(options);
             internalProps.frozenColDragHeaderMode = options.frozenColDragHeaderMode;
             this.pagination = options.pagination;
+            internalProps.dataConfig = {};
             this.showHeader = options.showHeader ?? true;
             internalProps.columns = options.columns
                 ? cloneDeep(options.columns)
@@ -56337,11 +57287,13 @@
             if (!layoutMap) {
                 return;
             }
-            layoutMap.recordsCount = table.internalProps.dataSource?.length ?? 0;
+            layoutMap.recordsCount =
+                (table.internalProps.dataSource?.length ?? 0) +
+                    layoutMap.hasAggregationOnTopCount +
+                    layoutMap.hasAggregationOnBottomCount;
             if (table.transpose) {
                 table.rowCount = layoutMap.rowCount ?? 0;
-                table.colCount =
-                    (table.internalProps.dataSource?.length ?? 0) * layoutMap.bodyRowSpanCount + layoutMap.headerLevelCount;
+                table.colCount = layoutMap.recordsCount * layoutMap.bodyRowSpanCount + layoutMap.headerLevelCount;
                 table.frozenRowCount = 0;
                 this.internalProps.frozenColCount = layoutMap.headerLevelCount ?? 0;
                 if (table.bottomFrozenRowCount !== (this.options.bottomFrozenRowCount ?? 0)) {
@@ -56353,8 +57305,7 @@
             }
             else {
                 table.colCount = layoutMap.colCount ?? 0;
-                table.rowCount =
-                    (table.internalProps.dataSource?.length ?? 0) * layoutMap.bodyRowSpanCount + layoutMap.headerLevelCount;
+                table.rowCount = layoutMap.recordsCount * layoutMap.bodyRowSpanCount + layoutMap.headerLevelCount;
                 this.internalProps.frozenColCount = this.options.frozenColCount ?? 0;
                 table.frozenRowCount = layoutMap.headerLevelCount;
                 if (table.bottomFrozenRowCount !== (this.options.bottomFrozenRowCount ?? 0)) {
@@ -56602,22 +57553,15 @@
             }
             let order;
             let field;
-            let fieldKey;
             if (Array.isArray(this.internalProps.sortState)) {
-                ({ order, field, fieldKey } = this.internalProps.sortState?.[0]);
+                ({ order, field } = this.internalProps.sortState?.[0]);
             }
             else {
-                ({ order, field, fieldKey } = this.internalProps.sortState);
+                ({ order, field } = this.internalProps.sortState);
             }
             if (field && executeSort) {
-                const sortFunc = this._getSortFuncFromHeaderOption(this.internalProps.columns, field, fieldKey);
-                let hd;
-                if (fieldKey) {
-                    hd = this.internalProps.layoutMap.headerObjects.find((col) => col && col.fieldKey === fieldKey);
-                }
-                else {
-                    hd = this.internalProps.layoutMap.headerObjects.find((col) => col && col.field === field);
-                }
+                const sortFunc = this._getSortFuncFromHeaderOption(this.internalProps.columns, field);
+                const hd = this.internalProps.layoutMap.headerObjects.find((col) => col && col.field === field);
                 if (hd.define.sort !== false) {
                     this.dataSource.sort(hd.field, order, sortFunc);
                     this.internalProps.layoutMap.clearCellRangeMap();
@@ -56626,6 +57570,19 @@
             }
             this.stateManager.updateSortState(sortState);
         }
+        updateFilterRules(filterRules) {
+            this.scenegraph.clearCells();
+            this.internalProps.dataConfig.filterRules = filterRules;
+            if (this.sortState) {
+                this.dataSource.updateFilterRulesForSorted(filterRules);
+                sortRecords(this);
+            }
+            else {
+                this.dataSource.updateFilterRules(filterRules);
+            }
+            this.refreshRowColCount();
+            this.scenegraph.createSceneGraph();
+        }
         getCheckboxState(field) {
             if (this.stateManager.checkedState.length < this.rowCount - this.columnHeaderLevelCount) {
                 this.stateManager.initLeftRecordsCheckState(this.records);
@@ -56660,24 +57617,17 @@
                 if (this.sortState) {
                     let order;
                     let field;
-                    let fieldKey;
                     if (Array.isArray(this.sortState)) {
                         if (this.sortState.length !== 0) {
-                            ({ order, field, fieldKey } = this.sortState?.[0]);
+                            ({ order, field } = this.sortState?.[0]);
                         }
                     }
                     else {
-                        ({ order, field, fieldKey } = this.sortState);
+                        ({ order, field } = this.sortState);
                     }
                     if (order && field && order !== 'normal') {
-                        const sortFunc = this._getSortFuncFromHeaderOption(undefined, field, fieldKey);
-                        let hd;
-                        if (fieldKey) {
-                            hd = this.internalProps.layoutMap.headerObjects.find((col) => col && col.fieldKey === fieldKey);
-                        }
-                        else {
-                            hd = this.internalProps.layoutMap.headerObjects.find((col) => col && col.field === field);
-                        }
+                        const sortFunc = this._getSortFuncFromHeaderOption(undefined, field);
+                        const hd = this.internalProps.layoutMap.headerObjects.find((col) => col && col.field === field);
                         if (hd.define.sort !== false) {
                             this.dataSource.sort(hd.field, order, sortFunc ?? defaultOrderFn);
                         }
@@ -56751,6 +57701,26 @@
             else {
                 this.dataSource.changeFieldValue(value, recordIndex, field, col, row, this);
             }
+            const aggregators = this.internalProps.layoutMap.getAggregators(col, row);
+            if (aggregators) {
+                if (Array.isArray(aggregators)) {
+                    for (let i = 0; i < aggregators?.length; i++) {
+                        aggregators[i].recalculate();
+                    }
+                }
+                else {
+                    aggregators.recalculate();
+                }
+                const aggregatorCells = this.internalProps.layoutMap.getCellAddressHasAggregator(col, row);
+                for (let i = 0; i < aggregatorCells.length; i++) {
+                    const range = this.getCellRange(aggregatorCells[i].col, aggregatorCells[i].row);
+                    for (let sCol = range.start.col; sCol <= range.end.col; sCol++) {
+                        for (let sRow = range.start.row; sRow <= range.end.row; sRow++) {
+                            this.scenegraph.updateCellContent(sCol, sRow);
+                        }
+                    }
+                }
+            }
             const range = this.getCellRange(col, row);
             for (let sCol = range.start.col; sCol <= range.end.col; sCol++) {
                 for (let sRow = range.start.row; sRow <= range.end.row; sRow++) {
@@ -57154,7 +58124,7 @@
                 }
             }
         }
-        hasCustomRenderOrLayout() {
+        _hasCustomRenderOrLayout() {
             const { headerObjects } = this.internalProps.layoutMap;
             if (this.options.customRender) {
                 return true;
@@ -57170,6 +58140,37 @@
             }
             return false;
         }
+        getAggregateValuesByField(field) {
+            const columns = this.internalProps.layoutMap.getColumnByField(field);
+            const results = [];
+            for (let i = 0; i < columns.length; i++) {
+                const aggregator = columns[i].columnDefine.aggregator;
+                delete columns[i].columnDefine;
+                if (aggregator) {
+                    const columnAggregateValue = {
+                        col: columns[i].col,
+                        aggregateValue: null
+                    };
+                    columnAggregateValue.aggregateValue = [];
+                    if (Array.isArray(aggregator)) {
+                        for (let j = 0; j < aggregator.length; j++) {
+                            columnAggregateValue.aggregateValue.push({
+                                aggregationType: aggregator[j].type,
+                                value: aggregator[j].value()
+                            });
+                        }
+                    }
+                    else {
+                        columnAggregateValue.aggregateValue.push({
+                            aggregationType: aggregator.type,
+                            value: aggregator.value()
+                        });
+                    }
+                    results.push(columnAggregateValue);
+                }
+            }
+            return results;
+        }
     }
 
     const defaultDimension = { startInTotal: 0, level: 0 };
@@ -58887,6 +59888,9 @@
                 const indicatorKey = paths.rowHeaderPaths.find(rowPath => rowPath.indicatorKey)?.indicatorKey;
                 indicatorObj = this._indicators?.find(indicator => indicator.indicatorKey === indicatorKey);
             }
+            if (typeof indicatorObj?.chartSpec === 'function') {
+                return;
+            }
             indicatorObj && (indicatorObj.chartInstance = chartInstance);
         }
         getChartInstance(_col, _row) {
@@ -58969,6 +59973,12 @@
         getRawChartSpec(col, row) {
             return getRawChartSpec(col, row, this);
         }
+        getChartSpec(col, row) {
+            return getChartSpec(col, row, this);
+        }
+        isShareChartSpec(col, row) {
+            return isShareChartSpec(col, row, this);
+        }
         getChartDataId(col, row) {
             return getChartDataId(col, row, this);
         }
@@ -59079,9 +60089,6 @@
             }
             return null;
         }
-        getChartSpec(col, row) {
-            return getChartSpec(col, row, this);
-        }
         _generateChartState() {
             const state = {
                 vtable_selected: {
@@ -59318,12 +60325,23 @@
             });
             return indicatorInfo;
         }
+        getLayoutColumnTree() {
+            const tree = [];
+            const children = this.columnDimensionTree.tree.children;
+            generateLayoutTree(tree, children);
+            return tree;
+        }
         getLayoutRowTree() {
             const tree = [];
             const children = this.rowDimensionTree.tree.children;
             generateLayoutTree(tree, children);
             return tree;
         }
+        getLayoutColumnTreeCount() {
+            const children = this.columnDimensionTree.tree.children;
+            const mainTreeCount = countLayoutTree(children, this.rowHierarchyType === 'tree');
+            return mainTreeCount;
+        }
         getLayoutRowTreeCount() {
             const children = this.rowDimensionTree.tree.children;
             const mainTreeCount = countLayoutTree(children, this.rowHierarchyType === 'tree');
@@ -59542,371 +60560,6 @@
         }
     }
 
-    class Aggregator {
-        className = 'Aggregator';
-        isRecord = true;
-        records = [];
-        type;
-        field;
-        formatFun;
-        _formatedValue;
-        needSplitPositiveAndNegativeForSum = false;
-        constructor(dimension, formatFun, isRecord, needSplitPositiveAndNegative) {
-            this.field = dimension;
-            this.needSplitPositiveAndNegativeForSum = needSplitPositiveAndNegative ?? false;
-            this.formatFun = formatFun;
-            this.isRecord = isRecord ?? this.isRecord;
-        }
-        clearCacheValue() {
-            this._formatedValue = undefined;
-        }
-        formatValue(col, row, table) {
-            if (!this._formatedValue) {
-                if (this.formatFun) {
-                    this._formatedValue = this.formatFun(this.value(), col, row, table);
-                }
-                else {
-                    this._formatedValue = this.value();
-                }
-            }
-            return this._formatedValue;
-        }
-        reset() {
-            this.records = [];
-        }
-    }
-    class RecordAggregator extends Aggregator {
-        type = AggregationType.RECORD;
-        isRecord = true;
-        push(record) {
-            if (this.isRecord) {
-                if (record.className === 'Aggregator') {
-                    this.records.push(...record.records);
-                }
-                else {
-                    this.records.push(record);
-                }
-            }
-        }
-        value() {
-            return this.records;
-        }
-        reset() {
-            this.records = [];
-        }
-    }
-    class NoneAggregator extends Aggregator {
-        type = AggregationType.NONE;
-        isRecord = true;
-        fieldValue;
-        push(record) {
-            if (this.isRecord) {
-                this.records = [record];
-            }
-            this.fieldValue = record[this.field];
-        }
-        value() {
-            return this.fieldValue;
-        }
-        reset() {
-            this.records = [];
-            this.fieldValue = undefined;
-        }
-    }
-    class SumAggregator extends Aggregator {
-        type = AggregationType.SUM;
-        sum = 0;
-        positiveSum = 0;
-        nagetiveSum = 0;
-        push(record) {
-            if (this.isRecord) {
-                if (record.className === 'Aggregator') {
-                    this.records.push(...record.records);
-                }
-                else {
-                    this.records.push(record);
-                }
-            }
-            if (record.className === 'Aggregator') {
-                const value = record.value();
-                this.sum += value;
-                if (this.needSplitPositiveAndNegativeForSum) {
-                    if (value > 0) {
-                        this.positiveSum += value;
-                    }
-                    else if (value < 0) {
-                        this.nagetiveSum += value;
-                    }
-                }
-            }
-            else if (!isNaN(parseFloat(record[this.field]))) {
-                const value = parseFloat(record[this.field]);
-                this.sum += value;
-                if (this.needSplitPositiveAndNegativeForSum) {
-                    if (value > 0) {
-                        this.positiveSum += value;
-                    }
-                    else if (value < 0) {
-                        this.nagetiveSum += value;
-                    }
-                }
-            }
-        }
-        value() {
-            return this.sum;
-        }
-        positiveValue() {
-            return this.positiveSum;
-        }
-        negativeValue() {
-            return this.nagetiveSum;
-        }
-        reset() {
-            this.records = [];
-            this.sum = 0;
-        }
-    }
-    class CountAggregator extends Aggregator {
-        type = AggregationType.COUNT;
-        count = 0;
-        push(record) {
-            if (this.isRecord) {
-                if (record.className === 'Aggregator') {
-                    this.records.push(...record.records);
-                }
-                else {
-                    this.records.push(record);
-                }
-            }
-            if (record.className === 'Aggregator') {
-                this.count += record.value();
-            }
-            else {
-                this.count++;
-            }
-        }
-        value() {
-            return this.count;
-        }
-        reset() {
-            this.records = [];
-            this.count = 0;
-        }
-    }
-    class AvgAggregator extends Aggregator {
-        type = AggregationType.AVG;
-        sum = 0;
-        count = 0;
-        push(record) {
-            if (this.isRecord) {
-                if (record.className === 'Aggregator') {
-                    this.records.push(...record.records);
-                }
-                else {
-                    this.records.push(record);
-                }
-            }
-            if (record.className === 'Aggregator' && record.type === AggregationType.AVG) {
-                this.sum += record.sum;
-                this.count += record.count;
-            }
-            else if (!isNaN(parseFloat(record[this.field]))) {
-                this.sum += parseFloat(record[this.field]);
-                this.count++;
-            }
-        }
-        value() {
-            return this.sum / this.count;
-        }
-        reset() {
-            this.records = [];
-            this.sum = 0;
-            this.count = 0;
-        }
-    }
-    class MaxAggregator extends Aggregator {
-        type = AggregationType.MAX;
-        max = Number.MIN_SAFE_INTEGER;
-        push(record) {
-            if (this.isRecord) {
-                if (record.className === 'Aggregator') {
-                    this.records.push(...record.records);
-                }
-                else {
-                    this.records.push(record);
-                }
-            }
-            if (record.className === 'Aggregator') {
-                this.max = record.max > this.max ? record.max : this.max;
-            }
-            else if (typeof record === 'number') {
-                this.max = record > this.max ? record : this.max;
-            }
-            else if (typeof record[this.field] === 'number') {
-                this.max = record[this.field] > this.max ? record[this.field] : this.max;
-            }
-            else if (!isNaN(record[this.field])) {
-                this.max = parseFloat(record[this.field]) > this.max ? parseFloat(record[this.field]) : this.max;
-            }
-        }
-        value() {
-            return this.max;
-        }
-        reset() {
-            this.records = [];
-            this.max = Number.MIN_SAFE_INTEGER;
-        }
-    }
-    class MinAggregator extends Aggregator {
-        type = AggregationType.MIN;
-        min = Number.MAX_SAFE_INTEGER;
-        isRecord = false;
-        push(record) {
-            if (this.isRecord) {
-                if (record.className === 'Aggregator') {
-                    this.records.push(...record.records);
-                }
-                else {
-                    this.records.push(record);
-                }
-            }
-            if (record.className === 'Aggregator') {
-                this.min = record.min < this.min ? record.min : this.min;
-            }
-            else if (typeof record === 'number') {
-                this.min = record < this.min ? record : this.min;
-            }
-            else if (typeof record[this.field] === 'number') {
-                this.min = record[this.field] < this.min ? record[this.field] : this.min;
-            }
-        }
-        value() {
-            return this.min;
-        }
-        reset() {
-            this.records = [];
-            this.min = Number.MAX_SAFE_INTEGER;
-        }
-    }
-    function typeSort(a, b) {
-        if (a && b) {
-            return a.toString().localeCompare(b.toString(), 'zh');
-        }
-        if (a) {
-            return 1;
-        }
-        return -1;
-    }
-    function naturalSort(as, bs) {
-        const rx = /(\d+)|(\D+)/g;
-        const rd = /\d/;
-        const rz = /^0/;
-        let a;
-        let a1;
-        let b;
-        let b1;
-        let nas = 0;
-        let nbs = 0;
-        if (bs !== null && as === null) {
-            return -1;
-        }
-        if (as !== null && bs === null) {
-            return 1;
-        }
-        if (typeof as === 'number' && isNaN(as)) {
-            return -1;
-        }
-        if (typeof bs === 'number' && isNaN(bs)) {
-            return 1;
-        }
-        nas = +as;
-        nbs = +bs;
-        if (nas < nbs) {
-            return -1;
-        }
-        if (nas > nbs) {
-            return 1;
-        }
-        if (typeof as === 'number' && typeof bs !== 'number') {
-            return -1;
-        }
-        if (typeof bs === 'number' && typeof as !== 'number') {
-            return 1;
-        }
-        if (typeof as === 'number' && typeof bs === 'number') {
-            return 0;
-        }
-        if (isNaN(nbs) && !isNaN(nas)) {
-            return -1;
-        }
-        if (isNaN(nas) && !isNaN(nbs)) {
-            return 1;
-        }
-        a = String(as);
-        b = String(bs);
-        if (a === b) {
-            return 0;
-        }
-        if (!(rd.test(a) && rd.test(b))) {
-            return a > b ? 1 : -1;
-        }
-        a = a.match(rx);
-        b = b.match(rx);
-        while (a.length && b.length) {
-            a1 = a.shift();
-            b1 = b.shift();
-            if (a1 !== b1) {
-                if (rd.test(a1) && rd.test(b1)) {
-                    return a1.replace(rz, '.0') - b1.replace(rz, '.0');
-                }
-                return a1 > b1 ? 1 : -1;
-            }
-        }
-        return a.length - b.length;
-    }
-    function sortBy(order) {
-        let x;
-        const mapping = {};
-        const lowercase_mapping = {};
-        for (let i = 0; i < order.length; i++) {
-            x = order[i];
-            mapping[x] = i;
-            if (typeof x === 'string') {
-                lowercase_mapping[x.toLowerCase()] = i;
-            }
-        }
-        return function (a, b) {
-            if (mapping[a] !== null && mapping[a] !== undefined && mapping[b] !== null && mapping[b] !== undefined) {
-                return mapping[a] - mapping[b];
-            }
-            else if (mapping[a] !== null && mapping[a] !== undefined) {
-                return -1;
-            }
-            else if (mapping[b] !== null && mapping[b] !== undefined) {
-                return 1;
-            }
-            else if (lowercase_mapping[a] !== null &&
-                mapping[a] !== undefined &&
-                lowercase_mapping[b] !== null &&
-                mapping[b] !== undefined) {
-                return lowercase_mapping[a] - lowercase_mapping[b];
-            }
-            else if (lowercase_mapping[a] === null ||
-                mapping[a] === undefined ||
-                lowercase_mapping[b] === null ||
-                mapping[b] === undefined) {
-                return 0;
-            }
-            else if (lowercase_mapping[a] !== null && mapping[a] !== undefined) {
-                return -1;
-            }
-            else if (lowercase_mapping[b] !== null && mapping[b] !== undefined) {
-                return 1;
-            }
-            return naturalSort(a, b);
-        };
-    }
-
     class Dataset {
         dataConfig;
         records;
@@ -60422,6 +61075,8 @@
                         formatFun: agg.formatFun,
                         records: agg.records,
                         className: '',
+                        recalculate() {
+                        },
                         push() {
                         },
                         clearCacheValue() {
@@ -60437,6 +61092,8 @@
                     className: '',
                     push() {
                     },
+                    recalculate() {
+                    },
                     formatValue() {
                         return changeValue;
                     },
@@ -60452,6 +61109,8 @@
                     className: '',
                     push() {
                     },
+                    recalculate() {
+                    },
                     value() {
                         return null;
                     },
@@ -61001,10 +61660,12 @@
             this.pagination = options.pagination;
             this.internalProps.columnResizeType = options.columnResizeType ?? 'column';
             this.internalProps.dataConfig = cloneDeep(options.dataConfig);
-            this.internalProps.enableDataAnalysis = options.enableDataAnalysis;
             if (!options.rowTree && !options.columnTree) {
                 this.internalProps.enableDataAnalysis = true;
             }
+            else {
+                this.internalProps.enableDataAnalysis = false;
+            }
             const records = this.internalProps.records;
             if (this.internalProps.enableDataAnalysis && (options.rows || options.columns)) {
                 const rowKeys = options.rows?.reduce((keys, rowObj) => {
@@ -61082,6 +61743,9 @@
         isPivotChart() {
             return false;
         }
+        get recordsCount() {
+            return this.records?.length;
+        }
         _canResizeColumn(col, row) {
             const ifCan = super._canResizeColumn(col, row);
             if (ifCan) {
@@ -61114,10 +61778,12 @@
             this.pagination = options.pagination;
             internalProps.columnResizeType = options.columnResizeType ?? 'column';
             internalProps.dataConfig = cloneDeep(options.dataConfig);
-            internalProps.enableDataAnalysis = options.enableDataAnalysis;
             if (!options.rowTree && !options.columnTree) {
                 internalProps.enableDataAnalysis = true;
             }
+            else {
+                internalProps.enableDataAnalysis = false;
+            }
             if (options?.rowHierarchyType === 'tree' &&
                 this.internalProps.layoutMap.rowHierarchyType === 'tree' &&
                 this.internalProps.layoutMap.rowExpandLevel === options?.rowExpandLevel) {
@@ -61611,6 +62277,14 @@
         getHierarchyState(col, row) {
             return this._getHeaderLayoutMap(col, row)?.hierarchyState;
         }
+        getLayoutColumnTree() {
+            const layoutMap = this.internalProps.layoutMap;
+            return layoutMap.getLayoutColumnTree();
+        }
+        getLayoutColumnTreeCount() {
+            const layoutMap = this.internalProps.layoutMap;
+            return layoutMap.getLayoutColumnTreeCount();
+        }
         getLayoutRowTree() {
             const layoutMap = this.internalProps.layoutMap;
             return layoutMap.getLayoutRowTree();
@@ -61829,7 +62503,7 @@
                 this.records[rowIndex][colIndex] = newValue;
             }
         }
-        hasCustomRenderOrLayout() {
+        _hasCustomRenderOrLayout() {
             if (this.options.customRender) {
                 return true;
             }
@@ -61945,6 +62619,9 @@
         get pivotChartAxes() {
             return this._axes;
         }
+        get recordsCount() {
+            return this.records?.length;
+        }
         isListTable() {
             return false;
         }
@@ -62716,7 +63393,7 @@
             }
             this.eventManager.updateEventBinder();
         }
-        hasCustomRenderOrLayout() {
+        _hasCustomRenderOrLayout() {
             if (this.options.customRender) {
                 return true;
             }
@@ -63254,7 +63931,7 @@
     }
 
     registerForVrender();
-    const version = "0.19.2-alpha.3";
+    const version = "0.20.0";
     function getIcons() {
         return get$1();
     }