@visactor/vtable 1.22.11-alpha.5 → 1.22.11-alpha.7

package/dist/vtable.js

@@ -37665,6 +37665,9 @@
                     get textAlign() {
                         return defaultStyle.textAlign ?? 'left';
                     },
+                    get textStickBaseOnAlign() {
+                        return defaultStyle.textStickBaseOnAlign;
+                    },
                     get textBaseline() {
                         return defaultStyle.textBaseline ?? 'middle';
                     },
@@ -38266,6 +38269,9 @@
                 get textStick() {
                     return style.textStick;
                 },
+                get textStickBaseOnAlign() {
+                    return style.textStickBaseOnAlign;
+                },
                 get marked() {
                     return style.marked;
                 },
@@ -38994,69 +39000,150 @@
                 }
             }
         }
-        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) {
+        _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 (viewIndex >= this.records.length) {
+                return rawRecords.length;
+            }
+            if (viewIndex <= 0) {
+                return 0;
+            }
+            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;
                         this.updatePagerData();
                     }
+                    if (this.dataSourceObj?.added) {
+                        this.dataSourceObj.added(index, 1);
+                    }
                 }
-                else {
-                    this.pagination.perPageCount = this._sourceLength;
-                    this.pagination.totalCount = this._sourceLength;
-                    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);
+            this.beforeChangedRecordsMap.clear();
+            this.sortedIndexMap.clear();
+            this.updateFilterRules(this.dataConfig?.filterRules);
+            if (this.dataSourceObj?.added) {
+                this.dataSourceObj.added(rawInsertIndex, 1);
             }
         }
-        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);
+        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]);
+                            }
+                        }
                     }
-                    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]);
+                    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.userPagination) {
-                    this.pagination.totalCount = this._sourceLength;
-                    const { perPageCount, currentPage } = this.pagination;
-                    const startIndex = perPageCount * (currentPage || 0);
-                    const endIndex = startIndex + perPageCount;
-                    if (index < endIndex) {
+                    else {
+                        this.pagination.perPageCount = this._sourceLength;
+                        this.pagination.totalCount = this._sourceLength;
                         this.updatePagerData();
                     }
+                    if (this.dataSourceObj?.added) {
+                        this.dataSourceObj.added(index, recordArr.length);
+                    }
                 }
-                else {
-                    this.pagination.perPageCount = this._sourceLength;
-                    this.pagination.totalCount = this._sourceLength;
-                    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);
+            this.beforeChangedRecordsMap.clear();
+            this.sortedIndexMap.clear();
+            this.updateFilterRules(this.dataConfig?.filterRules);
+            if (this.dataSourceObj?.added) {
+                this.dataSourceObj.added(rawInsertIndex, recordArr.length);
             }
         }
         addRecordForSorted(record) {
@@ -39106,39 +39193,68 @@
                 this.beforeChangedRecordsMap.set((key + delta).toString(), record);
             }
         }
-        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;
+        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;
                     }
-                    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);
+                    if (this.userPagination) {
+                        this.updatePagerData();
                     }
-                    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();
+                    }
+                    if (this.dataSourceObj?.deleted) {
+                        this.dataSourceObj.deleted(realDeletedRecordIndexs);
+                    }
+                    return realDeletedRecordIndexs;
                 }
-                else {
-                    this.pagination.perPageCount = this._sourceLength;
-                    this.pagination.totalCount = this._sourceLength;
-                    this.updatePagerData();
+                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.dataSourceObj?.deleted) {
-                    this.dataSourceObj.deleted(realDeletedRecordIndexs);
+                const deletedRecord = this.records[viewIndex];
+                const rawIndex = rawRecords.indexOf(deletedRecord);
+                if (rawIndex >= 0) {
+                    rawRecords.splice(rawIndex, 1);
+                    rawDeletedIndexs.push(rawIndex);
                 }
-                return realDeletedRecordIndexs;
+                realDeletedRecordIndexs.push(viewIndex);
             }
-            return [];
+            this.beforeChangedRecordsMap.clear();
+            this.sortedIndexMap.clear();
+            this.updateFilterRules(this.dataConfig?.filterRules);
+            if (this.dataSourceObj?.deleted) {
+                this.dataSourceObj.deleted(rawDeletedIndexs);
+            }
+            return realDeletedRecordIndexs;
         }
         deleteRecordsForSorted(recordIndexs) {
             if (Array.isArray(this.records)) {
@@ -39160,36 +39276,71 @@
                 this.beforeChangedRecordsMap.clear();
             }
         }
-        updateRecords(records, recordIndexs) {
-            const realDeletedRecordIndexs = [];
+        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 = [];
             for (let index = 0; index < recordIndexs.length; index++) {
                 const recordIndex = recordIndexs[index];
                 if (Array.isArray(recordIndex)) {
                     this.beforeChangedRecordsMap.delete(recordIndex.toString());
-                    realDeletedRecordIndexs.push(recordIndex);
+                    realUpdatedIndexs.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];
+                    }, rawRecords)[recordIndex[recordIndex.length - 1]] = records[index];
                 }
                 else {
-                    if (recordIndex >= this._sourceLength || recordIndex < 0) {
+                    if (recordIndex >= this.records.length || 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]);
+                    const oldRecord = this.records[recordIndex];
+                    const rawIndex = rawRecords.indexOf(oldRecord);
+                    if (rawIndex >= 0) {
+                        rawRecords[rawIndex] = records[index];
                     }
-                    this.records[recordIndex] = records[index];
+                    realUpdatedIndexs.push(recordIndex);
                 }
             }
-            if (this.userPagination) {
-                this.updatePagerData();
-            }
-            return realDeletedRecordIndexs;
+            this.beforeChangedRecordsMap.clear();
+            this.sortedIndexMap.clear();
+            this.updateFilterRules(this.dataConfig?.filterRules);
+            return realUpdatedIndexs;
         }
         updateRecordsForSorted(records, recordIndexs) {
             for (let index = 0; index < recordIndexs.length; index++) {
@@ -70235,7 +70386,7 @@
             return TABLE_EVENT_TYPE;
         }
         options;
-        version = "1.22.11-alpha.5";
+        version = "1.22.11-alpha.7";
         pagination;
         id = `VTable${Date.now()}`;
         headerStyleCache;
@@ -76643,7 +76794,13 @@
                 table.scenegraph.createSceneGraph();
             }
             else if (table.sortState) {
-                table.dataSource.addRecordForSorted(record);
+                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
+                if (syncToOriginalRecords) {
+                    table.dataSource.addRecord(record, table.dataSource.records.length, true);
+                }
+                else {
+                    table.dataSource.addRecordForSorted(record);
+                }
                 table.stateManager.checkedState.clear();
                 sortRecords(table);
                 table.refreshRowColCount();
@@ -76656,8 +76813,16 @@
                     recordIndex = table.dataSource.sourceLength;
                 }
                 const headerCount = table.transpose ? table.rowHeaderLevelCount : table.columnHeaderLevelCount;
-                table.dataSource.addRecord(record, recordIndex);
+                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
+                table.dataSource.addRecord(record, recordIndex, syncToOriginalRecords);
                 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) {
@@ -76769,7 +76934,13 @@
                 table.scenegraph.createSceneGraph();
             }
             else if (table.sortState) {
-                table.dataSource.addRecordsForSorted(records);
+                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
+                if (syncToOriginalRecords) {
+                    table.dataSource.addRecords(records, table.dataSource.records.length, true);
+                }
+                else {
+                    table.dataSource.addRecordsForSorted(records);
+                }
                 sortRecords(table);
                 table.refreshRowColCount();
                 table.scenegraph.clearCells();
@@ -76784,8 +76955,16 @@
                     recordIndex = 0;
                 }
                 const headerCount = table.transpose ? table.rowHeaderLevelCount : table.columnHeaderLevelCount;
-                table.dataSource.addRecords(records, recordIndex);
+                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
+                table.dataSource.addRecords(records, recordIndex, syncToOriginalRecords);
                 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) {
@@ -76901,20 +77080,34 @@
                 table.scenegraph.createSceneGraph();
             }
             else if (table.sortState) {
-                table.dataSource.deleteRecordsForSorted(recordIndexs);
+                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
+                if (syncToOriginalRecords) {
+                    table.dataSource.deleteRecords(recordIndexs, true);
+                }
+                else {
+                    table.dataSource.deleteRecordsForSorted(recordIndexs);
+                }
                 sortRecords(table);
                 table.refreshRowColCount();
                 table.scenegraph.clearCells();
                 table.scenegraph.createSceneGraph();
             }
             else {
-                const deletedRecordIndexs = table.dataSource.deleteRecords(recordIndexs);
+                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
+                const deletedRecordIndexs = table.dataSource.deleteRecords(recordIndexs, syncToOriginalRecords);
                 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;
@@ -77032,18 +77225,32 @@
                 table.scenegraph.createSceneGraph();
             }
             else if (table.sortState) {
-                table.dataSource.updateRecordsForSorted(records, recordIndexs);
+                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
+                if (syncToOriginalRecords) {
+                    table.dataSource.updateRecords(records, recordIndexs, true);
+                }
+                else {
+                    table.dataSource.updateRecordsForSorted(records, recordIndexs);
+                }
                 sortRecords(table);
                 table.refreshRowColCount();
                 table.scenegraph.clearCells();
                 table.scenegraph.createSceneGraph();
             }
             else {
-                const updateRecordIndexs = table.dataSource.updateRecords(records, recordIndexs);
+                const syncToOriginalRecords = !!table.options?.syncRecordOperationsToSourceRecords;
+                const updateRecordIndexs = table.dataSource.updateRecords(records, recordIndexs, syncToOriginalRecords);
                 if (updateRecordIndexs.length === 0) {
                     return;
                 }
-                const bodyRowIndex = updateRecordIndexs.map(index => table.getBodyRowIndexByRecordIndex(index));
+                if (syncToOriginalRecords) {
+                    table.refreshRowColCount();
+                    table.internalProps.layoutMap.clearCellRangeMap();
+                    table.scenegraph.clearCells();
+                    table.scenegraph.createSceneGraph();
+                    return;
+                }
+                const bodyRowIndex = updateRecordIndexs.map((index) => table.getBodyRowIndexByRecordIndex(index));
                 const recordIndexsMinToMax = bodyRowIndex.sort((a, b) => a - b);
                 if (table.pagination) {
                     const { perPageCount, currentPage } = table.pagination;
@@ -93642,7 +93849,7 @@
     }
 
     registerForVrender();
-    const version = "1.22.11-alpha.5";
+    const version = "1.22.11-alpha.7";
     function getIcons() {
         return get$2();
     }