@visactor/vtable 1.15.1-alpha.1 → 1.15.2-alpha.0

package/dist/vtable.js

@@ -30743,7 +30743,7 @@
             return EVENT_TYPE$1;
         }
         hasHierarchyStateExpand = false;
-        beforeChangedRecordsMap = {};
+        beforeChangedRecordsMap = new Map();
         registedAggregators = {};
         rowHierarchyType;
         fieldAggregators = [];
@@ -30803,6 +30803,27 @@
                 }
             }
         }
+        supplementConfig(pagination, columns, rowHierarchyType, hierarchyExpandLevel) {
+            this.columns = columns;
+            this._sourceLength = this._source?.length || 0;
+            this.sortedIndexMap = new Map();
+            this._currentPagerIndexedData = [];
+            this.userPagination = pagination;
+            this.pagination = pagination || {
+                totalCount: this._sourceLength,
+                perPageCount: this._sourceLength,
+                currentPage: 0
+            };
+            if (hierarchyExpandLevel >= 1) {
+                this.hierarchyExpandLevel = hierarchyExpandLevel;
+            }
+            this.currentIndexedData = Array.from({ length: this._sourceLength }, (_, i) => i);
+            if (rowHierarchyType === 'tree') {
+                this.initTreeHierarchyState();
+            }
+            this.rowHierarchyType = rowHierarchyType;
+            this.updatePagerData();
+        }
         registerAggregator(type, aggregator) {
             this.registedAggregators[type] = aggregator;
         }
@@ -30981,6 +31002,9 @@
                 throw new Error(`currentIndexedData should has values!`);
             }
         }
+        getRecordIndexPaths(bodyShowIndex) {
+            return this._currentPagerIndexedData[bodyShowIndex];
+        }
         get records() {
             return Array.isArray(this._source) ? this._source : [];
         }
@@ -31016,7 +31040,13 @@
         }
         getHierarchyState(index) {
             const record = this.getOriginalRecord(this.currentPagerIndexedData[index]);
-            return record?.hierarchyState ?? null;
+            if (record?.hierarchyState) {
+                const hierarchyState = record.hierarchyState;
+                if (record.children?.length > 0 || record.children === true) {
+                    return hierarchyState;
+                }
+            }
+            return null;
         }
         toggleHierarchyState(index, bodyStartIndex, bodyEndIndex) {
             const oldIndexedData = this.currentIndexedData.slice(0);
@@ -31103,13 +31133,9 @@
             }
             if (index >= 0) {
                 const dataIndex = this.getIndexKey(index);
-                if (!this.beforeChangedRecordsMap[dataIndex]) {
-                    const originRecord = this.getOriginalRecord(dataIndex);
-                    this.beforeChangedRecordsMap[dataIndex] =
-                        cloneDeep$1(originRecord, undefined, ['vtable_gantt_linkedFrom', 'vtable_gantt_linkedTo']) ?? {};
-                }
+                this.cacheBeforeChangedRecord(dataIndex, table);
                 if (typeof field === 'string' || typeof field === 'number') {
-                    const beforeChangedValue = this.beforeChangedRecordsMap[dataIndex][field];
+                    const beforeChangedValue = this.beforeChangedRecordsMap.get(dataIndex.toString())?.[field];
                     const record = this.getOriginalRecord(dataIndex);
                     let formatValue = value;
                     if (typeof beforeChangedValue === 'number' && isAllDigits(value)) {
@@ -31135,6 +31161,12 @@
                 }
             }
         }
+        cacheBeforeChangedRecord(dataIndex, table) {
+            if (!this.beforeChangedRecordsMap.has(dataIndex.toString())) {
+                const originRecord = this.getOriginalRecord(dataIndex);
+                this.beforeChangedRecordsMap.set(dataIndex.toString(), cloneDeep$1(originRecord, undefined, ['vtable_gantt_linkedFrom', 'vtable_gantt_linkedTo']) ?? {});
+            }
+        }
         setRecord(record, index) {
             let isAdd = true;
             if (this.dataConfig?.filterRules?.length >= 1) {
@@ -31221,7 +31253,7 @@
         }
         addRecordForSorted(record) {
             if (Array.isArray(this.records)) {
-                this.beforeChangedRecordsMap = [];
+                this.beforeChangedRecordsMap.clear();
                 this.records.push(record);
                 this.currentIndexedData.push(this.currentIndexedData.length);
                 this._sourceLength += 1;
@@ -31234,7 +31266,7 @@
         }
         addRecordsForSorted(recordArr) {
             if (Array.isArray(this.records)) {
-                this.beforeChangedRecordsMap = [];
+                this.beforeChangedRecordsMap.clear();
                 if (Array.isArray(recordArr)) {
                     this.records.push(...recordArr);
                     for (let i = 0; i < recordArr.length; i++) {
@@ -31249,12 +31281,12 @@
                 }
             }
         }
-        adjustBeforeChangedRecordsMap(insertIndex, insertCount) {
-            const length = this.beforeChangedRecordsMap.length;
+        adjustBeforeChangedRecordsMap(insertIndex, insertCount, type = 'add') {
+            const length = this.beforeChangedRecordsMap.size;
             for (let key = length - 1; key >= insertIndex; key--) {
-                const record = this.beforeChangedRecordsMap[key];
-                delete this.beforeChangedRecordsMap[key];
-                this.beforeChangedRecordsMap[key + insertCount] = record;
+                const record = this.beforeChangedRecordsMap.get(key.toString());
+                this.beforeChangedRecordsMap.delete(key.toString());
+                this.beforeChangedRecordsMap.set((key + (type === 'add' ? insertCount : -insertCount)).toString(), record);
             }
         }
         deleteRecords(recordIndexs) {
@@ -31266,7 +31298,7 @@
                     if (recordIndex >= this._sourceLength || recordIndex < 0) {
                         continue;
                     }
-                    delete this.beforeChangedRecordsMap[recordIndex];
+                    this.adjustBeforeChangedRecordsMap(recordIndex, 1, 'delete');
                     realDeletedRecordIndexs.push(recordIndex);
                     const deletedRecord = this.records[recordIndex];
                     for (let i = 0; i < this.fieldAggregators.length; i++) {
@@ -31300,7 +31332,6 @@
                         continue;
                     }
                     const rawIndex = this.currentIndexedData[recordIndex];
-                    delete this.beforeChangedRecordsMap[rawIndex];
                     this.records.splice(rawIndex, 1);
                     this._sourceLength -= 1;
                 }
@@ -31309,6 +31340,7 @@
                     this.pagination.perPageCount = this._sourceLength;
                     this.pagination.totalCount = this._sourceLength;
                 }
+                this.beforeChangedRecordsMap.clear();
             }
         }
         updateRecords(records, recordIndexs) {
@@ -31316,7 +31348,7 @@
             for (let index = 0; index < recordIndexs.length; index++) {
                 const recordIndex = recordIndexs[index];
                 if (Array.isArray(recordIndex)) {
-                    delete this.beforeChangedRecordsMap[recordIndex.join(',')];
+                    this.beforeChangedRecordsMap.delete(recordIndex.toString());
                     realDeletedRecordIndexs.push(recordIndex);
                     recordIndex.slice(0, -1).reduce((acc, key) => {
                         if (acc[key] === undefined) {
@@ -31329,7 +31361,7 @@
                     if (recordIndex >= this._sourceLength || recordIndex < 0) {
                         continue;
                     }
-                    delete this.beforeChangedRecordsMap[recordIndex];
+                    this.beforeChangedRecordsMap.delete(recordIndex.toString());
                     realDeletedRecordIndexs.push(recordIndex);
                     for (let i = 0; i < this.fieldAggregators.length; i++) {
                         this.fieldAggregators[i].updateRecord(this.records[recordIndex], records[index]);
@@ -31352,7 +31384,7 @@
                 if (typeof rawIndex !== 'number') {
                     return;
                 }
-                delete this.beforeChangedRecordsMap[rawIndex];
+                this.beforeChangedRecordsMap.delete(rawIndex.toString());
                 this.records[rawIndex] = records[index];
             }
             this.sortedIndexMap.clear();
@@ -31418,7 +31450,7 @@
         }
         clearFilteredChildren(record) {
             record.filteredChildren = undefined;
-            for (let i = 0; i < record.children?.length ?? 0; i++) {
+            for (let i = 0; i < (record.children?.length ?? 0); i++) {
                 this.clearFilteredChildren(record.children[i]);
             }
         }
@@ -31553,8 +31585,8 @@
             });
         }
         getRawRecord(dataIndex) {
-            if (this.beforeChangedRecordsMap?.[dataIndex]) {
-                return this.beforeChangedRecordsMap[dataIndex];
+            if (this.beforeChangedRecordsMap?.has(dataIndex.toString())) {
+                return this.beforeChangedRecordsMap?.get(dataIndex.toString());
             }
             let data;
             if (!this.dataSourceObj.records) {
@@ -31609,7 +31641,10 @@
             },
             length: 0
         });
-        isCanExchangeOrder(sourceIndex, targetIndex) {
+        canChangeOrder(sourceIndex, targetIndex) {
+            if ((this.dataSourceObj?.canChangeOrder)) {
+                return this.dataSourceObj.canChangeOrder(sourceIndex, targetIndex);
+            }
             if (this.hasHierarchyStateExpand) {
                 let sourceIndexs = this.currentPagerIndexedData[sourceIndex];
                 let targetIndexs = this.currentPagerIndexedData[targetIndex];
@@ -31651,11 +31686,15 @@
             }
             return true;
         }
-        reorderRecord(sourceIndex, targetIndex) {
+        changeOrder(sourceIndex, targetIndex) {
+            if ((this.dataSourceObj?.changeOrder)) {
+                this.dataSourceObj.changeOrder(sourceIndex, targetIndex);
+                return;
+            }
             if (this.lastSortStates?.some(state => state.order === 'asc' || state.order === 'desc')) {
                 return;
             }
-            else if (this.isCanExchangeOrder(sourceIndex, targetIndex)) {
+            else if (this.canChangeOrder(sourceIndex, targetIndex)) {
                 if (this.hasHierarchyStateExpand) {
                     let sourceIndexs = this.currentPagerIndexedData[sourceIndex];
                     let targetIndexs = this.currentPagerIndexedData[targetIndex];
@@ -31781,6 +31820,26 @@
         }
         return result;
     }
+    function sortRecordIndexs(recordIndexs, sort) {
+        const result = recordIndexs.sort((a, b) => {
+            if (isNumber$4(a)) {
+                a = [a];
+            }
+            if (isNumber$4(b)) {
+                b = [b];
+            }
+            const length = Math.max(a.length, b.length);
+            for (let i = 0; i < length; i++) {
+                const aa = a[i] ?? -1;
+                const bb = b[i] ?? -1;
+                if (aa !== bb) {
+                    return sort === 1 ? aa - bb : bb - aa;
+                }
+            }
+            return 0;
+        });
+        return result;
+    }
 
     /**
      * Checks if `value` is classified as an `Array` object.
@@ -33011,6 +33070,7 @@
         _recordCache;
         _fieldCache;
         groupAggregator;
+        _isGrouped;
         static get EVENT_TYPE() {
             return DataSource.EVENT_TYPE;
         }
@@ -33024,27 +33084,53 @@
             }, dataConfig, pagination, columns, rowHierarchyType, hierarchyExpandLevel);
         }
         constructor(opt, dataConfig, pagination, columns, rowHierarchyType, hierarchyExpandLevel) {
+            let _isGrouped;
             if (isArray$7(dataConfig?.groupByRules)) {
                 rowHierarchyType = 'tree';
+                _isGrouped = true;
             }
             super(opt, dataConfig, pagination, columns, rowHierarchyType, hierarchyExpandLevel);
+            this._isGrouped = _isGrouped;
             this._recordCache = [];
             this._fieldCache = {};
         }
         getOriginalRecord(index) {
-            if (this._recordCache && this._recordCache[index]) {
+            if (isNumber$4(index) && this._recordCache && this._recordCache[index]) {
                 return this._recordCache[index];
             }
             return super.getOriginalRecord(index);
         }
         getRawRecord(index) {
-            if (this.beforeChangedRecordsMap?.[index]) {
-                return this.beforeChangedRecordsMap[index];
+            let originRecordIndex;
+            if (this._isGrouped) {
+                originRecordIndex = this.getOriginRecordIndexForGroup(index);
+                if (isValid$3(originRecordIndex) && this.beforeChangedRecordsMap?.has(originRecordIndex.toString())) {
+                    return this.beforeChangedRecordsMap?.get(originRecordIndex.toString());
+                }
             }
-            if (this._recordCache && this._recordCache[index]) {
+            else {
+                if (this.beforeChangedRecordsMap?.has(index.toString())) {
+                    return this.beforeChangedRecordsMap?.get(index.toString());
+                }
+            }
+            if (isNumber$4(index) && this._recordCache && this._recordCache[index]) {
                 return this._recordCache[index];
             }
-            return super.getRawRecord(index);
+            let data;
+            if (!this.dataSourceObj.records) {
+                data = this._get(index);
+            }
+            else {
+                if (Array.isArray(index)) {
+                    data = getValueFromDeepArray(this.records, index);
+                }
+                else {
+                    data = this.records[index];
+                }
+            }
+            return getValue$2(data, (val) => {
+                this.recordPromiseCallBack(index, val);
+            });
         }
         getOriginalField(index, field, col, row, table) {
             const rowCache = this._fieldCache && this._fieldCache[index];
@@ -33089,7 +33175,6 @@
                         const groupResult = [];
                         for (let i = 0; i < records.length; i++) {
                             dealWithGroup(records[i], groupResult, groupMap, groupByKeys, 0);
-                            records[i].vtableOriginIndex = i;
                         }
                         return groupResult;
                     }
@@ -33125,43 +33210,185 @@
             this.initTreeHierarchyState();
             this.updatePagerData();
         }
+        getOriginRecordIndexForGroup(recordIndex) {
+            const targetRecord = this.getOriginalRecord(recordIndex);
+            if (!isValid$3(targetRecord)) {
+                return undefined;
+            }
+            if (targetRecord.children && targetRecord.children.length > 0) {
+                return undefined;
+            }
+            for (let i = 0; i < this.dataSourceObj.records.length; i++) {
+                if (this.dataSourceObj.records[i] === targetRecord) {
+                    return i;
+                }
+            }
+            return undefined;
+        }
         addRecordsForGroup(recordArr, recordIndex) {
             if (!isArray$7(recordArr) || recordArr.length === 0) {
                 return;
             }
-            if (recordIndex === undefined || recordIndex > this.dataSourceObj.records) {
-                recordIndex = this.dataSourceObj.records;
+            let originRecordIndex = this.getOriginRecordIndexForGroup(recordIndex);
+            if (originRecordIndex === undefined || originRecordIndex > this.dataSourceObj.records) {
+                originRecordIndex = this.dataSourceObj.records.length;
             }
-            this.dataSourceObj.records.splice(recordIndex, 0, ...recordArr);
+            this.dataSourceObj.records.splice(originRecordIndex, 0, ...recordArr);
+            this.adjustBeforeChangedRecordsMap(originRecordIndex, recordArr.length);
             this.updateGroup();
         }
         deleteRecordsForGroup(recordIndexs) {
             if (!isArray$7(recordIndexs) || recordIndexs.length === 0) {
                 return;
             }
-            const recordIndexsMaxToMin = recordIndexs.sort((a, b) => b - a);
+            const recordIndexsMaxToMin = sortRecordIndexs(recordIndexs, -1);
             for (let index = 0; index < recordIndexsMaxToMin.length; index++) {
                 const recordIndex = recordIndexsMaxToMin[index];
-                if (recordIndex >= this.sourceLength || recordIndex < 0) {
+                if (isNumber$4(recordIndex) && (recordIndex >= this.sourceLength || recordIndex < 0)) {
                     continue;
                 }
-                delete this.beforeChangedRecordsMap[recordIndex];
-                this.dataSourceObj.records.splice(recordIndex, 1);
+                const originRecordIndex = this.getOriginRecordIndexForGroup(recordIndex);
+                this.beforeChangedRecordsMap.delete(originRecordIndex.toString());
+                this.dataSourceObj.records.splice(originRecordIndex, 1);
                 this.sourceLength -= 1;
+                this.adjustBeforeChangedRecordsMap(originRecordIndex, 1, 'delete');
             }
             this.updateGroup();
         }
         updateRecordsForGroup(records, recordIndexs) {
             for (let index = 0; index < recordIndexs.length; index++) {
                 const recordIndex = recordIndexs[index];
-                if (recordIndex >= this.sourceLength || recordIndex < 0) {
+                if (isNumber$4(recordIndex) && (recordIndex >= this.sourceLength || recordIndex < 0)) {
                     continue;
                 }
-                delete this.beforeChangedRecordsMap[recordIndex];
-                this.dataSourceObj.records[recordIndex] = records[index];
+                const originRecordIndex = this.getOriginRecordIndexForGroup(recordIndex);
+                this.beforeChangedRecordsMap.delete(originRecordIndex.toString());
+                this.dataSourceObj.records[originRecordIndex] = records[index];
             }
             this.updateGroup();
         }
+        addRecordsForTree(recordArr, recordIndex) {
+            if (!isArray$7(recordArr) || recordArr.length === 0) {
+                return;
+            }
+            this.adjustBeforeChangedRecordsMap(recordIndex, recordArr.length);
+            if (isNumber$4(recordIndex)) {
+                this.dataSourceObj.records.splice(recordIndex, 0, ...recordArr);
+            }
+            else {
+                const index = recordIndex.pop();
+                const parentRecord = this.getOriginalRecord(recordIndex);
+                if (parentRecord.children) {
+                    parentRecord.children.splice(index, 0, ...recordArr);
+                }
+                else {
+                    parentRecord.children = recordArr;
+                }
+            }
+            this.initTreeHierarchyState();
+            this.updatePagerData();
+        }
+        deleteRecordsForTree(recordIndexs) {
+            if (!isArray$7(recordIndexs) || recordIndexs.length === 0) {
+                return;
+            }
+            const recordIndexsMaxToMin = sortRecordIndexs(recordIndexs, -1);
+            for (let index = 0; index < recordIndexsMaxToMin.length; index++) {
+                const recordIndex = recordIndexsMaxToMin[index];
+                if (isNumber$4(recordIndex) && (recordIndex >= this.sourceLength || recordIndex < 0)) {
+                    continue;
+                }
+                this.beforeChangedRecordsMap.delete(recordIndex.toString());
+                if (isNumber$4(recordIndex)) {
+                    this.dataSourceObj.records.splice(recordIndex, 1);
+                }
+                else {
+                    const index = recordIndex.pop();
+                    const parentRecord = this.getOriginalRecord(recordIndex);
+                    parentRecord.children.splice(index, 1);
+                }
+                this.adjustBeforeChangedRecordsMap(recordIndex, 1, 'delete');
+            }
+            this.initTreeHierarchyState();
+            this.updatePagerData();
+        }
+        updateRecordsForTree(records, recordIndexs) {
+            for (let index = 0; index < recordIndexs.length; index++) {
+                const recordIndex = recordIndexs[index];
+                const record = records[index];
+                if (isNumber$4(recordIndex) && (recordIndex >= this.sourceLength || recordIndex < 0)) {
+                    continue;
+                }
+                this.beforeChangedRecordsMap.delete(recordIndex.toString());
+                if (isNumber$4(recordIndex)) {
+                    this.dataSourceObj.records.splice(recordIndex, 1, record);
+                }
+                else {
+                    const index = recordIndex.pop();
+                    const parentRecord = this.getOriginalRecord(recordIndex);
+                    parentRecord.children.splice(index, 1, record);
+                }
+            }
+            this.initTreeHierarchyState();
+            this.updatePagerData();
+        }
+        adjustBeforeChangedRecordsMap(insertIndex, insertCount, type = 'add') {
+            if (this.rowHierarchyType === 'tree') {
+                let insertIndexArr;
+                if (isNumber$4(insertIndex)) {
+                    insertIndexArr = [insertIndex];
+                }
+                else {
+                    insertIndexArr = insertIndex;
+                }
+                const targetResult = [];
+                this.beforeChangedRecordsMap.forEach((value, key) => {
+                    const keyArray = key.split(',');
+                    const length = Math.max(keyArray.length, insertIndexArr.length);
+                    for (let i = 0; i < length; i++) {
+                        const current = insertIndexArr[i] ?? -1;
+                        const keyIndex = Number(keyArray[i]) ?? -1;
+                        if (current < keyIndex ||
+                            (current === keyIndex && i === keyArray.length - 1 && i === insertIndexArr.length - 1)) {
+                            keyArray[i] = (keyIndex + (type === 'add' ? insertCount : -insertCount)).toString();
+                            targetResult.push({
+                                originKey: key,
+                                targetKey: keyArray.toString(),
+                                value
+                            });
+                            return;
+                        }
+                    }
+                });
+                targetResult.forEach(({ originKey, targetKey, value }) => {
+                    this.beforeChangedRecordsMap.delete(originKey);
+                    this.beforeChangedRecordsMap.set(targetKey, value);
+                });
+            }
+            else {
+                super.adjustBeforeChangedRecordsMap(insertIndex, insertCount, type);
+            }
+        }
+        cacheBeforeChangedRecord(dataIndex, table) {
+            const originRecord = this.getOriginalRecord(dataIndex);
+            if (table.options.groupBy) {
+                dataIndex = this.getOriginRecordIndexForGroup(dataIndex);
+            }
+            if (!this.beforeChangedRecordsMap.has(dataIndex.toString())) {
+                this.beforeChangedRecordsMap.set(dataIndex.toString(), cloneDeep$1(originRecord, undefined, ['vtable_gantt_linkedFrom', 'vtable_gantt_linkedTo']) ?? {});
+            }
+        }
+        getGroupSeriesNumber(showIndex) {
+            const recordIndex = this.dataSource.currentIndexedData[showIndex];
+            const parentRecordIndexLength = recordIndex.length - 1;
+            let recordIndexLength = recordIndex.length;
+            let i = 1;
+            for (; recordIndexLength > parentRecordIndexLength; i++) {
+                const index = this.dataSource.currentIndexedData[showIndex - i];
+                recordIndexLength = isNumber$4(index) ? 1 : index.length;
+            }
+            return i - 1;
+        }
     }
     function dealWithGroup(record, children, map, groupByKeys, level) {
         const groupByKey = groupByKeys[level];
@@ -33714,18 +33941,20 @@
     }
     function _setDataSource(table, dataSource) {
         _dealWithUpdateDataSource(table, () => {
+            table.internalProps.dataSource && table.internalProps.dataSource.release?.();
             if (dataSource) {
                 if (dataSource instanceof DataSource) {
                     table.internalProps.dataSource = dataSource;
+                    table.internalProps.dataSource.supplementConfig(table.pagination, table.options.columns, table.internalProps.layoutMap.rowHierarchyType, getHierarchyExpandLevel(table));
                 }
                 else {
-                    const newDataSource = (table.internalProps.dataSource = new CachedDataSource(dataSource));
-                    table.addReleaseObj(newDataSource);
+                    table.internalProps.dataSource = new CachedDataSource(dataSource);
                 }
             }
             else {
                 table.internalProps.dataSource = DataSource.EMPTY;
             }
+            table.addReleaseObj(table.internalProps.dataSource);
             table.internalProps.records = null;
         });
     }
@@ -37046,9 +37275,12 @@
                 if (table.options.groupTitleCustomLayout) {
                     customResult = dealWithCustom(table.options.groupTitleCustomLayout, undefined, range.start.col, range.start.row, table.getColsWidth(range.start.col, range.end.col), table.getRowsHeight(range.start.row, range.end.row), false, table.isAutoRowHeight(row), [0, 0, 0, 0], range, table);
                 }
-            }
-            if (vtableMergeName) {
-                value = vtableMergeName;
+                if (table.options.groupTitleFieldFormat) {
+                    value = table.options.groupTitleFieldFormat(rawRecord, col, row, table);
+                }
+                else if (vtableMergeName) {
+                    value = vtableMergeName;
+                }
             }
         }
         const cellStyle = customStyle || table._getCellStyle(range ? range.start.col : col, range ? range.start.row : row);
@@ -37887,22 +38119,13 @@
                     table._setRowHeight(row, newRowHeight);
                 }
             }
-            if (table.heightMode === 'adaptive' ||
-                (table.autoFillHeight && table.getAllRowsHeight() <= table.tableNoFrameHeight)) {
-                for (let row = 0; row <= table.columnHeaderLevelCount - 1; row++) {
-                    const newRowHeight = table.getRowHeight(row);
-                    if (newRowHeight !== (oldRowHeights[row] ?? table.getRowHeight(row))) {
-                        table.scenegraph.updateRowHeight(row, newRowHeight - (oldRowHeights[row] ?? table.getRowHeight(row)), true);
-                    }
-                }
-                for (let row = table.rowCount - table.bottomFrozenRowCount; row <= table.rowCount - 1; row++) {
-                    const newRowHeight = table.getRowHeight(row);
-                    if (newRowHeight !== (oldRowHeights[row] ?? table.getRowHeight(row))) {
-                        table.scenegraph.updateRowHeight(row, newRowHeight - (oldRowHeights[row] ?? table.getRowHeight(row)), true);
-                    }
+            for (let row = 0; row <= table.frozenRowCount - 1; row++) {
+                const newRowHeight = table.getRowHeight(row);
+                if (newRowHeight !== (oldRowHeights[row] ?? table.getRowHeight(row))) {
+                    table.scenegraph.updateRowHeight(row, newRowHeight - (oldRowHeights[row] ?? table.getRowHeight(row)), true);
                 }
             }
-            for (let row = 0; row < table.frozenRowCount; row++) {
+            for (let row = table.rowCount - table.bottomFrozenRowCount; row <= table.rowCount - 1; row++) {
                 const newRowHeight = table.getRowHeight(row);
                 if (newRowHeight !== (oldRowHeights[row] ?? table.getRowHeight(row))) {
                     table.scenegraph.updateRowHeight(row, newRowHeight - (oldRowHeights[row] ?? table.getRowHeight(row)), true);
@@ -42985,9 +43208,12 @@
                     if (table.options.groupTitleCustomLayout) {
                         customResult = dealWithCustom(table.options.groupTitleCustomLayout, undefined, range.start.col, range.start.row, table.getColsWidth(range.start.col, range.end.col), table.getRowsHeight(range.start.row, range.end.row), false, table.isAutoRowHeight(row), [0, 0, 0, 0], range, table);
                     }
-                }
-                if (vtableMergeName) {
-                    value = vtableMergeName;
+                    if (table.options.groupTitleFieldFormat) {
+                        value = table.options.groupTitleFieldFormat(rawRecord, col, row, table);
+                    }
+                    else if (vtableMergeName) {
+                        value = vtableMergeName;
+                    }
                 }
             }
             const type = isVtableMerge || isCustomMerge
@@ -43189,7 +43415,7 @@
             computeColsWidth(table, 0, distColForCompute ?? distCol);
         }
         if (table.internalProps._heightResizedRowMap.size === 0) {
-            computeRowsHeight(table, 0, distRowForCompute ?? distRow);
+            computeRowsHeight(table, 0, table.options.canvasHeight === 'auto' ? table.rowCount - 1 : distRowForCompute ?? distRow);
         }
         if (distCol < table.colCount - table.rightFrozenColCount) {
             computeColsWidth(table, table.colCount - table.rightFrozenColCount, table.colCount - 1);
@@ -44030,7 +44256,6 @@
             [rowStart, rowEnd].forEach((row) => {
                 const style = table._getCellStyle(col, row);
                 if (style?.textStick &&
-                    table.internalProps.layoutMap.rowHierarchyType !== 'tree' &&
                     style?.textStick !== 'horizontal') {
                     const cellGroup = table.scenegraph.getCell(col, row);
                     adjustCellContentVerticalLayout(cellGroup, frozenRowsHeight + table.tableY, table.tableNoFrameHeight - table.getBottomFrozenRowsHeight() + table.tableY, changedCells, style?.textStickBaseOnAlign, table);
@@ -50644,7 +50869,7 @@
         const groupKeyLength = dataSource.dataConfig.groupByRules.length + 1;
         dataSource.currentIndexedData.forEach((indexArr, index) => {
             if (isArray$7(indexArr) && indexArr.length === groupKeyLength) {
-                const { vtableOriginIndex } = dataSource.getRawRecord(indexArr);
+                const vtableOriginIndex = dataSource.getOriginRecordIndexForGroup(indexArr);
                 result[vtableOriginIndex] = table.stateManager.checkedState.get(indexArr.toString());
             }
         });
@@ -57457,32 +57682,14 @@
         if (frozen) {
             return frozen;
         }
-        let row = getTargetRowAt(absoluteY, _this);
-        if (!row) {
-            row = {
-                top: -1,
-                row: -1,
-                bottom: -1,
-                height: -1
-            };
-        }
-        return row;
+        return getTargetRowAt(absoluteY, _this) ?? { top: -1, row: -1, bottom: -1, height: -1 };
     }
     function getColAt(absoluteX, _this) {
         const frozen = _getTargetFrozenColAt(_this, absoluteX);
         if (frozen) {
             return frozen;
         }
-        let col = getTargetColAt(absoluteX, _this);
-        if (!col) {
-            col = {
-                left: -1,
-                col: -1,
-                right: -1,
-                width: 1
-            };
-        }
-        return col;
+        return getTargetColAt(absoluteX, _this) ?? { left: -1, col: -1, right: -1, width: 1 };
     }
     function getCellAt(absoluteX, absoluteY, _this) {
         const rowInfo = getRowAt(absoluteY, _this);
@@ -58991,7 +59198,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "1.15.1-alpha.1";
+        version = "1.15.2-alpha.0";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -59043,8 +59250,8 @@
             }
             this.tableNoFrameWidth = 0;
             this.tableNoFrameHeight = 0;
-            this.canvasWidth = canvasWidth;
-            this.canvasHeight = canvasHeight;
+            this.canvasWidth = isNumber$4(canvasWidth) ? canvasWidth : undefined;
+            this.canvasHeight = isNumber$4(canvasHeight) ? canvasHeight : undefined;
             this.columnWidthComputeMode = options.columnWidthComputeMode ?? 'normal';
             const internalProps = (this.internalProps = {});
             showFrozenIcon !== undefined && (this.showFrozenIcon = showFrozenIcon);
@@ -59097,11 +59304,12 @@
             this.colWidthsMap = new NumberMap();
             this.colContentWidthsMap = new NumberMap();
             this.colWidthsLimit = {};
+            const that = this;
             internalProps.calcWidthContext = {
                 _: internalProps,
                 get full() {
                     if (Env.mode === 'node') {
-                        return canvasWidth / (pixelRatio ?? 1);
+                        return that.canvasWidth / (pixelRatio ?? 1);
                     }
                     return this._.canvas.width / (this._.context.pixelRatio ?? window.devicePixelRatio);
                 }
@@ -59200,6 +59408,52 @@
             if (CustomCellStylePlugin) {
                 this.customCellStylePlugin = new CustomCellStylePlugin(this, options.customCellStyle ?? [], options.customCellStyleArrangement ?? []);
             }
+            this._adjustCanvasSizeByOption();
+        }
+        _adjustCanvasSizeByOption() {
+            if (this.options.canvasHeight === 'auto' || this.options.canvasWidth === 'auto') {
+                setTimeout(() => {
+                    let canvasWidth;
+                    let canvasHeight;
+                    if (this.options.canvasHeight === 'auto') {
+                        let borderWidth = 0;
+                        if (this.theme.frameStyle?.innerBorder) {
+                            const shadowWidths = toBoxArray(this.internalProps.theme.frameStyle?.shadowBlur ?? [0]);
+                            borderWidth += shadowWidths[1] ?? 0;
+                        }
+                        else if (this.theme.frameStyle) {
+                            const lineWidths = toBoxArray(this.internalProps.theme.frameStyle?.borderLineWidth ?? [null]);
+                            const shadowWidths = toBoxArray(this.internalProps.theme.frameStyle?.shadowBlur ?? [0]);
+                            borderWidth +=
+                                (lineWidths[0] ?? 0) + (shadowWidths[0] ?? 0) + ((lineWidths[2] ?? 0) + (shadowWidths[2] ?? 0));
+                        }
+                        canvasHeight =
+                            Math.min(this.options.maxCanvasHeight ? this.options.maxCanvasHeight - borderWidth : 20000, this.getAllRowsHeight()) + borderWidth;
+                    }
+                    else {
+                        canvasHeight = this.canvasHeight;
+                    }
+                    if (this.options.canvasWidth === 'auto') {
+                        let borderWidth = 0;
+                        if (this.theme.frameStyle?.innerBorder) {
+                            const shadowWidths = toBoxArray(this.internalProps.theme.frameStyle?.shadowBlur ?? [0]);
+                            borderWidth += shadowWidths[2] ?? 0;
+                        }
+                        else if (this.theme.frameStyle) {
+                            const lineWidths = toBoxArray(this.internalProps.theme.frameStyle?.borderLineWidth ?? [null]);
+                            const shadowWidths = toBoxArray(this.internalProps.theme.frameStyle?.shadowBlur ?? [0]);
+                            borderWidth +=
+                                (lineWidths[1] ?? 0) + (shadowWidths[1] ?? 0) + ((lineWidths[3] ?? 0) + (shadowWidths[3] ?? 0));
+                        }
+                        canvasWidth =
+                            Math.min(this.options.maxCanvasWidth ? this.options.maxCanvasWidth - borderWidth : 20000, this.getAllColsWidth()) + borderWidth;
+                    }
+                    else {
+                        canvasWidth = this.canvasWidth;
+                    }
+                    this.setCanvasSize(canvasWidth, canvasHeight);
+                }, 0);
+            }
         }
         throttleInvalidate = throttle2(this.render.bind(this), 200);
         getContainer() {
@@ -59492,7 +59746,7 @@
         setPixelRatio(pixelRatio) {
             if (pixelRatio !== this.internalProps.pixelRatio) {
                 this.internalProps.pixelRatio = pixelRatio;
-                const canvasWidth = this.options.canvasWidth;
+                const canvasWidth = this.canvasWidth;
                 this.internalProps.calcWidthContext = {
                     _: this.internalProps,
                     get full() {
@@ -60348,8 +60602,8 @@
             this.autoFillWidth = autoFillWidth ?? false;
             this.autoFillHeight = autoFillHeight ?? false;
             this.customRender = customRender;
-            this.canvasWidth = canvasWidth;
-            this.canvasHeight = canvasHeight;
+            this.canvasWidth = isNumber$4(canvasWidth) ? canvasWidth : undefined;
+            this.canvasHeight = isNumber$4(canvasHeight) ? canvasHeight : undefined;
             const internalProps = this.internalProps;
             if (Env.mode !== 'node' && !options.canvas) {
                 updateRootElementPadding(internalProps.element, this.padding);
@@ -60464,6 +60718,7 @@
             this.clearRowHeightCache();
             internalProps.customMergeCell = getCustomMergeCellFunc(options.customMergeCell);
             this.customCellStylePlugin?.updateCustomCell(options.customCellStyle ?? [], options.customCellStyleArrangement ?? []);
+            this._adjustCanvasSizeByOption();
         }
         renderWithRecreateCells() {
             const oldHoverState = { col: this.stateManager.hover.cellPos.col, row: this.stateManager.hover.cellPos.row };
@@ -64658,7 +64913,7 @@
                 this.isSeriesNumberInBody(source.col, source.row)) {
                 const sourceIndex = this.getRecordShowIndexByCell(0, source.row);
                 const targetIndex = this.getRecordShowIndexByCell(0, target.row);
-                const canMove = this._table.dataSource.isCanExchangeOrder(sourceIndex, targetIndex);
+                const canMove = this._table.dataSource.canChangeOrder(sourceIndex, targetIndex);
                 return canMove;
             }
             else if (this.transpose &&
@@ -65356,6 +65611,15 @@
             table.dataSource.addRecordsForGroup?.([record], recordIndex);
             table.refreshRowColCount();
             table.internalProps.layoutMap.clearCellRangeMap();
+            table.sortState && sortRecords(table);
+            table.scenegraph.clearCells();
+            table.scenegraph.createSceneGraph();
+        }
+        else if (table.dataSource.rowHierarchyType === 'tree') {
+            table.dataSource.addRecordsForTree?.([record], recordIndex);
+            table.refreshRowColCount();
+            table.internalProps.layoutMap.clearCellRangeMap();
+            table.sortState && sortRecords(table);
             table.scenegraph.clearCells();
             table.scenegraph.createSceneGraph();
         }
@@ -65367,6 +65631,7 @@
             table.scenegraph.createSceneGraph();
         }
         else {
+            recordIndex = recordIndex;
             if (recordIndex === undefined || recordIndex > table.dataSource.sourceLength) {
                 recordIndex = table.dataSource.sourceLength;
             }
@@ -65447,6 +65712,15 @@
             table.dataSource.addRecordsForGroup?.(records, recordIndex);
             table.refreshRowColCount();
             table.internalProps.layoutMap.clearCellRangeMap();
+            table.sortState && sortRecords(table);
+            table.scenegraph.clearCells();
+            table.scenegraph.createSceneGraph();
+        }
+        else if (table.dataSource.rowHierarchyType === 'tree') {
+            table.dataSource.addRecordsForTree?.(records, recordIndex);
+            table.refreshRowColCount();
+            table.internalProps.layoutMap.clearCellRangeMap();
+            table.sortState && sortRecords(table);
             table.scenegraph.clearCells();
             table.scenegraph.createSceneGraph();
         }
@@ -65458,6 +65732,7 @@
             table.scenegraph.createSceneGraph();
         }
         else {
+            recordIndex = recordIndex;
             if (recordIndex === undefined || recordIndex > table.dataSource.sourceLength) {
                 recordIndex = table.dataSource.sourceLength;
             }
@@ -65555,6 +65830,15 @@
                 table.dataSource.deleteRecordsForGroup?.(recordIndexs);
                 table.refreshRowColCount();
                 table.internalProps.layoutMap.clearCellRangeMap();
+                table.sortState && sortRecords(table);
+                table.scenegraph.clearCells();
+                table.scenegraph.createSceneGraph();
+            }
+            else if (table.dataSource.rowHierarchyType === 'tree') {
+                table.dataSource.deleteRecordsForTree?.(recordIndexs);
+                table.refreshRowColCount();
+                table.internalProps.layoutMap.clearCellRangeMap();
+                table.sortState && sortRecords(table);
                 table.scenegraph.clearCells();
                 table.scenegraph.createSceneGraph();
             }
@@ -65674,6 +65958,15 @@
                 table.dataSource.updateRecordsForGroup?.(records, recordIndexs);
                 table.refreshRowColCount();
                 table.internalProps.layoutMap.clearCellRangeMap();
+                table.sortState && sortRecords(table);
+                table.scenegraph.clearCells();
+                table.scenegraph.createSceneGraph();
+            }
+            else if (table.dataSource.rowHierarchyType === 'tree') {
+                table.dataSource.updateRecordsForTree?.(records, recordIndexs);
+                table.refreshRowColCount();
+                table.internalProps.layoutMap.clearCellRangeMap();
+                table.sortState && sortRecords(table);
                 table.scenegraph.clearCells();
                 table.scenegraph.createSceneGraph();
             }
@@ -65877,7 +66170,7 @@
             this.refreshHeader();
             this.internalProps.useOneRowHeightFillAll = false;
             if (options.dataSource) {
-                _setDataSource(this, options.dataSource);
+                this.dataSource = options.dataSource;
             }
             else if (options.records) {
                 this.setRecords(options.records, { sortState: internalProps.sortState });
@@ -65999,8 +66292,7 @@
                     if (record?.vtableMerge) {
                         return '';
                     }
-                    const indexs = this.dataSource.currentIndexedData[row - this.columnHeaderLevelCount];
-                    value = indexs[indexs.length - 1] + 1;
+                    value = this.dataSource.getGroupSeriesNumber(row - this.columnHeaderLevelCount);
                 }
                 else {
                     value = row - this.columnHeaderLevelCount + 1;
@@ -66074,7 +66366,7 @@
         getRecordIndexByCell(col, row) {
             const { layoutMap } = this.internalProps;
             const recordShowIndex = layoutMap.getRecordShowIndexByCell(col, row);
-            return this.dataSource.currentPagerIndexedData[recordShowIndex];
+            return this.dataSource.getRecordIndexPaths(recordShowIndex);
         }
         getTableIndexByRecordIndex(recordIndex) {
             if (this.transpose) {
@@ -66156,7 +66448,7 @@
                 internalProps.releaseList = null;
             }
             if (options.dataSource) {
-                _setDataSource(this, options.dataSource);
+                this.dataSource = options.dataSource;
             }
             else if (options.records) {
                 this.setRecords(options.records, {
@@ -66306,7 +66598,7 @@
                 sourceIndex = this.getRecordShowIndexByCell(0, sourceIndex);
                 targetIndex = this.getRecordShowIndexByCell(0, targetIndex);
             }
-            this.dataSource.reorderRecord(sourceIndex, targetIndex);
+            this.dataSource.changeOrder(sourceIndex, targetIndex);
         }
         getCellAddress(findTargetRecord, field) {
             let targetRecordIndex;
@@ -66510,7 +66802,7 @@
                         return {
                             field: item.field,
                             order: item.order,
-                            orderFn: sortFunc
+                            orderFn: sortFunc ?? defaultOrderFn
                         };
                     }));
                     this.internalProps.layoutMap.clearCellRangeMap();
@@ -68710,22 +69002,7 @@
             if (!this._emptyTipComponent) {
                 return;
             }
-            const leftHeaderWidth = this.table.transpose || this.table.options.indicatorsAsCol === false
-                ? this.table.getFrozenColsWidth()
-                : 0;
-            const topHeaderHeight = !this.table.transpose || this.table.options.indicatorsAsCol
-                ? this.table.getFrozenRowsHeight()
-                : 0;
-            const width = (this.table.columnHeaderLevelCount > 0 && this.table.isListTable()
-                ? this.table.getDrawRange().width
-                : this.table.tableNoFrameWidth) -
-                leftHeaderWidth -
-                this.table.getTheme().scrollStyle.width;
-            const height = (this.table.rowHeaderLevelCount > 0 && this.table.isListTable()
-                ? this.table.getDrawRange().height
-                : this.table.tableNoFrameHeight) -
-                topHeaderHeight -
-                this.table.getTheme().scrollStyle.width;
+            const { leftHeaderWidth, topHeaderHeight, width, height } = this.getWidthAndHeight();
             this._emptyTipComponent.setAttributes({
                 spaceBetweenTextAndIcon: this._emptyTipOption.spaceBetweenTextAndIcon,
                 x: this.table.tableX + leftHeaderWidth,
@@ -68761,7 +69038,7 @@
                 }
             }
         }
-        _getEmptyTipAttrs() {
+        getWidthAndHeight() {
             const leftHeaderWidth = this.table.transpose || this.table.options.indicatorsAsCol === false
                 ? this.table.getFrozenColsWidth()
                 : 0;
@@ -68782,6 +69059,15 @@
                 : this.table.tableNoFrameHeight) -
                 topHeaderHeight -
                 this.table.getTheme().scrollStyle.width;
+            return {
+                leftHeaderWidth,
+                topHeaderHeight,
+                width,
+                height
+            };
+        }
+        _getEmptyTipAttrs() {
+            const { leftHeaderWidth, topHeaderHeight, width, height } = this.getWidthAndHeight();
             return {
                 spaceBetweenTextAndIcon: this._emptyTipOption.spaceBetweenTextAndIcon,
                 x: this.table.tableX + leftHeaderWidth,
@@ -80518,7 +80804,7 @@
     }
 
     registerForVrender();
-    const version = "1.15.1-alpha.1";
+    const version = "1.15.2-alpha.0";
     function getIcons() {
         return get$2();
     }