vxe-table 4.20.9 → 4.20.10

package/dist/all.esm.js

@@ -44,7 +44,7 @@ function eqEmptyValue(cellValue) {
     return cellValue === '' || XEUtils.eqNull(cellValue);
 }
 
-const version = "4.20.9";
+const version = "4.20.10";
 VxeUI.version = version;
 VxeUI.tableVersion = version;
 VxeUI.setConfig({
@@ -758,7 +758,7 @@ function wheelScrollTopTo(diffNum, cb) {
 }
 
 const { log } = VxeUI;
-const tableVersion = `table v${"4.20.9"}`;
+const tableVersion = `table v${"4.20.10"}`;
 function createComponentLog(name) {
     const uiVersion = VxeUI.uiVersion ? `ui v${VxeUI.uiVersion}` : '';
     const ganttVersion = VxeUI.ganttVersion ? `gantt v${VxeUI.ganttVersion}` : '';
@@ -6964,7 +6964,7 @@ var TableCustomPanelComponent = defineVxeComponent({
                         }, VxeUIRadioGroupComponent
                             ? [
                                 h(VxeUIRadioGroupComponent, {
-                                    modelValue: column.renderAlign || '',
+                                    modelValue: column.renderAlign || 'left',
                                     type: 'button',
                                     strict: false,
                                     disabled: isHidden,
@@ -6985,7 +6985,7 @@ var TableCustomPanelComponent = defineVxeComponent({
                             : (VxeUIRadioGroupComponent
                                 ? [
                                     h(VxeUIRadioGroupComponent, {
-                                        modelValue: column.renderHeaderAlign || '',
+                                        modelValue: column.renderHeaderAlign || 'left',
                                         type: 'button',
                                         strict: false,
                                         disabled: isHidden,
@@ -7006,7 +7006,7 @@ var TableCustomPanelComponent = defineVxeComponent({
                             : (VxeUIRadioGroupComponent
                                 ? [
                                     h(VxeUIRadioGroupComponent, {
-                                        modelValue: column.renderFooterAlign || '',
+                                        modelValue: column.renderFooterAlign || 'left',
                                         type: 'button',
                                         strict: false,
                                         disabled: isHidden,
@@ -12055,15 +12055,17 @@ hooks$4.add('tableExportModule', {
                             const { computeProxyOpts } = $xeGGWrapper.getComputeMaps();
                             const proxyOpts = computeProxyOpts.value;
                             const { sortData } = gridReactData;
-                            const { beforeQueryAll, afterQueryAll, ajax = {} } = proxyOpts;
+                            const { beforeQueryAll: oldBeforeQueryAll, afterQueryAll: oldAfterQueryAll, ajax = {} } = proxyOpts;
                             const resConfigs = proxyOpts.response || proxyOpts.props || {};
-                            const ajaxMethods = ajax.queryAll;
-                            const queryAllSuccessMethods = ajax.queryAllSuccess;
-                            const queryAllErrorMethods = ajax.queryAllError;
-                            if (!ajaxMethods) {
+                            const beforeQueryAllMethod = ajax.beforeQueryAll;
+                            const queryAllMethod = ajax.queryAll;
+                            const afterQueryAllMethod = ajax.afterQueryAll;
+                            const queryAllSuccessMethod = ajax.queryAllSuccess;
+                            const queryAllErrorMethod = ajax.queryAllError;
+                            if (!queryAllMethod) {
                                 errLog$5('vxe.error.notFunc', ['proxy-config.ajax.queryAll']);
                             }
-                            if (ajaxMethods) {
+                            if (queryAllMethod) {
                                 const params = {
                                     $table: $xeTable,
                                     $grid: $xeGrid,
@@ -12074,37 +12076,55 @@ hooks$4.add('tableExportModule', {
                                     form: gridReactData.formData,
                                     options: handleOptions
                                 };
-                                return Promise.resolve((beforeQueryAll || ajaxMethods)(params))
-                                    .then(rest => {
-                                    const listProp = resConfigs.list;
-                                    let tdData = [];
-                                    if (listProp) {
-                                        if (XEUtils.isFunction(listProp)) {
-                                            tdData = listProp({ data: rest, $table: $xeTable, $grid: $xeGrid, $gantt: $xeGantt });
+                                const handleQueryAll = () => {
+                                    return Promise.resolve((oldBeforeQueryAll || queryAllMethod)(params))
+                                        .then((rest) => {
+                                        if (afterQueryAllMethod) {
+                                            afterQueryAllMethod(Object.assign(Object.assign({}, params), { response: rest, status: 'success' }));
                                         }
                                         else {
-                                            tdData = XEUtils.isArray(rest) ? rest : XEUtils.get(rest, listProp);
+                                            const listProp = resConfigs.list;
+                                            let tdData = [];
+                                            if (listProp) {
+                                                if (XEUtils.isFunction(listProp)) {
+                                                    tdData = listProp({ data: rest, $table: $xeTable, $grid: $xeGrid, $gantt: $xeGantt });
+                                                }
+                                                else {
+                                                    tdData = XEUtils.isArray(rest) ? rest : XEUtils.get(rest, listProp);
+                                                }
+                                            }
+                                            else {
+                                                if (XEUtils.isArray(rest)) {
+                                                    tdData = rest;
+                                                }
+                                            }
+                                            handleOptions.data = tdData;
+                                            if (oldAfterQueryAll) {
+                                                oldAfterQueryAll(Object.assign(Object.assign({}, params), { response: rest }));
+                                            }
                                         }
-                                    }
-                                    else {
-                                        if (XEUtils.isArray(rest)) {
-                                            tdData = rest;
+                                        if (queryAllSuccessMethod) {
+                                            queryAllSuccessMethod(Object.assign(Object.assign({}, params), { response: rest }));
                                         }
-                                    }
-                                    handleOptions.data = tdData;
-                                    if (afterQueryAll) {
-                                        afterQueryAll(params);
-                                    }
-                                    if (queryAllSuccessMethods) {
-                                        queryAllSuccessMethods(Object.assign(Object.assign({}, params), { response: rest }));
-                                    }
-                                    return handleExport(handleOptions);
-                                })
-                                    .catch((rest) => {
-                                    if (queryAllErrorMethods) {
-                                        queryAllErrorMethods(Object.assign(Object.assign({}, params), { response: rest }));
-                                    }
-                                });
+                                        return handleExport(handleOptions);
+                                    })
+                                        .catch((rest) => {
+                                        if (afterQueryAllMethod) {
+                                            afterQueryAllMethod(Object.assign(Object.assign({}, params), { response: rest, status: 'error' }));
+                                        }
+                                        if (queryAllErrorMethod) {
+                                            queryAllErrorMethod(Object.assign(Object.assign({}, params), { response: rest }));
+                                        }
+                                    });
+                                };
+                                if (beforeQueryAllMethod) {
+                                    return Promise.resolve(beforeQueryAllMethod(params)).then(status => {
+                                        if (status !== false) {
+                                            return handleQueryAll();
+                                        }
+                                    });
+                                }
+                                return handleQueryAll();
                             }
                         }
                     }
@@ -14775,7 +14795,12 @@ renderer$2.mixin({
     },
     FormatNumberInput: {
         renderTableDefault: handleNumberCell,
-        tableFilterDefaultMethod: handleInputFilterMethod,
+        tableFilterDefaultMethod({ option, row, column }) {
+            const { data } = option;
+            const cellValue = XEUtils.get(row, column.field);
+            /* eslint-disable eqeqeq */
+            return cellValue == data;
+        },
         tableExportMethod(params) {
             const { row, column } = params;
             const cellValue = XEUtils.get(row, column.field);
@@ -14827,7 +14852,12 @@ renderer$2.mixin({
         createTableFilterOptions: defaultFilterOptions,
         renderTableFilter: defaultFilterRender,
         renderTableFloatingFilter: defaultFloatingFilterRender,
-        tableFilterDefaultMethod: handleInputFilterMethod,
+        tableFilterDefaultMethod({ option, row, column }) {
+            const { data } = option;
+            const cellValue = XEUtils.get(row, column.field);
+            /* eslint-disable eqeqeq */
+            return cellValue == data;
+        },
         tableExportMethod(params) {
             const { row, column } = params;
             const cellValue = XEUtils.get(row, column.field);
@@ -18765,7 +18795,7 @@ var VxeTableComponent = defineVxeComponent({
                 return;
             }
             internalData.rsePending = true;
-            handleLazyRecalculate(false, true, true, {
+            handleLazyRecalculate(true, true, true, {
                 minRunDelay: 200
             }).then(() => {
                 internalData.rsePending = false;
@@ -31563,7 +31593,7 @@ var VxeGridComponent = defineVxeComponent({
                 const proxyOpts = computeProxyOpts.value;
                 const pagerOpts = computePagerOpts.value;
                 const toolbarOpts = computeToolbarOpts.value;
-                const { beforeQuery, afterQuery, beforeQueryFooter, afterQueryFooter, beforeDelete, afterDelete, beforeSave, afterSave, ajax = {} } = proxyOpts;
+                const { beforeQuery: oldBeforeQuery, afterQuery: oldAfterQuery, beforeQueryFooter: oldBeforeQueryFooter, afterQueryFooter: oldAfterQueryFooter, beforeDelete: oldBeforeDelete, afterDelete: oldAfterDelete, beforeSave: oldBeforeSave, afterSave: oldAfterSave, ajax = {} } = proxyOpts;
                 const resConfigs = (proxyOpts.response || proxyOpts.props || {});
                 const $xeTable = refTable.value;
                 if (!$xeTable) {
@@ -31614,10 +31644,12 @@ var VxeGridComponent = defineVxeComponent({
                     case 'initial':
                     case 'reload':
                     case 'query': {
-                        const qMethods = ajax.query;
-                        const qsMethods = ajax.querySuccess;
-                        const qeMethods = ajax.queryError;
-                        if (qMethods) {
+                        const bqMethod = ajax.beforeQuery;
+                        const qMethod = ajax.query;
+                        const aqMethod = ajax.afterQuery;
+                        const qsMethod = ajax.querySuccess;
+                        const qeMethod = ajax.queryError;
+                        if (qMethod) {
                             const isInited = code === 'initial';
                             const isReload = code === 'reload';
                             if (!isInited && reactData.tableLoading) {
@@ -31699,73 +31731,91 @@ var VxeGridComponent = defineVxeComponent({
                                 sorts: sortList,
                                 filters: filterList,
                                 form: formData,
-                                options: qMethods
+                                options: qMethod
                             };
-                            reactData.sortData = sortList;
-                            reactData.filterData = filterList;
-                            reactData.tableLoading = true;
-                            return Promise.all([
-                                Promise.resolve((beforeQuery || qMethods)(commitParams, ...args)),
-                                operPromise
-                            ]).then(([rest]) => {
-                                let tableData = [];
-                                reactData.tableLoading = false;
-                                if (rest) {
-                                    const reParams = { data: rest, $table: $xeTable, $grid: $xeGrid, $gantt: null };
-                                    if (pagerConfig && isEnableConf(pagerOpts)) {
-                                        const totalProp = resConfigs.total;
-                                        const total = (XEUtils.isFunction(totalProp) ? totalProp(reParams) : XEUtils.get(rest, totalProp || 'page.total')) || 0;
-                                        tablePage.total = XEUtils.toNumber(total);
-                                        const resultProp = resConfigs.result;
-                                        tableData = (XEUtils.isFunction(resultProp) ? resultProp(reParams) : XEUtils.get(rest, resultProp || 'result')) || [];
-                                        // 检验当前页码，不能超出当前最大页数
-                                        const pageCount = Math.max(Math.ceil(total / tablePage.pageSize), 1);
-                                        if (tablePage.currentPage > pageCount) {
-                                            tablePage.currentPage = pageCount;
-                                        }
+                            const handleQuery = () => {
+                                reactData.sortData = sortList;
+                                reactData.filterData = filterList;
+                                reactData.tableLoading = true;
+                                return Promise.all([
+                                    Promise.resolve((oldBeforeQuery || qMethod)(commitParams, ...args)),
+                                    operPromise
+                                ]).then(([rest]) => {
+                                    reactData.tableLoading = false;
+                                    if (aqMethod) {
+                                        aqMethod(Object.assign(Object.assign({}, commitParams), { response: rest, status: 'success' }), ...args);
                                     }
                                     else {
-                                        const listProp = resConfigs.list;
-                                        if (XEUtils.isArray(rest)) {
-                                            tableData = rest;
-                                        }
-                                        else if (listProp) {
-                                            tableData = (XEUtils.isFunction(listProp) ? listProp(reParams) : XEUtils.get(rest, listProp)) || [];
-                                        }
-                                    }
-                                    if (showFooter) {
-                                        const fdProp = resConfigs.footerData;
-                                        const footerList = fdProp ? (XEUtils.isFunction(fdProp) ? fdProp(reParams) : XEUtils.get(rest, fdProp)) : [];
-                                        if (XEUtils.isArray(footerList)) {
-                                            reactData.footerData = footerList;
+                                        let tableData = [];
+                                        if (rest) {
+                                            const reParams = { data: rest, $table: $xeTable, $grid: $xeGrid, $gantt: null };
+                                            if (pagerConfig && isEnableConf(pagerOpts)) {
+                                                const totalProp = resConfigs.total;
+                                                const total = (XEUtils.isFunction(totalProp) ? totalProp(reParams) : XEUtils.get(rest, totalProp || 'page.total')) || 0;
+                                                tablePage.total = XEUtils.toNumber(total);
+                                                const resultProp = resConfigs.result;
+                                                tableData = (XEUtils.isFunction(resultProp) ? resultProp(reParams) : XEUtils.get(rest, resultProp || 'result')) || [];
+                                                // 检验当前页码，不能超出当前最大页数
+                                                const pageCount = Math.max(Math.ceil(total / tablePage.pageSize), 1);
+                                                if (tablePage.currentPage > pageCount) {
+                                                    tablePage.currentPage = pageCount;
+                                                }
+                                            }
+                                            else {
+                                                const listProp = resConfigs.list;
+                                                if (XEUtils.isArray(rest)) {
+                                                    tableData = rest;
+                                                }
+                                                else if (listProp) {
+                                                    tableData = (XEUtils.isFunction(listProp) ? listProp(reParams) : XEUtils.get(rest, listProp)) || [];
+                                                }
+                                            }
+                                            if (showFooter) {
+                                                const fdProp = resConfigs.footerData;
+                                                const footerList = fdProp ? (XEUtils.isFunction(fdProp) ? fdProp(reParams) : XEUtils.get(rest, fdProp)) : [];
+                                                if (XEUtils.isArray(footerList)) {
+                                                    reactData.footerData = footerList;
+                                                }
+                                            }
                                         }
-                                    }
-                                }
-                                if ($xeTable) {
-                                    $xeTable.loadData(tableData);
-                                }
-                                else {
-                                    nextTick(() => {
-                                        const $xeTable = refTable.value;
                                         if ($xeTable) {
                                             $xeTable.loadData(tableData);
                                         }
-                                    });
-                                }
-                                if (afterQuery) {
-                                    afterQuery(commitParams, ...args);
-                                }
-                                if (qsMethods) {
-                                    qsMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
-                                }
-                                return { status: true };
-                            }).catch((rest) => {
-                                reactData.tableLoading = false;
-                                if (qeMethods) {
-                                    qeMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
-                                }
-                                return { status: false };
-                            });
+                                        else {
+                                            nextTick(() => {
+                                                const $xeTable = refTable.value;
+                                                if ($xeTable) {
+                                                    $xeTable.loadData(tableData);
+                                                }
+                                            });
+                                        }
+                                        if (oldAfterQuery) {
+                                            oldAfterQuery(Object.assign(Object.assign({}, commitParams), { response: rest }), ...args);
+                                        }
+                                    }
+                                    if (qsMethod) {
+                                        qsMethod(Object.assign(Object.assign({}, commitParams), { response: rest }));
+                                    }
+                                    return { status: true };
+                                }).catch((rest) => {
+                                    reactData.tableLoading = false;
+                                    if (aqMethod) {
+                                        aqMethod(Object.assign(Object.assign({}, commitParams), { response: rest, status: 'error' }), ...args);
+                                    }
+                                    if (qeMethod) {
+                                        qeMethod(Object.assign(Object.assign({}, commitParams), { response: rest }));
+                                    }
+                                    return { status: false };
+                                });
+                            };
+                            if (bqMethod) {
+                                return Promise.resolve(bqMethod(commitParams, ...args)).then(status => {
+                                    if (status !== false) {
+                                        return handleQuery();
+                                    }
+                                });
+                            }
+                            return handleQuery();
                         }
                         else {
                             errLog('vxe.error.notFunc', ['proxy-config.ajax.query']);
@@ -31773,39 +31823,66 @@ var VxeGridComponent = defineVxeComponent({
                         break;
                     }
                     case 'queryFooter': {
-                        const qfMethods = ajax.queryFooter;
-                        const qfSuccessMethods = ajax.queryFooterSuccess;
-                        const qfErrorMethods = ajax.queryFooterError;
-                        if (qfMethods) {
+                        const bqfMethod = ajax.beforeQueryFooter;
+                        const qfMethod = ajax.queryFooter;
+                        const aqfMethod = ajax.afterQueryFooter;
+                        const qfSuccessMethod = ajax.queryFooterSuccess;
+                        const qfErrorMethod = ajax.queryFooterError;
+                        if (qfMethod) {
                             let filterList = [];
                             if ($xeTable) {
                                 filterList = $xeTable.getCheckedFilters();
                             }
+                            let pageParams = {};
+                            if (pagerConfig) {
+                                if (isEnableConf(pagerOpts)) {
+                                    pageParams = Object.assign({}, tablePage);
+                                }
+                            }
                             const commitParams = {
                                 $table: $xeTable,
                                 $grid: $xeGrid,
                                 $gantt: null,
                                 code,
                                 button,
+                                page: pageParams,
                                 filters: filterList,
                                 form: formData,
-                                options: qfMethods
+                                options: qfMethod
                             };
-                            return Promise.resolve((beforeQueryFooter || qfMethods)(commitParams, ...args)).then(rest => {
-                                reactData.footerData = XEUtils.isArray(rest) ? rest : [];
-                                if (afterQueryFooter) {
-                                    afterQueryFooter(commitParams, ...args);
-                                }
-                                if (qfSuccessMethods) {
-                                    qfSuccessMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
-                                }
-                                return { status: true };
-                            }).catch((rest) => {
-                                if (qfErrorMethods) {
-                                    qfErrorMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
-                                }
-                                return { status: false };
-                            });
+                            const handleQueryFooter = () => {
+                                return Promise.resolve((oldBeforeQueryFooter || qfMethod)(commitParams, ...args)).then(rest => {
+                                    if (aqfMethod) {
+                                        aqfMethod(Object.assign(Object.assign({}, commitParams), { response: rest, status: 'success' }), ...args);
+                                    }
+                                    else {
+                                        reactData.footerData = XEUtils.isArray(rest) ? rest : [];
+                                        if (oldAfterQueryFooter) {
+                                            oldAfterQueryFooter(Object.assign(Object.assign({}, commitParams), { response: rest }), ...args);
+                                        }
+                                    }
+                                    if (qfSuccessMethod) {
+                                        qfSuccessMethod(Object.assign(Object.assign({}, commitParams), { response: rest }));
+                                    }
+                                    return { status: true };
+                                }).catch((rest) => {
+                                    if (aqfMethod) {
+                                        aqfMethod(Object.assign(Object.assign({}, commitParams), { response: rest, status: 'error' }), ...args);
+                                    }
+                                    if (qfErrorMethod) {
+                                        qfErrorMethod(Object.assign(Object.assign({}, commitParams), { response: rest }));
+                                    }
+                                    return { status: false };
+                                });
+                            };
+                            if (bqfMethod) {
+                                return Promise.resolve(bqfMethod(commitParams, ...args)).then(status => {
+                                    if (status !== false) {
+                                        return handleQueryFooter();
+                                    }
+                                });
+                            }
+                            return handleQueryFooter();
                         }
                         else {
                             errLog('vxe.error.notFunc', ['proxy-config.ajax.queryFooter']);
@@ -31813,10 +31890,12 @@ var VxeGridComponent = defineVxeComponent({
                         break;
                     }
                     case 'delete': {
-                        const dMethods = ajax.delete;
+                        const bdMethod = ajax.beforeDelete;
+                        const dMethod = ajax.delete;
+                        const adMethod = ajax.afterDelete;
                         const deleteSuccessMethods = ajax.deleteSuccess;
                         const deleteErrorMethods = ajax.deleteError;
-                        if (dMethods) {
+                        if (dMethod) {
                             const selectRecords = $xeGrid.getCheckboxRecords();
                             const removeRecords = selectRecords.filter(row => !$xeTable.isInsertByRow(row));
                             const body = { removeRecords };
@@ -31828,49 +31907,69 @@ var VxeGridComponent = defineVxeComponent({
                                 button,
                                 body,
                                 form: formData,
-                                options: dMethods
+                                options: dMethod
                             };
                             if (selectRecords.length) {
                                 return handleDeleteRow(code, 'vxe.grid.deleteSelectRecord', () => {
                                     if (!removeRecords.length) {
                                         return $xeTable.remove(selectRecords);
                                     }
-                                    reactData.tableLoading = true;
-                                    return Promise.resolve((beforeDelete || dMethods)(commitParams, ...args))
-                                        .then(rest => {
-                                        reactData.tableLoading = false;
-                                        $xeTable.setPendingRow(removeRecords, false);
-                                        if (isRespMsg) {
-                                            if (VxeUI.modal) {
-                                                VxeUI.modal.message({ content: getRespMsg(rest, 'vxe.grid.delSuccess'), status: 'success' });
+                                    const handleDelete = () => {
+                                        reactData.tableLoading = true;
+                                        return Promise.resolve((oldBeforeDelete || dMethod)(commitParams, ...args))
+                                            .then(rest => {
+                                            reactData.tableLoading = false;
+                                            if (adMethod) {
+                                                adMethod(Object.assign(Object.assign({}, commitParams), { response: rest, status: 'success' }), ...args);
                                             }
-                                        }
-                                        if (afterDelete) {
-                                            afterDelete(commitParams, ...args);
-                                        }
-                                        else {
-                                            internalData.uFoot = true;
-                                            $xeGrid.commitProxy('query');
-                                            internalData.uFoot = false;
-                                            updateQueryFooter();
-                                        }
-                                        if (deleteSuccessMethods) {
-                                            deleteSuccessMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
-                                        }
-                                        return { status: true };
-                                    })
-                                        .catch(rest => {
-                                        reactData.tableLoading = false;
-                                        if (isRespMsg) {
-                                            if (VxeUI.modal) {
-                                                VxeUI.modal.message({ id: code, content: getRespMsg(rest, 'vxe.grid.operError'), status: 'error' });
+                                            else {
+                                                $xeTable.setPendingRow(removeRecords, false);
+                                                if (isRespMsg) {
+                                                    if (VxeUI.modal) {
+                                                        VxeUI.modal.message({ content: getRespMsg(rest, 'vxe.grid.delSuccess'), status: 'success' });
+                                                    }
+                                                }
+                                                if (oldAfterDelete) {
+                                                    oldAfterDelete(Object.assign(Object.assign({}, commitParams), { response: rest }), ...args);
+                                                }
+                                                else {
+                                                    internalData.uFoot = true;
+                                                    $xeGrid.commitProxy('query');
+                                                    internalData.uFoot = false;
+                                                    updateQueryFooter();
+                                                }
                                             }
-                                        }
-                                        if (deleteErrorMethods) {
-                                            deleteErrorMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
-                                        }
-                                        return { status: false };
-                                    });
+                                            if (deleteSuccessMethods) {
+                                                deleteSuccessMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
+                                            }
+                                            return { status: true };
+                                        })
+                                            .catch(rest => {
+                                            reactData.tableLoading = false;
+                                            if (adMethod) {
+                                                adMethod(Object.assign(Object.assign({}, commitParams), { response: rest, status: 'error' }), ...args);
+                                            }
+                                            else {
+                                                if (isRespMsg) {
+                                                    if (VxeUI.modal) {
+                                                        VxeUI.modal.message({ id: code, content: getRespMsg(rest, 'vxe.grid.operError'), status: 'error' });
+                                                    }
+                                                }
+                                            }
+                                            if (deleteErrorMethods) {
+                                                deleteErrorMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
+                                            }
+                                            return { status: false };
+                                        });
+                                    };
+                                    if (bdMethod) {
+                                        return Promise.resolve(bdMethod(commitParams, ...args)).then(status => {
+                                            if (status !== false) {
+                                                return handleDelete();
+                                            }
+                                        });
+                                    }
+                                    return handleDelete();
                                 });
                             }
                             else {
@@ -31887,10 +31986,12 @@ var VxeGridComponent = defineVxeComponent({
                         break;
                     }
                     case 'save': {
-                        const ajaxMethods = ajax.save;
-                        const saveSuccessMethods = ajax.saveSuccess;
-                        const saveErrorMethods = ajax.saveError;
-                        if (ajaxMethods) {
+                        const bSaveMethod = ajax.beforeSave;
+                        const sMethod = ajax.save;
+                        const aSaveMethod = ajax.afterSave;
+                        const sSuccessMethod = ajax.saveSuccess;
+                        const sErrorMethod = ajax.saveError;
+                        if (sMethod) {
                             const body = $xeTable.getRecordset();
                             const { insertRecords, removeRecords, updateRecords, pendingRecords } = body;
                             const commitParams = {
@@ -31901,7 +32002,7 @@ var VxeGridComponent = defineVxeComponent({
                                 button,
                                 body,
                                 form: formData,
-                                options: ajaxMethods
+                                options: sMethod
                             };
                             // 排除掉新增且标记为删除的数据
                             if (insertRecords.length) {
@@ -31922,42 +32023,62 @@ var VxeGridComponent = defineVxeComponent({
                                     return;
                                 }
                                 if (body.insertRecords.length || removeRecords.length || updateRecords.length || body.pendingRecords.length) {
-                                    reactData.tableLoading = true;
-                                    return Promise.resolve((beforeSave || ajaxMethods)(commitParams, ...args))
-                                        .then(rest => {
-                                        reactData.tableLoading = false;
-                                        $xeTable.clearPendingRow();
-                                        if (isRespMsg) {
-                                            if (VxeUI.modal) {
-                                                VxeUI.modal.message({ content: getRespMsg(rest, 'vxe.grid.saveSuccess'), status: 'success' });
+                                    const handleSave = () => {
+                                        reactData.tableLoading = true;
+                                        return Promise.resolve((oldBeforeSave || sMethod)(commitParams, ...args))
+                                            .then(rest => {
+                                            reactData.tableLoading = false;
+                                            if (aSaveMethod) {
+                                                aSaveMethod(Object.assign(Object.assign({}, commitParams), { response: rest, status: 'success' }), ...args);
                                             }
-                                        }
-                                        if (afterSave) {
-                                            afterSave(commitParams, ...args);
-                                        }
-                                        else {
-                                            internalData.uFoot = true;
-                                            $xeGrid.commitProxy('query');
-                                            internalData.uFoot = false;
-                                            updateQueryFooter();
-                                        }
-                                        if (saveSuccessMethods) {
-                                            saveSuccessMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
-                                        }
-                                        return { status: true };
-                                    })
-                                        .catch(rest => {
-                                        reactData.tableLoading = false;
-                                        if (isRespMsg) {
-                                            if (VxeUI.modal) {
-                                                VxeUI.modal.message({ id: code, content: getRespMsg(rest, 'vxe.grid.operError'), status: 'error' });
+                                            else {
+                                                $xeTable.clearPendingRow();
+                                                if (isRespMsg) {
+                                                    if (VxeUI.modal) {
+                                                        VxeUI.modal.message({ content: getRespMsg(rest, 'vxe.grid.saveSuccess'), status: 'success' });
+                                                    }
+                                                }
+                                                if (oldAfterSave) {
+                                                    oldAfterSave(Object.assign(Object.assign({}, commitParams), { response: rest }), ...args);
+                                                }
+                                                else {
+                                                    internalData.uFoot = true;
+                                                    $xeGrid.commitProxy('query');
+                                                    internalData.uFoot = false;
+                                                    updateQueryFooter();
+                                                }
                                             }
-                                        }
-                                        if (saveErrorMethods) {
-                                            saveErrorMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
-                                        }
-                                        return { status: false };
-                                    });
+                                            if (sSuccessMethod) {
+                                                sSuccessMethod(Object.assign(Object.assign({}, commitParams), { response: rest }));
+                                            }
+                                            return { status: true };
+                                        })
+                                            .catch(rest => {
+                                            reactData.tableLoading = false;
+                                            if (aSaveMethod) {
+                                                aSaveMethod(Object.assign(Object.assign({}, commitParams), { response: rest, status: 'error' }), ...args);
+                                            }
+                                            else {
+                                                if (isRespMsg) {
+                                                    if (VxeUI.modal) {
+                                                        VxeUI.modal.message({ id: code, content: getRespMsg(rest, 'vxe.grid.operError'), status: 'error' });
+                                                    }
+                                                }
+                                            }
+                                            if (sErrorMethod) {
+                                                sErrorMethod(Object.assign(Object.assign({}, commitParams), { response: rest }));
+                                            }
+                                            return { status: false };
+                                        });
+                                    };
+                                    if (bSaveMethod) {
+                                        return Promise.resolve(bSaveMethod(commitParams, ...args)).then(status => {
+                                            if (status !== false) {
+                                                return handleSave();
+                                            }
+                                        });
+                                    }
+                                    return handleSave();
                                 }
                                 else {
                                     if (isActiveMsg) {