@visactor/vtable 1.22.11-alpha.9 → 1.22.11

package/dist/vtable.js

@@ -36410,7 +36410,6 @@
         AFTER_UPDATE_CELL_CONTENT_WIDTH: 'after_update_cell_content_width',
         AFTER_UPDATE_SELECT_BORDER_HEIGHT: 'after_update_select_border_height',
         CHANGE_CELL_VALUE: 'change_cell_value',
-        CHANGE_CELL_VALUES: 'change_cell_values',
         DRAG_FILL_HANDLE_END: 'drag_fill_handle_end',
         MOUSEDOWN_FILL_HANDLE: 'mousedown_fill_handle',
         DBLCLICK_FILL_HANDLE: 'dblclick_fill_handle',
@@ -38508,7 +38507,6 @@
         _sourceLength;
         _source;
         sortedIndexMap;
-        _forceVisibleRecords;
         lastSortStates;
         currentIndexedData = [];
         userPagination;
@@ -38934,48 +38932,6 @@
                 }
             }
         }
-        changeFieldValueByRecordIndex(value, recordIndex, field, table) {
-            if (field === null) {
-                return undefined;
-            }
-            if (recordIndex === undefined || recordIndex === null) {
-                return;
-            }
-            const rawKey = recordIndex.toString();
-            if (!this.beforeChangedRecordsMap.has(rawKey)) {
-                const rawRecords = Array.isArray(this.dataSourceObj?.records)
-                    ? this.dataSourceObj.records
-                    : null;
-                const originRecord = rawRecords
-                    ? Array.isArray(recordIndex)
-                        ? getValueFromDeepArray(rawRecords, recordIndex)
-                        : rawRecords[recordIndex]
-                    : undefined;
-                this.beforeChangedRecordsMap.set(rawKey, cloneDeep(originRecord, undefined, ['vtable_gantt_linkedFrom', 'vtable_gantt_linkedTo']) ?? {});
-            }
-            if (typeof field === 'string' || typeof field === 'number') {
-                const beforeChangedValue = this.beforeChangedRecordsMap.get(rawKey)?.[field];
-                const rawRecords = Array.isArray(this.dataSourceObj?.records)
-                    ? this.dataSourceObj.records
-                    : null;
-                const record = rawRecords
-                    ? Array.isArray(recordIndex)
-                        ? getValueFromDeepArray(rawRecords, recordIndex)
-                        : rawRecords[recordIndex]
-                    : undefined;
-                let formatValue = value;
-                if (typeof beforeChangedValue === 'number' && isAllDigits(value)) {
-                    formatValue = parseFloat(value);
-                }
-                if (record) {
-                    record[field] = formatValue;
-                }
-                else if (rawRecords && typeof recordIndex === 'number') {
-                    rawRecords[recordIndex] = this.addRecordRule === 'Array' ? [] : {};
-                    rawRecords[recordIndex][field] = formatValue;
-                }
-            }
-        }
         cacheBeforeChangedRecord(dataIndex, table) {
             if (!this.beforeChangedRecordsMap.has(dataIndex.toString())) {
                 const originRecord = this.getOriginalRecord(dataIndex);
@@ -39001,165 +38957,69 @@
                 }
             }
         }
-        _getRawRecordsArray() {
-            const rawRecords = this.dataSourceObj?.records;
-            return Array.isArray(rawRecords) ? rawRecords : null;
-        }
-        _hasFilterInEffect() {
-            return (this.dataConfig?.filterRules?.length ?? 0) >= 1 || (this.lastFilterRules?.length ?? 0) >= 1;
-        }
-        _normalizeInsertIndex(index, length) {
-            if (index === undefined || index === null) {
-                return length;
-            }
-            if (index > length) {
-                return length;
-            }
-            if (index < 0) {
-                return 0;
-            }
-            return index;
-        }
-        _mapViewInsertIndexToRawInsertIndex(rawRecords, viewIndex) {
-            if (this.records.length === 0) {
-                return rawRecords.length;
-            }
-            if (viewIndex <= 0) {
-                const firstVisibleRecord = this.records[0];
-                const rawIndex = rawRecords.indexOf(firstVisibleRecord);
-                return rawIndex >= 0 ? rawIndex : 0;
-            }
-            if (viewIndex >= this.records.length) {
-                const lastVisibleRecord = this.records[this.records.length - 1];
-                const rawIndex = rawRecords.indexOf(lastVisibleRecord);
-                return rawIndex >= 0 ? rawIndex + 1 : rawRecords.length;
-            }
-            const prevRecord = this.records[viewIndex - 1];
-            const rawIndex = rawRecords.indexOf(prevRecord);
-            return rawIndex >= 0 ? rawIndex + 1 : rawRecords.length;
-        }
-        _resetIndexingFromViewRecords() {
-            this._sourceLength = this.records.length;
-            this.currentIndexedData = Array.from({ length: this._sourceLength }, (_, i) => i);
-            if (this.rowHierarchyType === 'tree') {
-                this.initTreeHierarchyState();
-            }
-            if (this.userPagination) {
-                this.pagination.totalCount = this._sourceLength;
-                this.updatePagerData();
-                return;
-            }
-            this.pagination.perPageCount = this._sourceLength;
-            this.pagination.totalCount = this._sourceLength;
-            this.updatePagerData();
-        }
-        addRecord(record, index, syncToOriginalRecords = false) {
-            if (!syncToOriginalRecords) {
-                if (Array.isArray(this.records)) {
-                    this.records.splice(index, 0, record);
-                    this.adjustBeforeChangedRecordsMap(index, 1);
-                    this.currentIndexedData.push(this.currentIndexedData.length);
-                    this._sourceLength += 1;
-                    for (let i = 0; i < this.fieldAggregators.length; i++) {
-                        this.fieldAggregators[i].push(record);
-                    }
-                    if (this.rowHierarchyType === 'tree') {
-                        this.initTreeHierarchyState();
-                    }
-                    if (this.userPagination) {
-                        this.pagination.totalCount = this._sourceLength;
-                        const { perPageCount, currentPage } = this.pagination;
-                        const startIndex = perPageCount * (currentPage || 0);
-                        const endIndex = startIndex + perPageCount;
-                        if (index < endIndex) {
-                            this.updatePagerData();
-                        }
-                    }
-                    else {
-                        this.pagination.perPageCount = this._sourceLength;
-                        this.pagination.totalCount = this._sourceLength;
+        addRecord(record, index) {
+            if (Array.isArray(this.records)) {
+                this.records.splice(index, 0, record);
+                this.adjustBeforeChangedRecordsMap(index, 1);
+                this.currentIndexedData.push(this.currentIndexedData.length);
+                this._sourceLength += 1;
+                for (let i = 0; i < this.fieldAggregators.length; i++) {
+                    this.fieldAggregators[i].push(record);
+                }
+                if (this.rowHierarchyType === 'tree') {
+                    this.initTreeHierarchyState();
+                }
+                if (this.userPagination) {
+                    this.pagination.totalCount = this._sourceLength;
+                    const { perPageCount, currentPage } = this.pagination;
+                    const startIndex = perPageCount * (currentPage || 0);
+                    const endIndex = startIndex + perPageCount;
+                    if (index < endIndex) {
                         this.updatePagerData();
                     }
-                    if (this.dataSourceObj?.added) {
-                        this.dataSourceObj.added(index, 1);
-                    }
                 }
-                return;
-            }
-            const rawRecords = this._getRawRecordsArray();
-            if (!rawRecords) {
-                return;
-            }
-            const viewInsertIndex = this._normalizeInsertIndex(index, this.records.length);
-            const rawInsertIndex = this._hasFilterInEffect()
-                ? this._mapViewInsertIndexToRawInsertIndex(rawRecords, viewInsertIndex)
-                : this._normalizeInsertIndex(viewInsertIndex, rawRecords.length);
-            rawRecords.splice(rawInsertIndex, 0, record);
-            if (syncToOriginalRecords && this._hasFilterInEffect()) {
-                this.markForceVisibleRecord(record);
-            }
-            this.beforeChangedRecordsMap.clear();
-            this.sortedIndexMap.clear();
-            this.updateFilterRules(this.dataConfig?.filterRules);
-            if (this.dataSourceObj?.added) {
-                this.dataSourceObj.added(rawInsertIndex, 1);
+                else {
+                    this.pagination.perPageCount = this._sourceLength;
+                    this.pagination.totalCount = this._sourceLength;
+                    this.updatePagerData();
+                }
+                if (this.dataSourceObj?.added) {
+                    this.dataSourceObj.added(index, 1);
+                }
             }
         }
-        addRecords(recordArr, index, syncToOriginalRecords = false) {
-            if (!syncToOriginalRecords) {
-                if (Array.isArray(this.records)) {
-                    if (Array.isArray(recordArr)) {
-                        this.records.splice(index, 0, ...recordArr);
-                        this.adjustBeforeChangedRecordsMap(index, recordArr.length);
-                        for (let i = 0; i < recordArr.length; i++) {
-                            this.currentIndexedData.push(this.currentIndexedData.length);
-                        }
-                        this._sourceLength += recordArr.length;
-                        for (let i = 0; i < this.fieldAggregators.length; i++) {
-                            for (let j = 0; j < recordArr.length; j++) {
-                                this.fieldAggregators[i].push(recordArr[j]);
-                            }
-                        }
+        addRecords(recordArr, index) {
+            if (Array.isArray(this.records)) {
+                if (Array.isArray(recordArr)) {
+                    this.records.splice(index, 0, ...recordArr);
+                    this.adjustBeforeChangedRecordsMap(index, recordArr.length);
+                    for (let i = 0; i < recordArr.length; i++) {
+                        this.currentIndexedData.push(this.currentIndexedData.length);
                     }
-                    if (this.userPagination) {
-                        this.pagination.totalCount = this._sourceLength;
-                        const { perPageCount, currentPage } = this.pagination;
-                        const startIndex = perPageCount * (currentPage || 0);
-                        const endIndex = startIndex + perPageCount;
-                        if (index < endIndex) {
-                            this.updatePagerData();
+                    this._sourceLength += recordArr.length;
+                    for (let i = 0; i < this.fieldAggregators.length; i++) {
+                        for (let j = 0; j < recordArr.length; j++) {
+                            this.fieldAggregators[i].push(recordArr[j]);
                         }
                     }
-                    else {
-                        this.pagination.perPageCount = this._sourceLength;
-                        this.pagination.totalCount = this._sourceLength;
+                }
+                if (this.userPagination) {
+                    this.pagination.totalCount = this._sourceLength;
+                    const { perPageCount, currentPage } = this.pagination;
+                    const startIndex = perPageCount * (currentPage || 0);
+                    const endIndex = startIndex + perPageCount;
+                    if (index < endIndex) {
                         this.updatePagerData();
                     }
-                    if (this.dataSourceObj?.added) {
-                        this.dataSourceObj.added(index, recordArr.length);
-                    }
                 }
-                return;
-            }
-            const rawRecords = this._getRawRecordsArray();
-            if (!rawRecords || !Array.isArray(recordArr) || recordArr.length === 0) {
-                return;
-            }
-            const viewInsertIndex = this._normalizeInsertIndex(index, this.records.length);
-            const rawInsertIndex = this._hasFilterInEffect()
-                ? this._mapViewInsertIndexToRawInsertIndex(rawRecords, viewInsertIndex)
-                : this._normalizeInsertIndex(viewInsertIndex, rawRecords.length);
-            rawRecords.splice(rawInsertIndex, 0, ...recordArr);
-            if (syncToOriginalRecords && this._hasFilterInEffect()) {
-                for (let i = 0; i < recordArr.length; i++) {
-                    this.markForceVisibleRecord(recordArr[i]);
+                else {
+                    this.pagination.perPageCount = this._sourceLength;
+                    this.pagination.totalCount = this._sourceLength;
+                    this.updatePagerData();
+                }
+                if (this.dataSourceObj?.added) {
+                    this.dataSourceObj.added(index, recordArr.length);
                 }
-            }
-            this.beforeChangedRecordsMap.clear();
-            this.sortedIndexMap.clear();
-            this.updateFilterRules(this.dataConfig?.filterRules);
-            if (this.dataSourceObj?.added) {
-                this.dataSourceObj.added(rawInsertIndex, recordArr.length);
             }
         }
         addRecordForSorted(record) {
@@ -39193,84 +39053,46 @@
             }
         }
         adjustBeforeChangedRecordsMap(insertIndex, insertCount, type = 'add') {
-            const delta = type === 'add' ? insertCount : -insertCount;
-            const numericKeys = [];
-            this.beforeChangedRecordsMap.forEach((_, key) => {
-                const numKey = Number(key);
-                if (Number.isInteger(numKey) && numKey.toString() === key && numKey >= insertIndex) {
-                    numericKeys.push(numKey);
-                }
-            });
-            numericKeys.sort((a, b) => (type === 'add' ? b - a : a - b));
-            for (let i = 0; i < numericKeys.length; i++) {
-                const key = numericKeys[i];
+            const length = this.beforeChangedRecordsMap.size;
+            for (let key = length - 1; key >= insertIndex; key--) {
                 const record = this.beforeChangedRecordsMap.get(key.toString());
                 this.beforeChangedRecordsMap.delete(key.toString());
-                this.beforeChangedRecordsMap.set((key + delta).toString(), record);
+                this.beforeChangedRecordsMap.set((key + (type === 'add' ? insertCount : -insertCount)).toString(), record);
             }
         }
-        deleteRecords(recordIndexs, syncToOriginalRecords = false) {
-            if (!syncToOriginalRecords) {
-                if (Array.isArray(this.records)) {
-                    const realDeletedRecordIndexs = [];
-                    const recordIndexsMaxToMin = recordIndexs.sort((a, b) => b - a);
-                    for (let index = 0; index < recordIndexsMaxToMin.length; index++) {
-                        const recordIndex = recordIndexsMaxToMin[index];
-                        if (recordIndex >= this._sourceLength || recordIndex < 0) {
-                            continue;
-                        }
-                        this.adjustBeforeChangedRecordsMap(recordIndex, 1, 'delete');
-                        realDeletedRecordIndexs.push(recordIndex);
-                        const deletedRecord = this.records[recordIndex];
-                        for (let i = 0; i < this.fieldAggregators.length; i++) {
-                            this.fieldAggregators[i].deleteRecord(deletedRecord);
-                        }
-                        this.records.splice(recordIndex, 1);
-                        this.currentIndexedData.pop();
-                        this._sourceLength -= 1;
-                    }
-                    if (this.userPagination) {
-                        this.updatePagerData();
-                    }
-                    else {
-                        this.pagination.perPageCount = this._sourceLength;
-                        this.pagination.totalCount = this._sourceLength;
-                        this.updatePagerData();
+        deleteRecords(recordIndexs) {
+            if (Array.isArray(this.records)) {
+                const realDeletedRecordIndexs = [];
+                const recordIndexsMaxToMin = recordIndexs.sort((a, b) => b - a);
+                for (let index = 0; index < recordIndexsMaxToMin.length; index++) {
+                    const recordIndex = recordIndexsMaxToMin[index];
+                    if (recordIndex >= this._sourceLength || recordIndex < 0) {
+                        continue;
                     }
-                    if (this.dataSourceObj?.deleted) {
-                        this.dataSourceObj.deleted(realDeletedRecordIndexs);
+                    this.adjustBeforeChangedRecordsMap(recordIndex, 1, 'delete');
+                    realDeletedRecordIndexs.push(recordIndex);
+                    const deletedRecord = this.records[recordIndex];
+                    for (let i = 0; i < this.fieldAggregators.length; i++) {
+                        this.fieldAggregators[i].deleteRecord(deletedRecord);
                     }
-                    return realDeletedRecordIndexs;
+                    this.records.splice(recordIndex, 1);
+                    this.currentIndexedData.pop();
+                    this._sourceLength -= 1;
                 }
-                return [];
-            }
-            const rawRecords = this._getRawRecordsArray();
-            if (!rawRecords || !Array.isArray(this.records)) {
-                return [];
-            }
-            const realDeletedRecordIndexs = [];
-            const recordIndexsMaxToMin = recordIndexs.slice().sort((a, b) => b - a);
-            const rawDeletedIndexs = [];
-            for (let index = 0; index < recordIndexsMaxToMin.length; index++) {
-                const viewIndex = recordIndexsMaxToMin[index];
-                if (viewIndex >= this.records.length || viewIndex < 0) {
-                    continue;
+                if (this.userPagination) {
+                    this.updatePagerData();
                 }
-                const deletedRecord = this.records[viewIndex];
-                const rawIndex = rawRecords.indexOf(deletedRecord);
-                if (rawIndex >= 0) {
-                    rawRecords.splice(rawIndex, 1);
-                    rawDeletedIndexs.push(rawIndex);
+                else {
+                    this.pagination.perPageCount = this._sourceLength;
+                    this.pagination.totalCount = this._sourceLength;
+                    this.updatePagerData();
                 }
-                realDeletedRecordIndexs.push(viewIndex);
-            }
-            this.beforeChangedRecordsMap.clear();
-            this.sortedIndexMap.clear();
-            this.updateFilterRules(this.dataConfig?.filterRules);
-            if (this.dataSourceObj?.deleted) {
-                this.dataSourceObj.deleted(rawDeletedIndexs);
+                if (this.dataSourceObj?.deleted) {
+                    this.dataSourceObj.deleted(realDeletedRecordIndexs);
+                }
+                return realDeletedRecordIndexs;
             }
-            return realDeletedRecordIndexs;
+            return [];
         }
         deleteRecordsForSorted(recordIndexs) {
             if (Array.isArray(this.records)) {
@@ -39292,71 +39114,36 @@
                 this.beforeChangedRecordsMap.clear();
             }
         }
-        updateRecords(records, recordIndexs, syncToOriginalRecords = false) {
-            if (!syncToOriginalRecords) {
-                const realDeletedRecordIndexs = [];
-                for (let index = 0; index < recordIndexs.length; index++) {
-                    const recordIndex = recordIndexs[index];
-                    if (Array.isArray(recordIndex)) {
-                        this.beforeChangedRecordsMap.delete(recordIndex.toString());
-                        realDeletedRecordIndexs.push(recordIndex);
-                        recordIndex.slice(0, -1).reduce((acc, key) => {
-                            if (acc[key] === undefined) {
-                                acc[key] = {};
-                            }
-                            return acc[key].children;
-                        }, this.records)[recordIndex[recordIndex.length - 1]] = records[index];
-                    }
-                    else {
-                        if (recordIndex >= this._sourceLength || recordIndex < 0) {
-                            continue;
-                        }
-                        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]);
-                        }
-                        this.records[recordIndex] = records[index];
-                    }
-                }
-                if (this.userPagination) {
-                    this.updatePagerData();
-                }
-                return realDeletedRecordIndexs;
-            }
-            const rawRecords = this._getRawRecordsArray();
-            if (!rawRecords || !Array.isArray(this.records)) {
-                return [];
-            }
-            const realUpdatedIndexs = [];
+        updateRecords(records, recordIndexs) {
+            const realDeletedRecordIndexs = [];
             for (let index = 0; index < recordIndexs.length; index++) {
                 const recordIndex = recordIndexs[index];
                 if (Array.isArray(recordIndex)) {
                     this.beforeChangedRecordsMap.delete(recordIndex.toString());
-                    realUpdatedIndexs.push(recordIndex);
+                    realDeletedRecordIndexs.push(recordIndex);
                     recordIndex.slice(0, -1).reduce((acc, key) => {
                         if (acc[key] === undefined) {
                             acc[key] = {};
                         }
                         return acc[key].children;
-                    }, rawRecords)[recordIndex[recordIndex.length - 1]] = records[index];
+                    }, this.records)[recordIndex[recordIndex.length - 1]] = records[index];
                 }
                 else {
-                    if (recordIndex >= this.records.length || recordIndex < 0) {
+                    if (recordIndex >= this._sourceLength || recordIndex < 0) {
                         continue;
                     }
-                    const oldRecord = this.records[recordIndex];
-                    const rawIndex = rawRecords.indexOf(oldRecord);
-                    if (rawIndex >= 0) {
-                        rawRecords[rawIndex] = records[index];
+                    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]);
                     }
-                    realUpdatedIndexs.push(recordIndex);
+                    this.records[recordIndex] = records[index];
                 }
             }
-            this.beforeChangedRecordsMap.clear();
-            this.sortedIndexMap.clear();
-            this.updateFilterRules(this.dataConfig?.filterRules);
-            return realUpdatedIndexs;
+            if (this.userPagination) {
+                this.updatePagerData();
+            }
+            return realDeletedRecordIndexs;
         }
         updateRecordsForSorted(records, recordIndexs) {
             for (let index = 0; index < recordIndexs.length; index++) {
@@ -39437,11 +39224,7 @@
                 }
             }
             if (!filedMapArray.length) {
-                filedMapArray = states.map(() => ({
-                    asc: [],
-                    desc: [],
-                    normal: []
-                }));
+                filedMapArray = states.map(() => ({ asc: [], desc: [], normal: [] }));
                 for (let index = 0; index < states.length; index++) {
                     this.sortedIndexMap.set(states[index].field, filedMapArray[index]);
                 }
@@ -39456,16 +39239,6 @@
         setSortedIndexMap(field, filedMap) {
             this.sortedIndexMap.set(field, filedMap);
         }
-        markForceVisibleRecord(record) {
-            if (!record || (typeof record !== 'object' && typeof record !== 'function')) {
-                return;
-            }
-            this._forceVisibleRecords ||= new WeakSet();
-            this._forceVisibleRecords.add(record);
-        }
-        clearForceVisibleRecords() {
-            this._forceVisibleRecords = undefined;
-        }
         clearFilteredChildren(record) {
             record.filteredChildren = undefined;
             for (let i = 0; i < (record.children?.length ?? 0); i++) {
@@ -39473,9 +39246,6 @@
             }
         }
         filterRecord(record) {
-            if (this._forceVisibleRecords?.has(record)) {
-                return true;
-            }
             let isReserved = true;
             for (let i = 0; i < this.dataConfig.filterRules?.length; i++) {
                 const filterRule = this.dataConfig?.filterRules[i];
@@ -55806,6 +55576,7 @@
             rowUpdatePos = isValid$1(rowUpdatePos) ? (isValid$1(pos) ? Math.min(rowUpdatePos, pos) : rowUpdatePos) : pos;
         }
         scene.table._clearRowRangeHeightsMap();
+        verifyProxyRowStatus(scene);
         let updateAfter;
         addRows.forEach(row => {
             const needUpdateAfter = addRow(row, scene, skipUpdateProxy);
@@ -56224,6 +55995,31 @@
             }
         }
     }
+    function verifyProxyRowStatus(scene) {
+        const proxy = scene.proxy;
+        const { rowStart, rowEnd, rowLimit, totalRow } = proxy;
+        if (rowStart > rowEnd) {
+            proxy.rowStart = scene.table.columnHeaderLevelCount;
+            proxy.rowEnd = Math.min(totalRow, proxy.rowStart + rowLimit - 1);
+            proxy.currentRow = 0;
+            return;
+        }
+        if (rowStart + rowLimit - 1 > totalRow) {
+            const oldRowStart = proxy.rowStart;
+            const newRowStart = Math.max(scene.table.columnHeaderLevelCount, totalRow - rowLimit + 1);
+            if (newRowStart === oldRowStart) {
+                return;
+            }
+            proxy.rowStart = newRowStart;
+            proxy.rowEnd = Math.min(totalRow, newRowStart + rowLimit - 1);
+            proxy.currentRow = proxy.rowEnd + 1;
+            const addRowCount = oldRowStart - proxy.rowStart;
+            for (let i = 0; i < addRowCount; i++) {
+                addRowCellGroup(proxy.rowStart + i, scene);
+            }
+            proxy.rowUpdatePos = proxy.rowStart;
+        }
+    }
 
     function createReactContainer(table) {
         const { internalProps } = table;
@@ -60026,7 +59822,7 @@
                 scenegraph.updateCellSelectBorder(currentRange);
             }
             else {
-                let extendSelectRange = true;
+                let extendSelectRange = isValid$1(skipBodyMerge) ? !skipBodyMerge : true;
                 if (cellPos.col !== -1 && cellPos.row !== -1 && !enableCtrlSelectMode) {
                     state.select.ranges = [];
                     scenegraph.deleteAllSelectBorder();
@@ -60194,7 +59990,7 @@
         }
         else if ((interactionState === InteractionState.grabing || table.eventManager.isDraging) &&
             !table.stateManager.isResizeCol()) {
-            let extendSelectRange = true;
+            let extendSelectRange = isValid$1(skipBodyMerge) ? !skipBodyMerge : true;
             if (cellPos.col === -1) {
                 cellPos.col = col;
             }
@@ -65685,7 +65481,6 @@
         cutOperationTime = 0;
         lastClipboardContent = '';
         cutCellRange = null;
-        cutRanges = null;
         copySourceRange = null;
         constructor(table) {
             this.table = table;
@@ -66205,10 +66000,6 @@
             this.handleCopy(e, true);
             this.cutWaitPaste = true;
             this.cutCellRange = this.table.getSelectedCellInfos();
-            this.cutRanges = this.table.stateManager.select.ranges?.map(r => ({
-                start: { col: r.start.col, row: r.start.row },
-                end: { col: r.end.col, row: r.end.row }
-            }));
             if (this.clipboardCheckTimer) {
                 clearTimeout(this.clipboardCheckTimer);
             }
@@ -66216,7 +66007,6 @@
                 if (this.cutWaitPaste) {
                     this.cutWaitPaste = false;
                     this.cutCellRange = null;
-                    this.cutRanges = null;
                     this.clipboardCheckTimer = null;
                 }
             }, 30000);
@@ -66236,7 +66026,6 @@
                 if (this.cutWaitPaste) {
                     this.cutWaitPaste = false;
                     this.cutCellRange = null;
-                    this.cutRanges = null;
                     if (this.clipboardCheckTimer) {
                         clearTimeout(this.clipboardCheckTimer);
                         this.clipboardCheckTimer = null;
@@ -66352,11 +66141,17 @@
         }
         clearCutArea(table) {
             try {
-                const ranges = this.cutRanges;
-                if (!ranges || ranges.length === 0) {
+                const selectCells = this.cutCellRange;
+                if (!selectCells || selectCells.length === 0) {
                     return;
                 }
-                table.changeCellValuesByIds(ranges, '');
+                for (let i = 0; i < selectCells.length; i++) {
+                    for (let j = 0; j < selectCells[i].length; j++) {
+                        if (selectCells[i][j]) {
+                            table.changeCellValue(selectCells[i][j].col, selectCells[i][j].row, undefined);
+                        }
+                    }
+                }
             }
             catch (error) {
             }
@@ -69873,19 +69668,56 @@
         table;
         customCellStyle;
         customCellStyleArrangement;
+        _customCellStyleArrangementIndex;
+        _customCellStyleArrangementTombstoneCount;
         constructor(table, customCellStyle, customCellStyleArrangement) {
             this.table = table;
             this.customCellStyle = customCellStyle;
             this.customCellStyleArrangement = customCellStyleArrangement;
+            this._customCellStyleArrangementIndex = new Map();
+            this._customCellStyleArrangementTombstoneCount = 0;
+            this._rebuildCustomCellStyleArrangementIndex();
         }
-        clearCustomCellStyleArrangement() {
-            this.customCellStyleArrangement = [];
+        _getCustomCellStyleArrangementKey(cellPos) {
+            if (cellPos.range) {
+                const { start, end } = cellPos.range;
+                return `range:${start.col},${start.row},${end.col},${end.row}`;
+            }
+            if (cellPos.col === undefined || cellPos.row === undefined) {
+                return undefined;
+            }
+            return `cell:${cellPos.col},${cellPos.row}`;
         }
-        addCustomCellStyleArrangement(cellPosition, customStyleId) {
-            this.customCellStyleArrangement.push({
-                cellPosition,
-                customStyleId
-            });
+        _rebuildCustomCellStyleArrangementIndex() {
+            this._customCellStyleArrangementIndex.clear();
+            this._customCellStyleArrangementTombstoneCount = 0;
+            for (let i = 0; i < this.customCellStyleArrangement.length; i++) {
+                if (!isValid$1(this.customCellStyleArrangement[i].customStyleId)) {
+                    this._customCellStyleArrangementTombstoneCount++;
+                    continue;
+                }
+                const key = this._getCustomCellStyleArrangementKey(this.customCellStyleArrangement[i].cellPosition);
+                if (key) {
+                    this._customCellStyleArrangementIndex.set(key, i);
+                }
+            }
+        }
+        _compactCustomCellStyleArrangementIfNeeded() {
+            const length = this.customCellStyleArrangement.length;
+            if (this._customCellStyleArrangementTombstoneCount < 2048) {
+                return;
+            }
+            if (this._customCellStyleArrangementTombstoneCount * 4 < length) {
+                return;
+            }
+            const compacted = this.customCellStyleArrangement.filter(style => isValid$1(style.customStyleId));
+            if (compacted.length === this.customCellStyleArrangement.length) {
+                this._customCellStyleArrangementTombstoneCount = 0;
+                return;
+            }
+            this.customCellStyleArrangement.length = 0;
+            this.customCellStyleArrangement.push(...compacted);
+            this._rebuildCustomCellStyleArrangementIndex();
         }
         getCustomCellStyle(col, row) {
             const customStyleIds = this.getCustomCellStyleIds(col, row);
@@ -69908,6 +69740,9 @@
                         styles.push(styleOption.style);
                     }
                 });
+                if (!styles.length) {
+                    return undefined;
+                }
                 return merge({}, ...styles);
             }
             return undefined;
@@ -69918,6 +69753,9 @@
             for (let c = range.start.col; c <= range.end.col; c++) {
                 for (let r = range.start.row; r <= range.end.row; r++) {
                     this.customCellStyleArrangement.forEach(style => {
+                        if (!isValid$1(style.customStyleId)) {
+                            return;
+                        }
                         if (style.cellPosition.range) {
                             if (style.cellPosition.range.start.col <= c &&
                                 style.cellPosition.range.end.col >= c &&
@@ -69969,15 +69807,40 @@
             this.table.scenegraph.updateNextFrame();
         }
         arrangeCustomCellStyle(cellPos, customStyleId, forceFastUpdate) {
-            const index = this.customCellStyleArrangement.findIndex(style => {
-                if (style.cellPosition.range && cellPos.range) {
-                    return (style.cellPosition.range.start.col === cellPos.range.start.col &&
-                        style.cellPosition.range.start.row === cellPos.range.start.row &&
-                        style.cellPosition.range.end.col === cellPos.range.end.col &&
-                        style.cellPosition.range.end.row === cellPos.range.end.row);
-                }
-                return style.cellPosition.col === cellPos.col && style.cellPosition.row === cellPos.row;
-            });
+            const inputKey = this._getCustomCellStyleArrangementKey(cellPos);
+            let index = inputKey ? this._customCellStyleArrangementIndex.get(inputKey) ?? -1 : -1;
+            if (inputKey && index !== -1) {
+                const item = this.customCellStyleArrangement[index];
+                const itemKey = item ? this._getCustomCellStyleArrangementKey(item.cellPosition) : undefined;
+                if (!item || !isValid$1(item.customStyleId) || itemKey !== inputKey) {
+                    index = this.customCellStyleArrangement.findIndex(style => {
+                        if (!isValid$1(style.customStyleId)) {
+                            return false;
+                        }
+                        return this._getCustomCellStyleArrangementKey(style.cellPosition) === inputKey;
+                    });
+                    if (index !== -1) {
+                        this._customCellStyleArrangementIndex.set(inputKey, index);
+                    }
+                    else {
+                        this._customCellStyleArrangementIndex.delete(inputKey);
+                    }
+                }
+            }
+            if (index === -1 && !inputKey) {
+                index = this.customCellStyleArrangement.findIndex(style => {
+                    if (!isValid$1(style.customStyleId)) {
+                        return false;
+                    }
+                    if (style.cellPosition.range && cellPos.range) {
+                        return (style.cellPosition.range.start.col === cellPos.range.start.col &&
+                            style.cellPosition.range.start.row === cellPos.range.start.row &&
+                            style.cellPosition.range.end.col === cellPos.range.end.col &&
+                            style.cellPosition.range.end.row === cellPos.range.end.row);
+                    }
+                    return style.cellPosition.col === cellPos.col && style.cellPosition.row === cellPos.row;
+                });
+            }
             if (index === -1 && !customStyleId) {
                 return;
             }
@@ -69990,6 +69853,11 @@
                     },
                     customStyleId: customStyleId
                 });
+                const pushedIndex = this.customCellStyleArrangement.length - 1;
+                const pushedKey = this._getCustomCellStyleArrangementKey(this.customCellStyleArrangement[pushedIndex].cellPosition);
+                if (pushedKey) {
+                    this._customCellStyleArrangementIndex.set(pushedKey, pushedIndex);
+                }
             }
             else if (this.customCellStyleArrangement[index].customStyleId === customStyleId) {
                 return;
@@ -69998,9 +69866,17 @@
                 this.customCellStyleArrangement[index].customStyleId = customStyleId;
             }
             else {
-                this.customCellStyleArrangement.splice(index, 1);
+                const existedKey = this._getCustomCellStyleArrangementKey(this.customCellStyleArrangement[index].cellPosition);
+                if (isValid$1(this.customCellStyleArrangement[index].customStyleId)) {
+                    this._customCellStyleArrangementTombstoneCount++;
+                }
+                this.customCellStyleArrangement[index].customStyleId = null;
+                if (existedKey) {
+                    this._customCellStyleArrangementIndex.delete(existedKey);
+                }
+                this._compactCustomCellStyleArrangementIfNeeded();
             }
-            const style = this.getCustomCellStyleOption(customStyleId)?.style;
+            const style = customStyleId ? this.getCustomCellStyleOption(customStyleId)?.style : undefined;
             if (style) {
                 forceFastUpdate = true;
                 for (const key in style) {
@@ -70030,6 +69906,8 @@
         updateCustomCell(customCellStyle, customCellStyleArrangement) {
             this.customCellStyle.length = 0;
             this.customCellStyleArrangement.length = 0;
+            this._customCellStyleArrangementIndex.clear();
+            this._customCellStyleArrangementTombstoneCount = 0;
             customCellStyle.forEach((cellStyle) => {
                 this.registerCustomCellStyle(cellStyle.id, cellStyle.style);
             });
@@ -70415,7 +70293,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "1.22.11-alpha.9";
+        version = "1.22.11";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -72411,6 +72289,7 @@
             this.stateManager.updateSelectPos(startCol, startRow, enableShiftSelectMode, enableCtrlSelectMode, false, this.options.select?.makeSelectCellVisible ?? true, true);
             this.stateManager.updateInteractionState(InteractionState.grabing);
             this.stateManager.updateSelectPos(endCol, endRow, enableShiftSelectMode, enableCtrlSelectMode, false, this.options.select?.makeSelectCellVisible ?? true, true);
+            this.stateManager.select.selecting = false;
         }
         dragSelectCol(colIndex, enableCtrlSelectMode) {
             const currentSelectRanges = this.stateManager.select.ranges;
@@ -72419,10 +72298,10 @@
                 lastSelectRange.end.col = colIndex;
             }
             this.stateManager.updateSelectPos(colIndex, this.rowCount - 1, false, enableCtrlSelectMode, false, this.options.select?.makeSelectCellVisible ?? true, true);
+            this.stateManager.select.selecting = false;
         }
         endDragSelect() {
             this.stateManager.updateInteractionState(InteractionState.default);
-            this.stateManager.endSelectCells(false, false);
         }
         startDragSelectRow(rowIndex, enableCtrlSelectMode, isShift) {
             const lastSelectRange = this.stateManager.select.ranges[this.stateManager.select.ranges.length - 1];
@@ -72433,6 +72312,7 @@
             this.stateManager.updateSelectPos(startCol, startRow, isShift, enableCtrlSelectMode, false, this.options.select?.makeSelectCellVisible ?? true, true);
             this.stateManager.updateInteractionState(InteractionState.grabing);
             this.stateManager.updateSelectPos(endCol, endRow, isShift, enableCtrlSelectMode, false, this.options.select?.makeSelectCellVisible ?? true, true);
+            this.stateManager.select.selecting = false;
         }
         dragSelectRow(rowIndex, isCtrl) {
             const currentSelectRanges = this.stateManager.select.ranges;
@@ -72441,6 +72321,7 @@
                 lastSelectRange.end.row = rowIndex;
             }
             this.stateManager.updateSelectPos(this.colCount - 1, rowIndex, false, isCtrl, false, this.options.select?.makeSelectCellVisible ?? true, true);
+            this.stateManager.select.selecting = false;
         }
         get recordsCount() {
             return this.records?.length;
@@ -73654,6 +73535,22 @@
             }
             return false;
         }
+        updateCellContent(col, row) {
+            this.scenegraph.updateCellContent(col, row);
+        }
+        updateCellContentRange(startCol, startRow, endCol, endRow) {
+            for (let i = startCol; i <= endCol; i++) {
+                for (let j = startRow; j <= endRow; j++) {
+                    this.scenegraph.updateCellContent(i, j);
+                }
+            }
+        }
+        updateCellContentRanges(ranges) {
+            for (let i = 0; i < ranges.length; i++) {
+                const range = ranges[i];
+                this.updateCellContentRange(range.start.col, range.start.row, range.end.col, range.end.row);
+            }
+        }
     }
 
     var core = /*#__PURE__*/Object.freeze({
@@ -76273,7 +76170,7 @@
             }
             const editor = this.table.getEditor(col, row);
             if (editor) {
-                editElement && editor.setElement(editElement);
+                editElement && editor.setElement?.(editElement);
                 if (this.table.internalProps.layoutMap.isSeriesNumber(col, row)) {
                     return;
                 }
@@ -76453,10 +76350,9 @@
         return { addRecordRule };
     }
 
-    function listTableChangeCellValue(col, row, value, workOnEditableCell, triggerEvent, table, silentChangeCellValuesEvent) {
+    function listTableChangeCellValue(col, row, value, workOnEditableCell, triggerEvent, table) {
         if ((workOnEditableCell && table.isHasEditorDefine(col, row)) || workOnEditableCell === false) {
-            const recordShowIndex = table.getRecordShowIndexByCell(col, row);
-            const recordIndex = recordShowIndex >= 0 ? table.dataSource.getIndexKey(recordShowIndex) : undefined;
+            const recordIndex = table.getRecordShowIndexByCell(col, row);
             const { field } = table.internalProps.layoutMap.getBody(col, row);
             const beforeChangeValue = table.getCellRawValue(col, row);
             const oldValue = table.getCellOriginValue(col, row);
@@ -76464,7 +76360,7 @@
                 table.internalProps.layoutMap.updateColumnTitle(col, row, value);
             }
             else {
-                table.dataSource.changeFieldValue(value, recordShowIndex, field, col, row, table);
+                table.dataSource.changeFieldValue(value, recordIndex, field, col, row, table);
             }
             const range = table.getCellRange(col, row);
             const aggregators = table.internalProps.layoutMap.getAggregatorsByCell(col, row);
@@ -76517,24 +76413,18 @@
             }
             const changedValue = table.getCellOriginValue(col, row);
             if (oldValue !== changedValue && triggerEvent) {
-                const changeValue = {
+                table.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUE, {
                     col,
                     row,
-                    recordIndex,
-                    field,
                     rawValue: beforeChangeValue,
                     currentValue: oldValue,
                     changedValue
-                };
-                table.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUE, changeValue);
-                if (!silentChangeCellValuesEvent) {
-                    table.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUES, { values: [changeValue] });
-                }
+                });
             }
             table.scenegraph.updateNextFrame();
         }
     }
-    async function listTableChangeCellValues(startCol, startRow, values, workOnEditableCell, triggerEvent, table, silentChangeCellValuesEvent) {
+    async function listTableChangeCellValues(startCol, startRow, values, workOnEditableCell, triggerEvent, table) {
         const changedCellResults = [];
         let pasteColEnd = startCol;
         let pasteRowEnd = startRow;
@@ -76561,7 +76451,6 @@
                 oldRowValues.push(oldValue);
             }
         }
-        const resultChangeValues = [];
         for (let i = 0; i < values.length; i++) {
             if (startRow + i > table.rowCount - 1) {
                 break;
@@ -76601,8 +76490,7 @@
                 if (isCanChange) {
                     changedCellResults[i][j] = true;
                     const value = rowValues[j];
-                    const recordShowIndex = table.getRecordShowIndexByCell(startCol + j, startRow + i);
-                    const recordIndex = recordShowIndex >= 0 ? table.dataSource.getIndexKey(recordShowIndex) : undefined;
+                    const recordIndex = table.getRecordShowIndexByCell(startCol + j, startRow + i);
                     const { field } = table.internalProps.layoutMap.getBody(startCol + j, startRow + i);
                     const beforeChangeValue = beforeChangeValues[i][j];
                     const oldValue = oldValues[i][j];
@@ -76610,21 +76498,17 @@
                         table.internalProps.layoutMap.updateColumnTitle(startCol + j, startRow + i, value);
                     }
                     else {
-                        table.dataSource.changeFieldValue(value, recordShowIndex, field, startCol + j, startRow + i, table);
+                        table.dataSource.changeFieldValue(value, recordIndex, field, startCol + j, startRow + i, table);
                     }
                     const changedValue = table.getCellOriginValue(startCol + j, startRow + i);
                     if (oldValue !== changedValue && triggerEvent) {
-                        const changeValue = {
+                        table.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUE, {
                             col: startCol + j,
                             row: startRow + i,
-                            recordIndex,
-                            field,
                             rawValue: beforeChangeValue,
                             currentValue: oldValue,
                             changedValue
-                        };
-                        table.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUE, changeValue);
-                        resultChangeValues.push(changeValue);
+                        });
                     }
                 }
                 else {
@@ -76633,9 +76517,6 @@
             }
             pasteColEnd = Math.max(pasteColEnd, thisRowPasteColEnd);
         }
-        if (!silentChangeCellValuesEvent) {
-            table.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUES, { values: resultChangeValues });
-        }
         const startRange = table.getCellRange(startCol, startRow);
         const range = table.getCellRange(pasteColEnd, pasteRowEnd);
         const aggregators = table.internalProps.layoutMap.getAggregatorsByCellRange(startRange.start.col, startRange.start.row, range.end.col, range.end.row);
@@ -76708,68 +76589,6 @@
         table.scenegraph.updateNextFrame();
         return changedCellResults;
     }
-    async function listTableChangeCellValuesByIds(ranges, value, workOnEditableCell, triggerEvent, table, silentChangeCellValuesEvent) {
-        const resultChangeValues = [];
-        const processed = new Set();
-        const nextValue = (value ?? '');
-        for (let i = 0; i < (ranges?.length ?? 0); i++) {
-            const range = ranges[i];
-            const startCol = Math.min(range.start.col, range.end.col);
-            const endCol = Math.max(range.start.col, range.end.col);
-            const startRow = Math.min(range.start.row, range.end.row);
-            const endRow = Math.max(range.start.row, range.end.row);
-            if (startCol > endCol || startRow > endRow) {
-                continue;
-            }
-            const values = [];
-            const oldValues = [];
-            for (let row = startRow; row <= endRow; row++) {
-                const rowValues = [];
-                const rowOldValues = [];
-                for (let col = startCol; col <= endCol; col++) {
-                    rowValues.push(nextValue);
-                    rowOldValues.push(table.getCellOriginValue(col, row));
-                }
-                values.push(rowValues);
-                oldValues.push(rowOldValues);
-            }
-            const changedCellResults = await listTableChangeCellValues(startCol, startRow, values, workOnEditableCell, triggerEvent, table, true);
-            for (let r = 0; r < values.length; r++) {
-                for (let c = 0; c < values[r].length; c++) {
-                    const col = startCol + c;
-                    const row = startRow + r;
-                    const key = `${col},${row}`;
-                    if (processed.has(key)) {
-                        continue;
-                    }
-                    processed.add(key);
-                    if (!triggerEvent || !changedCellResults?.[r]?.[c]) {
-                        continue;
-                    }
-                    const oldValue = oldValues[r][c];
-                    const changedValue = table.getCellOriginValue(col, row);
-                    if (oldValue === changedValue) {
-                        continue;
-                    }
-                    const recordShowIndex = table.getRecordShowIndexByCell(col, row);
-                    const recordIndex = recordShowIndex >= 0 ? table.dataSource.getIndexKey(recordShowIndex) : undefined;
-                    const { field } = table.internalProps.layoutMap.getBody(col, row);
-                    resultChangeValues.push({
-                        col,
-                        row,
-                        recordIndex,
-                        field,
-                        rawValue: oldValue,
-                        currentValue: oldValue,
-                        changedValue
-                    });
-                }
-            }
-        }
-        if (!silentChangeCellValuesEvent && triggerEvent) {
-            table.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUES, { values: resultChangeValues });
-        }
-    }
     function getCellUpdateType(col, row, table, oldCellUpdateType) {
         if (oldCellUpdateType === 'group') {
             return oldCellUpdateType;
@@ -76823,13 +76642,7 @@
                 table.scenegraph.createSceneGraph();
             }
             else if (table.sortState) {
-                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
-                if (syncToOriginalRecords) {
-                    table.dataSource.addRecord(record, table.dataSource.records.length, true);
-                }
-                else {
-                    table.dataSource.addRecordForSorted(record);
-                }
+                table.dataSource.addRecordForSorted(record);
                 table.stateManager.checkedState.clear();
                 sortRecords(table);
                 table.refreshRowColCount();
@@ -76842,16 +76655,8 @@
                     recordIndex = table.dataSource.sourceLength;
                 }
                 const headerCount = table.transpose ? table.rowHeaderLevelCount : table.columnHeaderLevelCount;
-                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
-                table.dataSource.addRecord(record, recordIndex, syncToOriginalRecords);
+                table.dataSource.addRecord(record, recordIndex);
                 adjustCheckBoxStateMapWithAddRecordIndex(table, recordIndex, 1);
-                if (syncToOriginalRecords) {
-                    table.refreshRowColCount();
-                    table.internalProps.layoutMap.clearCellRangeMap();
-                    table.scenegraph.clearCells();
-                    table.scenegraph.createSceneGraph();
-                    return true;
-                }
                 const oldRowCount = table.rowCount;
                 table.refreshRowColCount();
                 if (table.scenegraph.proxy.totalActualBodyRowCount === 0) {
@@ -76963,13 +76768,7 @@
                 table.scenegraph.createSceneGraph();
             }
             else if (table.sortState) {
-                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
-                if (syncToOriginalRecords) {
-                    table.dataSource.addRecords(records, table.dataSource.records.length, true);
-                }
-                else {
-                    table.dataSource.addRecordsForSorted(records);
-                }
+                table.dataSource.addRecordsForSorted(records);
                 sortRecords(table);
                 table.refreshRowColCount();
                 table.scenegraph.clearCells();
@@ -76984,16 +76783,8 @@
                     recordIndex = 0;
                 }
                 const headerCount = table.transpose ? table.rowHeaderLevelCount : table.columnHeaderLevelCount;
-                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
-                table.dataSource.addRecords(records, recordIndex, syncToOriginalRecords);
+                table.dataSource.addRecords(records, recordIndex);
                 adjustCheckBoxStateMapWithAddRecordIndex(table, recordIndex, records.length);
-                if (syncToOriginalRecords) {
-                    table.refreshRowColCount();
-                    table.internalProps.layoutMap.clearCellRangeMap();
-                    table.scenegraph.clearCells();
-                    table.scenegraph.createSceneGraph();
-                    return true;
-                }
                 const oldRowCount = table.transpose ? table.colCount : table.rowCount;
                 table.refreshRowColCount();
                 if (table.scenegraph.proxy.totalActualBodyRowCount === 0) {
@@ -77109,34 +76900,20 @@
                 table.scenegraph.createSceneGraph();
             }
             else if (table.sortState) {
-                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
-                if (syncToOriginalRecords) {
-                    table.dataSource.deleteRecords(recordIndexs, true);
-                }
-                else {
-                    table.dataSource.deleteRecordsForSorted(recordIndexs);
-                }
+                table.dataSource.deleteRecordsForSorted(recordIndexs);
                 sortRecords(table);
                 table.refreshRowColCount();
                 table.scenegraph.clearCells();
                 table.scenegraph.createSceneGraph();
             }
             else {
-                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
-                const deletedRecordIndexs = table.dataSource.deleteRecords(recordIndexs, syncToOriginalRecords);
+                const deletedRecordIndexs = table.dataSource.deleteRecords(recordIndexs);
                 if (deletedRecordIndexs.length === 0) {
                     return;
                 }
                 for (let index = 0; index < deletedRecordIndexs.length; index++) {
                     adjustCheckBoxStateMapWithDeleteRecordIndex(table, deletedRecordIndexs[index], 1);
                 }
-                if (syncToOriginalRecords) {
-                    table.refreshRowColCount();
-                    table.internalProps.layoutMap.clearCellRangeMap();
-                    table.scenegraph.clearCells();
-                    table.scenegraph.createSceneGraph();
-                    return;
-                }
                 const oldRowCount = table.transpose ? table.colCount : table.rowCount;
                 table.refreshRowColCount();
                 const newRowCount = table.transpose ? table.colCount : table.rowCount;
@@ -77254,32 +77031,18 @@
                 table.scenegraph.createSceneGraph();
             }
             else if (table.sortState) {
-                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
-                if (syncToOriginalRecords) {
-                    table.dataSource.updateRecords(records, recordIndexs, true);
-                }
-                else {
-                    table.dataSource.updateRecordsForSorted(records, recordIndexs);
-                }
+                table.dataSource.updateRecordsForSorted(records, recordIndexs);
                 sortRecords(table);
                 table.refreshRowColCount();
                 table.scenegraph.clearCells();
                 table.scenegraph.createSceneGraph();
             }
             else {
-                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
-                const updateRecordIndexs = table.dataSource.updateRecords(records, recordIndexs, syncToOriginalRecords);
+                const updateRecordIndexs = table.dataSource.updateRecords(records, recordIndexs);
                 if (updateRecordIndexs.length === 0) {
                     return;
                 }
-                if (syncToOriginalRecords) {
-                    table.refreshRowColCount();
-                    table.internalProps.layoutMap.clearCellRangeMap();
-                    table.scenegraph.clearCells();
-                    table.scenegraph.createSceneGraph();
-                    return;
-                }
-                const bodyRowIndex = updateRecordIndexs.map((index) => table.getBodyRowIndexByRecordIndex(index));
+                const bodyRowIndex = updateRecordIndexs.map(index => table.getBodyRowIndexByRecordIndex(index));
                 const recordIndexsMinToMax = bodyRowIndex.sort((a, b) => a - b);
                 if (table.pagination) {
                     const { perPageCount, currentPage } = table.pagination;
@@ -78456,7 +78219,6 @@
         }
         updateFilterRules(filterRules, options = { clearRowHeightCache: true }) {
             this.scenegraph.clearCells();
-            this.dataSource.clearForceVisibleRecords?.();
             if (this.sortState) {
                 this.dataSource.updateFilterRulesForSorted(filterRules);
                 sortRecords(this);
@@ -78677,182 +78439,17 @@
             }
             return isValid$1(editorDefine);
         }
-        changeCellValue(col, row, value, workOnEditableCell = false, triggerEvent = true, silentChangeCellValuesEvent) {
-            return listTableChangeCellValue(col, row, value, workOnEditableCell, triggerEvent, this, silentChangeCellValuesEvent);
-        }
-        changeCellValues(startCol, startRow, values, workOnEditableCell = false, triggerEvent = true, silentChangeCellValuesEvent) {
-            return listTableChangeCellValues(startCol, startRow, values, workOnEditableCell, triggerEvent, this, silentChangeCellValuesEvent);
+        changeCellValue(col, row, value, workOnEditableCell = false, triggerEvent = true) {
+            return listTableChangeCellValue(col, row, value, workOnEditableCell, triggerEvent, this);
         }
-        changeCellValuesByIds(ranges, value, workOnEditableCell = false, triggerEvent = true, silentChangeCellValuesEvent) {
-            return listTableChangeCellValuesByIds(ranges, value, workOnEditableCell, triggerEvent, this, silentChangeCellValuesEvent);
+        changeCellValues(startCol, startRow, values, workOnEditableCell = false, triggerEvent = true) {
+            return listTableChangeCellValues(startCol, startRow, values, workOnEditableCell, triggerEvent, this);
         }
-        changeSourceCellValue(recordIndex, field, value) {
-            const tableIndex = this.getTableIndexByRecordIndex(recordIndex);
-            const cellAddr = this.getCellAddrByFieldRecord(field, recordIndex);
-            if (tableIndex < 0 || cellAddr.col < 0 || cellAddr.row < 0) {
-                return;
-            }
-            this.dataSource.changeFieldValue(value, tableIndex, field, cellAddr.col, cellAddr.row, this);
-            const beforeChangeValue = this.getCellRawValue(cellAddr.col, cellAddr.row);
-            const oldValue = this.getCellOriginValue(cellAddr.col, cellAddr.row);
-            const changedValue = this.getCellOriginValue(cellAddr.col, cellAddr.row);
-            if (oldValue !== changedValue) {
-                const changeValue = {
-                    col: cellAddr.col,
-                    row: cellAddr.row,
-                    recordIndex,
-                    field,
-                    rawValue: beforeChangeValue,
-                    currentValue: oldValue,
-                    changedValue
-                };
-                this.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUE, changeValue);
-                this.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUES, { values: [changeValue] });
-            }
-        }
-        changeCellValueByRecord(recordIndex, field, value, options) {
-            const triggerEvent = options?.triggerEvent ?? true;
-            const silentChangeCellValuesEvent = options?.silentChangeCellValuesEvent;
-            const autoRefresh = options?.autoRefresh ?? true;
-            const records = this.dataSource.dataSourceObj?.records;
-            let record;
-            let oldValue;
-            if (Array.isArray(records) && (typeof field === 'string' || typeof field === 'number')) {
-                record = Array.isArray(recordIndex) ? getValueFromDeepArray(records, recordIndex) : records[recordIndex];
-                oldValue = record?.[field];
-            }
-            this.dataSource.changeFieldValueByRecordIndex(value, recordIndex, field, this);
-            if (!triggerEvent) {
-                return;
-            }
-            const changedValue = record && (typeof field === 'string' || typeof field === 'number') ? record?.[field] : value;
-            if (oldValue !== changedValue) {
-                const cellAddr = this.getCellAddrByFieldRecord(field, recordIndex);
-                const changeValue = {
-                    col: cellAddr?.col ?? -1,
-                    row: cellAddr?.row ?? -1,
-                    recordIndex,
-                    field,
-                    rawValue: oldValue,
-                    currentValue: oldValue,
-                    changedValue
-                };
-                this.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUE, changeValue);
-                if (!silentChangeCellValuesEvent) {
-                    this.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUES, { values: [changeValue] });
-                }
-            }
-            if (autoRefresh) {
-                this.refreshAfterSourceChange();
-            }
-        }
-        changeCellValueBySource(recordIndex, field, value, triggerEvent = true, silentChangeCellValuesEvent) {
-            return this.changeCellValueByRecord(recordIndex, field, value, {
-                triggerEvent,
-                silentChangeCellValuesEvent,
-                autoRefresh: true
-            });
-        }
-        changeCellValuesByRecords(changeValues, options) {
-            const triggerEvent = options?.triggerEvent ?? true;
-            const silentChangeCellValuesEvent = options?.silentChangeCellValuesEvent;
-            const autoRefresh = options?.autoRefresh ?? true;
-            const resultChangeValues = [];
-            for (let i = 0; i < changeValues.length; i++) {
-                const { recordIndex, field, value } = changeValues[i];
-                const records = this.dataSource.dataSourceObj?.records;
-                let record;
-                let oldValue;
-                if (Array.isArray(records) && (typeof field === 'string' || typeof field === 'number')) {
-                    record = Array.isArray(recordIndex) ? getValueFromDeepArray(records, recordIndex) : records[recordIndex];
-                    oldValue = record?.[field];
-                }
-                this.dataSource.changeFieldValueByRecordIndex(value, recordIndex, field, this);
-                if (triggerEvent) {
-                    const changedValue = record && (typeof field === 'string' || typeof field === 'number') ? record?.[field] : value;
-                    if (oldValue !== changedValue) {
-                        const changeValue = {
-                            col: (this.getCellAddrByFieldRecord(field, recordIndex)?.col ?? -1),
-                            row: (this.getCellAddrByFieldRecord(field, recordIndex)?.row ?? -1),
-                            recordIndex,
-                            field,
-                            rawValue: oldValue,
-                            currentValue: oldValue,
-                            changedValue
-                        };
-                        this.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUE, changeValue);
-                        resultChangeValues.push(changeValue);
-                    }
-                }
-            }
-            if (!silentChangeCellValuesEvent && resultChangeValues.length && triggerEvent) {
-                this.fireListeners(TABLE_EVENT_TYPE.CHANGE_CELL_VALUES, { values: resultChangeValues });
-            }
-            if (autoRefresh) {
-                this.refreshAfterSourceChange();
-            }
-        }
-        changeCellValuesBySource(changeValues, triggerEvent = true, silentChangeCellValuesEvent) {
-            return this.changeCellValuesByRecords(changeValues, {
-                triggerEvent,
-                silentChangeCellValuesEvent,
-                autoRefresh: true
-            });
-        }
-        refreshAfterSourceChange(options) {
-            const reapplyFilter = options?.reapplyFilter ?? true;
-            const reapplySort = options?.reapplySort ?? true;
-            const clearRowHeightCache = options?.clearRowHeightCache ?? true;
-            this.scenegraph.clearCells();
-            if (this.sortState && reapplySort) {
-                this.dataSource.clearSortedIndexMap?.();
-                this.dataSource.sortedIndexMap?.clear?.();
-            }
-            if (reapplyFilter) {
-                if (this.sortState && reapplySort) {
-                    this.dataSource.updateFilterRulesForSorted(this.dataSource.dataConfig?.filterRules);
-                    sortRecords(this);
-                }
-                else {
-                    this.dataSource.updateFilterRules(this.dataSource.dataConfig?.filterRules);
-                }
-            }
-            else if (this.sortState && reapplySort) {
-                sortRecords(this);
-            }
-            const traverseColumns = (columns) => {
-                for (let i = 0; i < (columns?.length ?? 0); i++) {
-                    const column = columns[i];
-                    const aggregators = column?.vtable_aggregator;
-                    if (aggregators) {
-                        if (Array.isArray(aggregators)) {
-                            for (let j = 0; j < aggregators.length; j++) {
-                                aggregators[j]?.recalculate?.();
-                            }
-                        }
-                        else {
-                            aggregators?.recalculate?.();
-                        }
-                    }
-                    if (column?.columns) {
-                        traverseColumns(column.columns);
-                    }
-                }
-            };
-            traverseColumns(this.internalProps.columns);
-            this.refreshRowColCount();
-            this.internalProps.layoutMap.clearCellRangeMap();
-            this.internalProps.useOneRowHeightFillAll = false;
-            this.stateManager.initCheckedState(this.records);
-            this.scenegraph.createSceneGraph(!clearRowHeightCache);
-            this.internalProps.emptyTip?.resetVisible();
-            this.resize();
-        }
-        addRecord(record, recordIndex, triggerEvent = true) {
+        addRecord(record, recordIndex) {
             const success = listTableAddRecord(record, recordIndex, this);
             adjustHeightResizedRowMapWithAddRecordIndex(this, recordIndex, [record]);
             this.internalProps.emptyTip?.resetVisible();
-            if (triggerEvent && success) {
+            if (success) {
                 this.fireListeners(TABLE_EVENT_TYPE.ADD_RECORD, {
                     records: [record],
                     recordIndex,
@@ -78860,13 +78457,13 @@
                 });
             }
         }
-        addRecords(records, recordIndex, triggerEvent = true) {
+        addRecords(records, recordIndex) {
             const success = listTableAddRecords(records, recordIndex, this);
             if (typeof recordIndex === 'number') {
                 adjustHeightResizedRowMapWithAddRecordIndex(this, recordIndex, records);
             }
             this.internalProps.emptyTip?.resetVisible();
-            if (triggerEvent && success) {
+            if (success) {
                 this.fireListeners(TABLE_EVENT_TYPE.ADD_RECORD, {
                     records,
                     recordIndex,
@@ -78874,20 +78471,7 @@
                 });
             }
         }
-        deleteRecords(recordIndexs, triggerEvent = true) {
-            const deletedRecords = [];
-            if (recordIndexs?.length > 0) {
-                recordIndexs.forEach(index => {
-                    let record = null;
-                    if (typeof index === 'number') {
-                        record = this.dataSource.get(index);
-                    }
-                    else {
-                        record = [];
-                    }
-                    deletedRecords.push(record);
-                });
-            }
+        deleteRecords(recordIndexs) {
             listTableDeleteRecords(recordIndexs, this);
             adjustHeightResizedRowMapWithDeleteRecordIndex(this, recordIndexs);
             this.internalProps.emptyTip?.resetVisible();
@@ -78895,26 +78479,21 @@
             for (let i = 0; i < recordIndexs.length; i++) {
                 rowIndexs.push(this.getBodyRowIndexByRecordIndex(recordIndexs[i]) + this.columnHeaderLevelCount);
             }
-            if (triggerEvent) {
-                this.fireListeners(TABLE_EVENT_TYPE.DELETE_RECORD, {
-                    recordIndexs,
-                    records: deletedRecords,
-                    rowIndexs,
-                    deletedCount: Array.isArray(recordIndexs[0])
-                        ? recordIndexs.length
-                        : recordIndexs.length
-                });
-            }
+            this.fireListeners(TABLE_EVENT_TYPE.DELETE_RECORD, {
+                recordIndexs,
+                rowIndexs,
+                deletedCount: Array.isArray(recordIndexs[0])
+                    ? recordIndexs.length
+                    : recordIndexs.length
+            });
         }
-        updateRecords(records, recordIndexs, triggerEvent = true) {
+        updateRecords(records, recordIndexs) {
             listTableUpdateRecords(records, recordIndexs, this);
-            if (triggerEvent) {
-                this.fireListeners(TABLE_EVENT_TYPE.UPDATE_RECORD, {
-                    records,
-                    recordIndexs,
-                    updateCount: records.length
-                });
-            }
+            this.fireListeners(TABLE_EVENT_TYPE.UPDATE_RECORD, {
+                records,
+                recordIndexs,
+                updateCount: records.length
+            });
         }
         _hasCustomRenderOrLayout() {
             const { headerObjects } = this.internalProps.layoutMap;
@@ -86636,7 +86215,11 @@
                 const colHeaderPath = {};
                 colHeaderPath.dimensionKey = colHeader.dimensionKey;
                 colHeaderPath.indicatorKey = colHeader.indicatorKey;
-                colHeaderPath.value = colHeader.value ?? this.getIndicatorInfoByIndicatorKey(colHeader.indicatorKey)?.title ?? '';
+                colHeaderPath.value =
+                    colHeader.value ??
+                        (colHeader.indicatorKey
+                            ? this.getIndicatorInfoByIndicatorKey(colHeader.indicatorKey)?.title ?? ''
+                            : colHeader.value);
                 colHeaderPath.virtual = colHeader.virtual;
                 colHeaderPath.role = colHeader.role;
                 headerPaths.colHeaderPaths.push(colHeaderPath);
@@ -89460,10 +89043,11 @@
                 }
                 if (rowKey.length < this.rows.length && this.rowHierarchyType === 'grid-tree') {
                     if (rowKey[0] === this.rowGrandTotalLabel) ;
-                    else if (this.totals?.row?.subTotalsDimensions &&
+                    else if (((this.totals?.row?.subTotalsDimensions &&
                         this.totals?.row?.subTotalsDimensions?.length >= 1 &&
-                        rowKey[rowKey.length - 1] !== this.rowSubTotalLabel &&
-                        this.totals.row.subTotalsDimensions.find((dimension) => dimension === rowDimensionKey)) {
+                        this.totals.row.subTotalsDimensions.find((dimension) => dimension === rowDimensionKey)) ||
+                        this.totals?.row?.showSubTotalsOnTreeNode) &&
+                        rowKey[rowKey.length - 1] !== this.rowSubTotalLabel) {
                         rowKey.push(this.rowSubTotalLabel);
                     }
                 }
@@ -89482,10 +89066,11 @@
                 }
                 if (colKey.length < this.columns.length && this.columnHierarchyType === 'grid-tree') {
                     if (colKey[0] === this.colGrandTotalLabel) ;
-                    else if (this.totals?.column?.subTotalsDimensions &&
+                    else if (((this.totals?.column?.subTotalsDimensions &&
                         this.totals?.column?.subTotalsDimensions?.length >= 1 &&
-                        colKey[colKey.length - 1] !== this.colSubTotalLabel &&
-                        this.totals.column.subTotalsDimensions.find((dimension) => dimension === colDimensionKey)) {
+                        this.totals.column.subTotalsDimensions.find((dimension) => dimension === colDimensionKey)) ||
+                        this.totals?.column?.showSubTotalsOnTreeNode) &&
+                        colKey[colKey.length - 1] !== this.colSubTotalLabel) {
                         colKey.push(this.colSubTotalLabel);
                     }
                 }
@@ -89679,11 +89264,16 @@
                     return;
                 }
                 const colKey = flatColKey.split(this.stringJoinChar);
-                if (that.totals?.column?.subTotalsDimensions &&
+                if ((that.totals?.column?.subTotalsDimensions &&
                     that.totals?.column?.subTotalsDimensions?.length > 0 &&
-                    that.totals.column.showSubTotals !== false) {
-                    for (let i = 0, len = that.totals?.column?.subTotalsDimensions?.length; i < len; i++) {
-                        const dimension = that.totals.column.subTotalsDimensions[i];
+                    (that.totals?.column?.showSubTotals !== false || that.totals?.column?.showSubTotalsOnTreeNode)) ||
+                    (that.totals?.column?.showSubTotalsOnTreeNode && that.columns.length > 0)) {
+                    let colSubTotalDimensions = that.totals?.column?.subTotalsDimensions || [];
+                    if (that.totals?.column?.showSubTotalsOnTreeNode && colSubTotalDimensions.length === 0) {
+                        colSubTotalDimensions = that.columns.map(col => col);
+                    }
+                    for (let i = 0, len = colSubTotalDimensions.length; i < len; i++) {
+                        const dimension = colSubTotalDimensions[i];
                         const dimensionIndex = that.columns.indexOf(dimension);
                         if (dimensionIndex >= 0) {
                             const colTotalKey = colKey.slice(0, dimensionIndex + 1);
@@ -89802,16 +89392,23 @@
             if ((that?.totals?.column?.subTotalsDimensions && that?.totals?.column?.subTotalsDimensions?.length >= 1) ||
                 (that?.totals?.row?.subTotalsDimensions && that?.totals?.row?.subTotalsDimensions?.length >= 1) ||
                 that?.totals?.column?.showGrandTotals ||
-                that?.totals?.row?.showGrandTotals) {
+                that?.totals?.row?.showGrandTotals ||
+                that?.totals?.row?.showSubTotalsOnTreeNode ||
+                that?.totals?.column?.showSubTotalsOnTreeNode) {
                 const rowTotalKeys = [];
                 Object.keys(that.tree).forEach(flatRowKey => {
                     const rowKey = flatRowKey.split(this.stringJoinChar);
                     Object.keys(that.tree[flatRowKey]).forEach(flatColKey => {
-                        if (that.totals?.row?.subTotalsDimensions &&
+                        if ((that.totals?.row?.subTotalsDimensions &&
                             that.totals?.row?.subTotalsDimensions?.length > 0 &&
-                            that.totals.row.showSubTotals !== false) {
-                            for (let i = 0, len = that.totals?.row?.subTotalsDimensions?.length; i < len; i++) {
-                                const dimension = that.totals.row.subTotalsDimensions[i];
+                            (that.totals?.row?.showSubTotals !== false || that.totals?.row?.showSubTotalsOnTreeNode)) ||
+                            (that.totals?.row?.showSubTotalsOnTreeNode && that.rows.length > 0)) {
+                            let rowSubTotalDimensions = that.totals?.row?.subTotalsDimensions || [];
+                            if (that.totals?.row?.showSubTotalsOnTreeNode && rowSubTotalDimensions.length === 0) {
+                                rowSubTotalDimensions = that.rows.map(row => row);
+                            }
+                            for (let i = 0, len = rowSubTotalDimensions.length; i < len; i++) {
+                                const dimension = rowSubTotalDimensions[i];
                                 const dimensionIndex = that.rows.indexOf(dimension);
                                 if (dimensionIndex >= 0 && dimensionIndex < that.rows.length - 1) {
                                     const rowTotalKey = rowKey.slice(0, dimensionIndex + 1);
@@ -93879,7 +93476,7 @@
     }
 
     registerForVrender();
-    const version = "1.22.11-alpha.9";
+    const version = "1.22.11";
     function getIcons() {
         return get$2();
     }