vxe-table 3.12.14 → 3.12.15

package/es/table/module/edit/mixin.js

@@ -5,6 +5,15 @@ import { getCellValue, setCellValue, getRowid } from '../../src/util';
 import { browse, removeClass, addClass } from '../../../ui/src/dom';
 import { warnLog, errLog } from '../../../ui/src/log';
 const { getConfig, renderer, getI18n } = VxeUI;
+function removeCellSelectedClass($xeTable) {
+    const el = $xeTable.$refs.refElem;
+    if (el) {
+        const cell = el.querySelector('.col--selected');
+        if (cell) {
+            removeClass(cell, 'col--selected');
+        }
+    }
+}
 function insertTreeRow(_vm, newRecords, isAppend) {
     const { tableFullTreeData, afterFullData, fullDataRowIdData, fullAllDataRowIdData, treeOpts } = _vm;
     const { rowField, parentField, mapChildrenField } = treeOpts;
@@ -293,7 +302,7 @@ export default {
             const treeOpts = $xeTable.computeTreeOpts;
             const { transform, mapChildrenField } = treeOpts;
             const childrenField = treeOpts.children || treeOpts.childrenField;
-            const { actived, removeList, insertMaps } = editStore;
+            const { actived, removeMaps, insertMaps } = editStore;
             const { checkField } = checkboxOpts;
             let delList = [];
             if (!rows) {
@@ -305,7 +314,8 @@ export default {
             // 如果是新增，则保存记录
             rows.forEach(row => {
                 if (!$xeTable.isInsertByRow(row)) {
-                    removeList.push(row);
+                    const rowid = getRowid($xeTable, row);
+                    removeMaps[rowid] = row;
                 }
             });
             // 如果绑定了多选属性，则更新状态
@@ -467,7 +477,15 @@ export default {
          * 获取已删除的数据
          */
         _getRemoveRecords() {
-            return this.editStore.removeList;
+            const $xeTable = this;
+            const reactData = $xeTable;
+            const { editStore } = reactData;
+            const { removeMaps } = editStore;
+            const removeRecords = [];
+            XEUtils.each(removeMaps, (row) => {
+                removeRecords.push(row);
+            });
+            return removeRecords;
         },
         /**
          * 获取更新数据
@@ -829,7 +847,7 @@ export default {
                         selected.row = row;
                         selected.column = column;
                         if (isMouseSelected) {
-                            this.addColSdCls();
+                            this.addCellSelectedClass();
                         }
                         this.focus();
                         if (evnt) {
@@ -855,11 +873,12 @@ export default {
          * 清除所选中源状态
          */
         _clearSelected() {
+            const $xeTable = this;
             const { selected } = this.editStore;
             selected.row = null;
             selected.column = null;
             this.reColTitleSdCls();
-            this.reColSdCls();
+            removeCellSelectedClass($xeTable);
             return this.$nextTick();
         },
         reColTitleSdCls() {
@@ -868,18 +887,15 @@ export default {
                 XEUtils.arrayEach(headerElem.querySelectorAll('.col--title-selected'), elem => removeClass(elem, 'col--title-selected'));
             }
         },
-        reColSdCls() {
-            const cell = this.$el.querySelector('.col--selected');
-            if (cell) {
-                removeClass(cell, 'col--selected');
-            }
-        },
-        addColSdCls() {
-            const { selected } = this.editStore;
+        addCellSelectedClass() {
+            const $xeTable = this;
+            const reactData = $xeTable;
+            const { editStore } = reactData;
+            const { selected } = editStore;
             const { row, column } = selected;
-            this.reColSdCls();
+            removeCellSelectedClass($xeTable);
             if (row && column) {
-                const cell = this.getCellElement(row, column);
+                const cell = $xeTable.getCellElement(row, column);
                 if (cell) {
                     addClass(cell, 'col--selected');
                 }

package/es/table/module/export/mixin.js

@@ -2,6 +2,7 @@ import XEUtils from 'xe-utils';
 import { VxeUI } from '../../../ui';
 import { isColumnInfo, mergeBodyMethod, getCellValue } from '../../src/util';
 import { parseFile, formatText, eqEmptyValue } from '../../../ui/src/utils';
+import { hasClass } from '../../../ui/src/dom';
 import { createHtmlPage, getExportBlobByContent } from './util';
 import { warnLog, errLog } from '../../../ui/src/log';
 const { getI18n, renderer } = VxeUI;
@@ -121,7 +122,7 @@ function getBodyLabelData($xeTable, opts, columns, datas) {
                                     }
                                     else {
                                         const cell = $xeTable.getCellElement(row, column);
-                                        if (cell) {
+                                        if (cell && !hasClass(cell, 'is--progress')) {
                                             cellValue = cell.innerText.trim();
                                         }
                                     }
@@ -182,7 +183,7 @@ function getBodyLabelData($xeTable, opts, columns, datas) {
                             }
                             else {
                                 const cell = $xeTable.getCellElement(row, column);
-                                if (cell) {
+                                if (cell && !hasClass(cell, 'is--progress')) {
                                     cellValue = cell.innerText.trim();
                                 }
                             }

package/es/table/module/validator/mixin.js

@@ -153,8 +153,9 @@ export default {
             const internalData = $xeTable;
             const validRest = {};
             const { editRules, treeConfig } = props;
-            const { pendingRowMaps } = reactData;
+            const { editStore, pendingRowMaps } = reactData;
             const { afterFullData } = internalData;
+            const { removeMaps } = editStore;
             const treeOpts = $xeTable.computeTreeOpts;
             const childrenField = treeOpts.children || treeOpts.childrenField;
             let validList;
@@ -181,6 +182,10 @@ export default {
                 const columns = cols && cols.length ? cols : this.getColumns();
                 const handleVaild = (row) => {
                     const rowid = getRowid($xeTable, row);
+                    // 是否删除
+                    if (removeMaps[rowid]) {
+                        return;
+                    }
                     // 是否标记删除
                     if (pendingRowMaps[rowid]) {
                         return;

package/es/table/src/body.js

@@ -357,6 +357,7 @@ function renderTdColumn(h, _vm, seq, rowid, fixedType, isOptimizeMode, rowLevel,
                 'fixed--width': !isAutoCellWidth,
                 'fixed--hidden': fixedHiddenColumn,
                 'is--padding': isCellPadding,
+                'is--progress': (fixedHiddenColumn && isAllOverflow) || isVNPreEmptyStatus,
                 'is--drag-cell': isRowDragCell && (isCrossDrag || isPeerDrag || !rowLevel),
                 'is--drag-disabled': isDisabledDrag,
                 'col--dirty': isDirty,

package/es/table/src/methods.js

@@ -1065,7 +1065,7 @@ const calcCellHeight = ($xeTable) => {
         reactData.calcCellHeightFlag++;
     }
 };
-function getOrderField(_vm, column) {
+function getOrderField($xeTable, column) {
     const { sortBy, sortType } = column;
     return (row) => {
         let cellValue;
@@ -1073,7 +1073,7 @@ function getOrderField(_vm, column) {
             cellValue = XEUtils.isFunction(sortBy) ? sortBy({ row, column }) : XEUtils.get(row, sortBy);
         }
         else {
-            cellValue = _vm.getCellLabel(row, column);
+            cellValue = $xeTable.getCellLabel(row, column);
         }
         if (!sortType || sortType === 'auto') {
             return isNaN(cellValue) ? cellValue : XEUtils.toNumber(cellValue);
@@ -2887,76 +2887,146 @@ const Methods = {
      */
     updateAfterFullData() {
         const $xeTable = this;
-        const { tableFullColumn, tableFullData, filterOpts, sortOpts, treeConfig, treeOpts, tableFullTreeData } = this;
+        const props = $xeTable;
+        const internalData = $xeTable;
+        const { treeConfig } = props;
+        const { tableFullColumn, tableFullData, tableFullTreeData } = internalData;
+        const filterOpts = $xeTable.computeFilterOpts;
+        const sortOpts = $xeTable.computeSortOpts;
+        const treeOpts = $xeTable.computeTreeOpts;
+        const childrenField = treeOpts.children || treeOpts.childrenField;
+        const { transform, rowField, parentField, mapChildrenField } = treeOpts;
         const { remote: allRemoteFilter, filterMethod: allFilterMethod } = filterOpts;
         const { remote: allRemoteSort, sortMethod: allSortMethod, multiple: sortMultiple, chronological } = sortOpts;
-        const { transform } = treeOpts;
-        const childrenField = treeOpts.children || treeOpts.childrenField;
         let tableData = [];
         let tableTree = [];
-        const filterColumns = [];
-        let orderColumns = [];
-        tableFullColumn.forEach((column) => {
-            const { field, sortable, order, filters } = column;
-            if (!allRemoteFilter && filters && filters.length) {
-                const valueList = [];
-                const itemList = [];
-                filters.forEach((item) => {
-                    if (item.checked) {
-                        itemList.push(item);
-                        valueList.push(item.value);
+        // 处理数据
+        if (!allRemoteFilter || !allRemoteSort) {
+            const filterColumns = [];
+            let orderColumns = [];
+            tableFullColumn.forEach((column) => {
+                const { field, sortable, order, filters } = column;
+                if (!allRemoteFilter && filters && filters.length) {
+                    const valueList = [];
+                    const itemList = [];
+                    filters.forEach((item) => {
+                        if (item.checked) {
+                            itemList.push(item);
+                            valueList.push(item.value);
+                        }
+                    });
+                    if (itemList.length) {
+                        filterColumns.push({ column, valueList, itemList });
                     }
-                });
-                if (itemList.length) {
-                    filterColumns.push({ column, valueList, itemList });
                 }
-            }
-            if (!allRemoteSort && sortable && order) {
-                orderColumns.push({ column, field, property: field, order, sortTime: column.sortTime });
-            }
-        });
-        if (sortMultiple && chronological && orderColumns.length > 1) {
-            orderColumns = XEUtils.orderBy(orderColumns, 'sortTime');
-        }
-        if (filterColumns.length) {
-            const handleFilter = (row) => {
-                return filterColumns.every(({ column, valueList, itemList }) => {
-                    if (valueList.length && !allRemoteFilter) {
-                        const { filterMethod, filterRender, field } = column;
+                if (!allRemoteSort && sortable && order) {
+                    orderColumns.push({ column, field, property: field, order: order, sortTime: column.sortTime });
+                }
+            });
+            if (sortMultiple && chronological && orderColumns.length > 1) {
+                orderColumns = XEUtils.orderBy(orderColumns, 'sortTime');
+            }
+            // 处理筛选
+            // 支持单列、多列、组合筛选
+            if (!allRemoteFilter && filterColumns.length) {
+                const handleFilter = (row) => {
+                    return filterColumns.every(({ column, valueList, itemList }) => {
+                        const { filterMethod, filterRender } = column;
                         const compConf = isEnableConf(filterRender) ? renderer.get(filterRender.name) : null;
                         const compFilterMethod = compConf ? (compConf.tableFilterMethod || compConf.filterMethod) : null;
                         const tdFilterMethod = compConf ? (compConf.tableFilterDefaultMethod || compConf.defaultTableFilterMethod || compConf.defaultFilterMethod) : null;
                         const cellValue = getCellValue(row, column);
                         if (filterMethod) {
-                            return itemList.some((item) => filterMethod({ value: item.value, option: item, cellValue, row, column, $table: this }));
+                            return itemList.some((item) => filterMethod({ value: item.value, option: item, cellValue, row, column, $table: $xeTable }));
                         }
                         else if (compFilterMethod) {
-                            return itemList.some((item) => compFilterMethod({ value: item.value, option: item, cellValue, row, column, $table: this }));
+                            return itemList.some((item) => compFilterMethod({ value: item.value, option: item, cellValue, row, column, $table: $xeTable }));
                         }
                         else if (allFilterMethod) {
                             return allFilterMethod({ options: itemList, values: valueList, cellValue, row, column });
                         }
                         else if (tdFilterMethod) {
-                            return itemList.some((item) => tdFilterMethod({ value: item.value, option: item, cellValue, row, column, $table: this }));
+                            return itemList.some((item) => tdFilterMethod({ value: item.value, option: item, cellValue, row, column, $table: $xeTable }));
                         }
-                        return valueList.indexOf(XEUtils.get(row, field)) > -1;
-                    }
-                    return true;
-                });
-            };
-            if (treeConfig && transform) {
-                // 筛选虚拟树
-                tableTree = XEUtils.searchTree(tableFullTreeData, handleFilter, {
-                    original: true,
-                    isEvery: true,
-                    children: treeOpts.mapChildrenField,
-                    mapChildren: childrenField
-                });
-                tableData = tableTree;
+                        return valueList.indexOf(XEUtils.get(row, column.field)) > -1;
+                    });
+                };
+                if (treeConfig && transform) {
+                    // 筛选虚拟树
+                    tableTree = XEUtils.searchTree(tableFullTreeData, handleFilter, {
+                        original: true,
+                        isEvery: true,
+                        children: mapChildrenField,
+                        mapChildren: childrenField
+                    });
+                    tableData = tableTree;
+                }
+                else {
+                    tableData = treeConfig ? tableFullTreeData.filter(handleFilter) : tableFullData.filter(handleFilter);
+                    tableTree = tableData;
+                }
             }
             else {
-                tableData = treeConfig ? tableFullTreeData.filter(handleFilter) : tableFullData.filter(handleFilter);
-                tableTree = tableData;
+                if (treeConfig && transform) {
+                    // 还原虚拟树
+                    tableTree = XEUtils.searchTree(tableFullTreeData, () => true, {
+                        original: true,
+                        isEvery: true,
+                        children: mapChildrenField,
+                        mapChildren: childrenField
+                    });
+                    tableData = tableTree;
+                }
+                else {
+                    tableData = treeConfig ? tableFullTreeData.slice(0) : tableFullData.slice(0);
+                    tableTree = tableData;
+                }
+            }
+            // 处理排序（不能用于树形结构）
+            // 支持单列、多列、组合排序
+            if (!allRemoteSort && orderColumns.length) {
+                if (treeConfig && transform) {
+                    // 虚拟树和列表一样，只能排序根级节点
+                    if (allSortMethod) {
+                        const sortRests = allSortMethod({ data: tableTree, sortList: orderColumns, $table: $xeTable });
+                        tableTree = XEUtils.isArray(sortRests) ? sortRests : tableTree;
+                    }
+                    else {
+                        const treeList = XEUtils.toTreeArray(tableTree, {
+                            children: mapChildrenField
+                        });
+                        tableTree = XEUtils.toArrayTree(XEUtils.orderBy(treeList, orderColumns.map(({ column, order }) => [getOrderField($xeTable, column), order])), {
+                            key: rowField,
+                            parentKey: parentField,
+                            children: childrenField,
+                            mapChildren: mapChildrenField
+                        });
+                    }
+                    tableData = tableTree;
+                }
+                else {
+                    if (allSortMethod) {
+                        const sortRests = allSortMethod({ data: tableData, sortList: orderColumns, $table: $xeTable });
+                        tableData = XEUtils.isArray(sortRests) ? sortRests : tableData;
+                    }
+                    else {
+                        // 兼容 v4
+                        if (sortMultiple) {
+                            tableData = XEUtils.orderBy(tableData, orderColumns.map(({ column, order }) => [getOrderField(this, column), order]));
+                        }
+                        else {
+                            const firstOrderColumn = orderColumns[0];
+                            let sortByConfs;
+                            // 已废弃，兼容 v2，在 v4 中废弃， sortBy 不能为数组
+                            if (XEUtils.isArray(firstOrderColumn.sortBy)) {
+                                sortByConfs = firstOrderColumn.sortBy.map((item) => [item, firstOrderColumn.order]);
+                            }
+                            tableData = XEUtils.orderBy(tableData, sortByConfs || [firstOrderColumn].map(({ column, order }) => [getOrderField(this, column), order]));
+                        }
+                        tableData = XEUtils.orderBy(tableData, orderColumns.map(({ column, order }) => [getOrderField($xeTable, column), order]));
+                    }
+                    tableTree = tableData;
+                }
             }
         }
         else {
@@ -2975,43 +3045,8 @@ const Methods = {
                 tableTree = tableData;
             }
         }
-        const firstOrderColumn = orderColumns[0];
-        if (!allRemoteSort && firstOrderColumn) {
-            if (treeConfig && transform) {
-                // 虚拟树和列表一样，只能排序根级节点
-                if (allSortMethod) {
-                    const sortRests = allSortMethod({ data: tableTree, sortList: orderColumns, $table: this });
-                    tableTree = XEUtils.isArray(sortRests) ? sortRests : tableTree;
-                }
-                else {
-                    tableTree = XEUtils.orderBy(tableTree, orderColumns.map(({ column, order }) => [getOrderField(this, column), order]));
-                }
-                tableData = tableTree;
-            }
-            else {
-                if (allSortMethod) {
-                    const sortRests = allSortMethod({ data: tableData, column: firstOrderColumn.column, property: firstOrderColumn.field, field: firstOrderColumn.field, order: firstOrderColumn.order, sortList: orderColumns, $table: this });
-                    tableData = XEUtils.isArray(sortRests) ? sortRests : tableData;
-                }
-                else {
-                    // 兼容 v4
-                    if (sortMultiple) {
-                        tableData = XEUtils.orderBy(tableData, orderColumns.map(({ column, order }) => [getOrderField(this, column), order]));
-                    }
-                    else {
-                        // 兼容 v2，在 v4 中废弃， sortBy 不能为数组
-                        let sortByConfs;
-                        if (XEUtils.isArray(firstOrderColumn.sortBy)) {
-                            sortByConfs = firstOrderColumn.sortBy.map((item) => [item, firstOrderColumn.order]);
-                        }
-                        tableData = XEUtils.orderBy(tableData, sortByConfs || [firstOrderColumn].map(({ column, order }) => [getOrderField(this, column), order]));
-                    }
-                }
-                tableTree = tableData;
-            }
-        }
-        this.afterFullData = tableData;
-        this.afterTreeFullData = tableTree;
+        internalData.afterFullData = tableData;
+        internalData.afterTreeFullData = tableTree;
         updateAfterDataIndex($xeTable);
     },
     /**

package/es/table/src/table.js

@@ -496,7 +496,6 @@ export default {
                     column: null
                 },
                 insertMaps: {},
-                removeList: [],
                 removeMaps: {}
             },
             // 存放 tooltip 相关信息

package/es/ui/index.js

@@ -1,6 +1,6 @@
 import { VxeUI } from '@vxe-ui/core';
 import { getFuncText } from './src/utils';
-export const version = "3.12.14";
+export const version = "3.12.15";
 VxeUI.version = version;
 VxeUI.tableVersion = version;
 VxeUI.setConfig({

package/es/ui/src/log.js

@@ -1,5 +1,5 @@
 import { VxeUI } from '@vxe-ui/core';
 const { log } = VxeUI;
-const version = `table v${"3.12.14"}`;
+const version = `table v${"3.12.15"}`;
 export const warnLog = log.create('warn', version);
 export const errLog = log.create('error', version);