@visactor/vtable 1.5.3-alpha.1 → 1.5.3

package/es/ListTable.d.ts

@@ -68,7 +68,7 @@ export declare class ListTable extends BaseTable implements ListTableAPI {
         sortState?: SortState | SortState[];
     }): void;
     setRecordChildren(records: any[], col: number, row: number): void;
-    startEditCell(col?: number, row?: number): void;
+    startEditCell(col?: number, row?: number, value?: string | number): void;
     completeEditCell(): void;
     getEditor(col: number, row: number): IEditor<any>;
     isHasEditorDefine(col: number, row: number): boolean;
@@ -87,5 +87,4 @@ export declare class ListTable extends BaseTable implements ListTableAPI {
         }[];
     }[];
     isAggregation(col: number, row: number): boolean;
-    getGroupTitleLevel(col: number, row: number): number | undefined;
 }

package/es/ListTable.js

@@ -2,9 +2,9 @@ import { HierarchyState } from "./ts-types";
 
 import { SimpleHeaderLayoutMap } from "./layout";
 
-import { isArray, isValid } from "@visactor/vutils";
+import { isValid } from "@visactor/vutils";
 
-import { _setDataSource, _setRecords } from "./core/tableHelper";
+import { _setDataSource, _setRecords, sortRecords } from "./core/tableHelper";
 
 import { BaseTable } from "./core";
 
@@ -30,23 +30,17 @@ import { setCellCheckboxState } from "./state/checkbox/checkbox";
 
 import { Factory } from "./core/factory";
 
-import { getGroupByDataConfig } from "./core/group-helper";
-
-import { listTableAddRecord, listTableAddRecords, listTableDeleteRecords, listTableUpdateRecords, sortRecords } from "./core/record-helper";
-
 export class ListTable extends BaseTable {
     constructor(container, options) {
-        var _a, _b, _c, _d;
+        var _a, _b;
         "node" === Env.mode ? (options = container, container = null) : container instanceof HTMLElement || (options = container, 
         container = container.container ? container.container : null), super(container, options), 
         this.showHeader = !0;
         const internalProps = this.internalProps;
         if (internalProps.frozenColDragHeaderMode = options.frozenColDragHeaderMode, this.pagination = options.pagination, 
-        internalProps.sortState = options.sortState, internalProps.dataConfig = options.groupBy ? getGroupByDataConfig(options.groupBy) : {}, 
-        internalProps.columns = options.columns ? cloneDeepSpec(options.columns, [ "children" ]) : options.header ? cloneDeepSpec(options.header, [ "children" ]) : [], 
-        internalProps.enableTreeNodeMerge = null !== (_b = null !== (_a = options.enableTreeNodeMerge) && void 0 !== _a ? _a : isValid(options.groupBy)) && void 0 !== _b && _b, 
-        this.internalProps.headerHelper.setTableColumnsEditor(), this.showHeader = null === (_c = options.showHeader) || void 0 === _c || _c, 
-        this.transpose = null !== (_d = options.transpose) && void 0 !== _d && _d, "node" !== Env.mode && (this.editorManager = new EditManeger(this)), 
+        internalProps.sortState = options.sortState, internalProps.dataConfig = {}, internalProps.columns = options.columns ? cloneDeepSpec(options.columns, [ "children" ]) : options.header ? cloneDeepSpec(options.header, [ "children" ]) : [], 
+        this.internalProps.headerHelper.setTableColumnsEditor(), this.showHeader = null === (_a = options.showHeader) || void 0 === _a || _a, 
+        this.transpose = null !== (_b = options.transpose) && void 0 !== _b && _b, "node" !== Env.mode && (this.editorManager = new EditManeger(this)), 
         this.refreshHeader(), this.internalProps.useOneRowHeightFillAll = !1, options.dataSource ? _setDataSource(this, options.dataSource) : options.records ? this.setRecords(options.records, {
             sortState: internalProps.sortState
         }) : this.setRecords([]), options.title) {
@@ -350,9 +344,7 @@ export class ListTable extends BaseTable {
         return null;
     }
     getHierarchyState(col, row) {
-        if (!this.options.groupBy) {
-            if (!this.getBodyColumnDefine(col, row).tree) return HierarchyState.none;
-        }
+        if (!this.getBodyColumnDefine(col, row).tree) return HierarchyState.none;
         const index = this.getRecordShowIndexByCell(col, row);
         return this.dataSource.getHierarchyState(index);
     }
@@ -489,12 +481,12 @@ export class ListTable extends BaseTable {
         const index = this.getRecordShowIndexByCell(col, row);
         this.dataSource.setRecord(record, index), this._refreshHierarchyState(col, row);
     }
-    startEditCell(col, row) {
+    startEditCell(col, row, value) {
         var _a;
         if (isValid(col) && isValid(row)) this.eventManager.isDraging = !1, this.selectCell(col, row), 
-        this.editorManager.startEditCell(col, row); else if (null === (_a = this.stateManager.select) || void 0 === _a ? void 0 : _a.cellPos) {
+        this.editorManager.startEditCell(col, row, value); else if (null === (_a = this.stateManager.select) || void 0 === _a ? void 0 : _a.cellPos) {
             const {col: col, row: row} = this.stateManager.select.cellPos;
-            isValid(col) && isValid(row) && this.editorManager.startEditCell(col, row);
+            isValid(col) && isValid(row) && this.editorManager.startEditCell(col, row, value);
         }
     }
     completeEditCell() {
@@ -617,16 +609,194 @@ export class ListTable extends BaseTable {
         this.scenegraph.updateNextFrame();
     }
     addRecord(record, recordIndex) {
-        listTableAddRecord(record, recordIndex, this);
+        if (this.sortState) this.dataSource.addRecordForSorted(record), sortRecords(this), 
+        this.refreshRowColCount(), this.scenegraph.clearCells(), this.scenegraph.createSceneGraph(); else {
+            (void 0 === recordIndex || recordIndex > this.dataSource.sourceLength) && (recordIndex = this.dataSource.sourceLength);
+            const headerCount = this.transpose ? this.rowHeaderLevelCount : this.columnHeaderLevelCount;
+            this.dataSource.addRecord(record, recordIndex);
+            const oldRowCount = this.rowCount;
+            if (this.refreshRowColCount(), 0 === this.scenegraph.proxy.totalActualBodyRowCount) return this.scenegraph.clearCells(), 
+            void this.scenegraph.createSceneGraph();
+            const newRowCount = this.transpose ? this.colCount : this.rowCount;
+            if (this.pagination) {
+                const {perPageCount: perPageCount, currentPage: currentPage} = this.pagination, endIndex = perPageCount * (currentPage || 0) + perPageCount;
+                if (recordIndex < endIndex) if (recordIndex < endIndex - perPageCount) this.scenegraph.clearCells(), 
+                this.scenegraph.createSceneGraph(); else {
+                    const rowNum = recordIndex - (endIndex - perPageCount) + headerCount;
+                    if (oldRowCount - headerCount === this.pagination.perPageCount) {
+                        const updateRows = [];
+                        for (let row = rowNum; row < newRowCount; row++) this.transpose ? updateRows.push({
+                            col: row,
+                            row: 0
+                        }) : updateRows.push({
+                            col: 0,
+                            row: row
+                        });
+                        this.transpose ? this.scenegraph.updateCol([], [], updateRows) : this.scenegraph.updateRow([], [], updateRows);
+                    } else {
+                        const addRows = [];
+                        for (let row = rowNum; row < Math.min(newRowCount, rowNum + 1); row++) this.transpose ? addRows.push({
+                            col: row,
+                            row: 0
+                        }) : addRows.push({
+                            col: 0,
+                            row: row
+                        });
+                        this.transpose ? this.scenegraph.updateCol([], addRows, []) : this.scenegraph.updateRow([], addRows, []);
+                    }
+                }
+            } else {
+                const addRows = [];
+                for (let row = recordIndex + headerCount; row < recordIndex + headerCount + 1; row++) this.transpose ? addRows.push({
+                    col: row,
+                    row: 0
+                }) : addRows.push({
+                    col: 0,
+                    row: row
+                });
+                this.transpose ? this.scenegraph.updateCol([], addRows, []) : this.scenegraph.updateRow([], addRows, []);
+            }
+        }
     }
     addRecords(records, recordIndex) {
-        listTableAddRecords(records, recordIndex, this);
+        if (this.sortState) this.dataSource.addRecordsForSorted(records), sortRecords(this), 
+        this.refreshRowColCount(), this.scenegraph.clearCells(), this.scenegraph.createSceneGraph(); else {
+            void 0 === recordIndex || recordIndex > this.dataSource.sourceLength ? recordIndex = this.dataSource.sourceLength : recordIndex < 0 && (recordIndex = 0);
+            const headerCount = this.transpose ? this.rowHeaderLevelCount : this.columnHeaderLevelCount;
+            this.dataSource.addRecords(records, recordIndex);
+            const oldRowCount = this.transpose ? this.colCount : this.rowCount;
+            if (this.refreshRowColCount(), 0 === this.scenegraph.proxy.totalActualBodyRowCount) return this.scenegraph.clearCells(), 
+            void this.scenegraph.createSceneGraph();
+            const newRowCount = this.transpose ? this.colCount : this.rowCount;
+            if (this.pagination) {
+                const {perPageCount: perPageCount, currentPage: currentPage} = this.pagination, endIndex = perPageCount * (currentPage || 0) + perPageCount;
+                if (recordIndex < endIndex) if (recordIndex < endIndex - perPageCount) this.scenegraph.clearCells(), 
+                this.scenegraph.createSceneGraph(); else {
+                    const rowNum = recordIndex - (endIndex - perPageCount) + headerCount;
+                    if (oldRowCount - headerCount === this.pagination.perPageCount) {
+                        const updateRows = [];
+                        for (let row = rowNum; row < newRowCount; row++) this.transpose ? updateRows.push({
+                            col: row,
+                            row: 0
+                        }) : updateRows.push({
+                            col: 0,
+                            row: row
+                        });
+                        this.transpose ? this.scenegraph.updateCol([], [], updateRows) : this.scenegraph.updateRow([], [], updateRows);
+                    } else {
+                        const addRows = [];
+                        for (let row = rowNum; row < Math.min(newRowCount, rowNum + (Array.isArray(records) ? records.length : 1)); row++) this.transpose ? addRows.push({
+                            col: row,
+                            row: 0
+                        }) : addRows.push({
+                            col: 0,
+                            row: row
+                        });
+                        this.transpose ? this.scenegraph.updateCol([], addRows, []) : this.scenegraph.updateRow([], addRows, []);
+                    }
+                }
+            } else {
+                const addRows = [];
+                for (let row = recordIndex + headerCount; row < recordIndex + headerCount + (Array.isArray(records) ? records.length : 1); row++) this.transpose ? addRows.push({
+                    col: row,
+                    row: 0
+                }) : addRows.push({
+                    col: 0,
+                    row: row
+                });
+                this.transpose ? this.scenegraph.updateCol([], addRows, []) : this.scenegraph.updateRow([], addRows, []);
+            }
+        }
     }
     deleteRecords(recordIndexs) {
-        listTableDeleteRecords(recordIndexs, this);
+        if ((null == recordIndexs ? void 0 : recordIndexs.length) > 0) if (this.sortState) this.dataSource.deleteRecordsForSorted(recordIndexs), 
+        sortRecords(this), this.refreshRowColCount(), this.scenegraph.clearCells(), this.scenegraph.createSceneGraph(); else {
+            const deletedRecordIndexs = this.dataSource.deleteRecords(recordIndexs);
+            if (0 === deletedRecordIndexs.length) return;
+            const oldRowCount = this.transpose ? this.colCount : this.rowCount;
+            this.refreshRowColCount();
+            const newRowCount = this.transpose ? this.colCount : this.rowCount, recordIndexsMinToMax = deletedRecordIndexs.sort(((a, b) => a - b)), minRecordIndex = recordIndexsMinToMax[0];
+            if (this.pagination) {
+                const {perPageCount: perPageCount, currentPage: currentPage} = this.pagination, endIndex = perPageCount * (currentPage || 0) + perPageCount;
+                if (minRecordIndex < endIndex) if (minRecordIndex < endIndex - perPageCount) this.scenegraph.clearCells(), 
+                this.scenegraph.createSceneGraph(); else {
+                    const updateRows = [], delRows = [];
+                    for (let row = minRecordIndex - (endIndex - perPageCount) + (this.transpose ? this.rowHeaderLevelCount : this.columnHeaderLevelCount); row < newRowCount; row++) this.transpose ? updateRows.push({
+                        col: row,
+                        row: 0
+                    }) : updateRows.push({
+                        col: 0,
+                        row: row
+                    });
+                    if (newRowCount < oldRowCount) for (let row = newRowCount; row < oldRowCount; row++) this.transpose ? delRows.push({
+                        col: row,
+                        row: 0
+                    }) : delRows.push({
+                        col: 0,
+                        row: row
+                    });
+                    this.transpose ? this.scenegraph.updateCol(delRows, [], updateRows) : this.scenegraph.updateRow(delRows, [], updateRows);
+                }
+            } else {
+                const delRows = [];
+                for (let index = 0; index < recordIndexsMinToMax.length; index++) {
+                    const rowNum = recordIndexsMinToMax[index] + (this.transpose ? this.rowHeaderLevelCount : this.columnHeaderLevelCount);
+                    this.transpose ? delRows.push({
+                        col: rowNum,
+                        row: 0
+                    }) : delRows.push({
+                        col: 0,
+                        row: rowNum
+                    });
+                }
+                this.transpose ? this.scenegraph.updateCol(delRows, [], []) : this.scenegraph.updateRow(delRows, [], []);
+            }
+        }
     }
     updateRecords(records, recordIndexs) {
-        listTableUpdateRecords(records, recordIndexs, this);
+        if ((null == recordIndexs ? void 0 : recordIndexs.length) > 0) if (this.sortState) this.dataSource.updateRecordsForSorted(records, recordIndexs), 
+        sortRecords(this), this.refreshRowColCount(), this.scenegraph.clearCells(), this.scenegraph.createSceneGraph(); else {
+            const updateRecordIndexs = this.dataSource.updateRecords(records, recordIndexs);
+            if (0 === updateRecordIndexs.length) return;
+            const recordIndexsMinToMax = updateRecordIndexs.sort(((a, b) => a - b));
+            if (this.pagination) {
+                const {perPageCount: perPageCount, currentPage: currentPage} = this.pagination, endIndex = perPageCount * (currentPage || 0) + perPageCount, updateRows = [];
+                for (let index = 0; index < recordIndexsMinToMax.length; index++) {
+                    const recordIndex = recordIndexsMinToMax[index];
+                    if (recordIndex < endIndex && recordIndex >= endIndex - perPageCount) {
+                        const rowNum = recordIndex - (endIndex - perPageCount) + (this.transpose ? this.rowHeaderLevelCount : this.columnHeaderLevelCount);
+                        updateRows.push(rowNum);
+                    }
+                }
+                if (updateRows.length >= 1) {
+                    const updateRowCells = [];
+                    for (let index = 0; index < updateRows.length; index++) {
+                        const updateRow = updateRows[index];
+                        this.transpose ? updateRowCells.push({
+                            col: updateRow,
+                            row: 0
+                        }) : updateRowCells.push({
+                            col: 0,
+                            row: updateRow
+                        });
+                    }
+                    this.transpose ? this.scenegraph.updateCol([], [], updateRowCells) : this.scenegraph.updateRow([], [], updateRowCells);
+                }
+            } else {
+                const updateRows = [];
+                for (let index = 0; index < recordIndexsMinToMax.length; index++) {
+                    const rowNum = recordIndexsMinToMax[index] + (this.transpose ? this.rowHeaderLevelCount : this.columnHeaderLevelCount);
+                    this.transpose ? updateRows.push({
+                        col: rowNum,
+                        row: 0
+                    }) : updateRows.push({
+                        col: 0,
+                        row: rowNum
+                    });
+                }
+                this.transpose ? this.scenegraph.updateCol([], [], updateRows) : this.scenegraph.updateRow([], [], updateRows);
+            }
+        }
     }
     _hasCustomRenderOrLayout() {
         var _a, _b, _c, _d;
@@ -662,13 +832,5 @@ export class ListTable extends BaseTable {
     isAggregation(col, row) {
         return this.internalProps.layoutMap.isAggregation(col, row);
     }
-    getGroupTitleLevel(col, row) {
-        var _a;
-        if (!this.options.groupBy) return;
-        const indexArr = this.dataSource.getIndexKey(this.getRecordShowIndexByCell(col, row)), groupLength = null !== (_a = this.dataSource.getGroupLength()) && void 0 !== _a ? _a : 0;
-        let indexArrLngth = isArray(indexArr) ? indexArr.length - 1 : 0;
-        return groupLength > 0 && indexArrLngth === groupLength && (indexArrLngth = void 0), 
-        indexArrLngth;
-    }
 }
 //# sourceMappingURL=ListTable.js.map