vxe-gantt 3.0.23 → 3.0.25

package/es/gantt/src/gantt-body.js

@@ -1,5 +1,7 @@
 import { defineVxeComponent } from '../../ui/src/comp';
 import { getCellRestHeight } from './util';
+import { getClass } from '../../ui/src/utils';
+import XEUtils from 'xe-utils';
 import GanttViewChartComponent from './gantt-chart';
 const sourceType = 'gantt';
 const viewType = 'body';
@@ -35,9 +37,10 @@ export default defineVxeComponent({
             const { headerGroups } = reactData;
             const { todayDateMaps } = internalData;
             const taskViewOpts = $xeGantt.computeTaskViewOpts;
-            const { showNowLine } = taskViewOpts;
+            const { showNowLine, viewStyle } = taskViewOpts;
             const { scaleItem } = headerGroups[headerGroups.length - 1] || {};
-            const { field } = column;
+            const { field, dateObj } = column;
+            const { cellClassName, cellStyle } = viewStyle || {};
             const todayValue = showNowLine && scaleItem ? todayDateMaps[scaleItem.type] : null;
             const rowRest = fullAllDataRowIdData[rowid] || {};
             const resizeHeight = resizeHeightFlag ? rowRest.resizeHeight : 0;
@@ -78,16 +81,24 @@ export default defineVxeComponent({
                     }
                 }));
             }
-            const ctParams = { source: sourceType, type: viewType, row, column, $rowIndex, rowIndex, _rowIndex };
+            const ctParams = { source: sourceType, type: viewType, dateObj, row, column, $rowIndex, rowIndex, _rowIndex };
             return h('td', {
                 key: $columnIndex,
-                class: ['vxe-gantt-view--body-column', {
+                class: [
+                    'vxe-gantt-view--body-column',
+                    {
                         'is--now': showNowLine && todayValue === field,
                         'col--rs-height': isRsHeight
-                    }],
-                style: {
-                    height: `${cellHeight}px`
-                },
+                    },
+                    getClass(cellClassName, ctParams)
+                ],
+                style: cellStyle
+                    ? Object.assign({}, XEUtils.isFunction(cellStyle) ? cellStyle(ctParams) : cellStyle, {
+                        height: `${cellHeight}px`
+                    })
+                    : {
+                        height: `${cellHeight}px`
+                    },
                 on: {
                     click(evnt) {
                         $xeGantt.handleTaskCellClickEvent(evnt, { row, column });
@@ -104,6 +115,7 @@ export default defineVxeComponent({
         renderRows(h, $xeTable, tableData) {
             const _vm = this;
             const $xeGanttView = _vm.$xeGanttView;
+            const $xeGantt = _vm.$xeGantt;
             const { reactData } = $xeGanttView;
             const tableProps = $xeTable;
             const { treeConfig, stripe, highlightHoverRow, editConfig } = tableProps;
@@ -117,6 +129,9 @@ export default defineVxeComponent({
             const treeOpts = $xeTable.computeTreeOpts;
             const { transform } = treeOpts;
             const childrenField = treeOpts.children || treeOpts.childrenField;
+            const taskViewOpts = $xeGantt.computeTaskViewOpts;
+            const { viewStyle } = taskViewOpts;
+            const { rowClassName, rowStyle } = viewStyle || {};
             const { tableColumn, scrollYLoad } = reactData;
             const trVNs = [];
             tableData.forEach((row, $rowIndex) => {
@@ -149,15 +164,21 @@ export default defineVxeComponent({
                     trOns.dragend = $xeTable.handleRowDragDragendEvent;
                     trOns.dragover = $xeTable.handleRowDragDragoverEvent;
                 }
+                const rowParams = { source: sourceType, type: viewType, row, rowIndex, $rowIndex, _rowIndex };
                 trVNs.push(h('tr', {
                     key: treeConfig ? rowid : $rowIndex,
-                    class: ['vxe-gantt-view--body-row', {
+                    class: [
+                        'vxe-gantt-view--body-row',
+                        {
                             'row--stripe': stripe && (_rowIndex + 1) % 2 === 0,
                             'is--new': isNewRow,
                             'row--radio': radioOpts.highlight && $xeTable.eqRow(selectRadioRow, row),
                             'row--checked': checkboxOpts.highlight && $xeTable.isCheckedByCheckboxRow(row),
                             'row--pending': !!pendingRowFlag && !!pendingRowMaps[rowid]
-                        }],
+                        },
+                        getClass(rowClassName, rowParams)
+                    ],
+                    style: rowStyle ? XEUtils.isFunction(rowStyle) ? rowStyle(rowParams) : rowStyle : undefined,
                     attrs: {
                         rowid
                     },

package/es/gantt/src/gantt-view.js

@@ -7,6 +7,7 @@ import GanttViewHeaderComponent from './gantt-header';
 import GanttViewBodyComponent from './gantt-body';
 import GanttViewFooterComponent from './gantt-footer';
 const { globalEvents } = VxeUI;
+const sourceType = 'gantt';
 function createInternalData() {
     return {
         xeTable: null,
@@ -751,10 +752,104 @@ function checkLastSyncScroll($xeGanttView, isRollX, isRollY) {
         reactData.lazScrollLoading = false;
     }, 200);
 }
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function handleScrollEvent($xeGanttView, evnt, isRollY, isRollX, scrollTop, scrollLeft) {
+function handleScrollData($xeGanttView, isRollY, isRollX, scrollTop, scrollLeft) {
+    const reactData = $xeGanttView.reactData;
+    const internalData = $xeGanttView.internalData;
+    if (isRollX) {
+        internalData.lastScrollLeft = scrollLeft;
+    }
+    if (isRollY) {
+        internalData.lastScrollTop = scrollTop;
+    }
+    reactData.lastScrollTime = Date.now();
     checkLastSyncScroll($xeGanttView, isRollX, isRollY);
 }
+function handleScrollEvent($xeGanttView, evnt, isRollY, isRollX, scrollTop, scrollLeft) {
+    const $xeGantt = $xeGanttView.$xeGantt;
+    const internalData = $xeGanttView.internalData;
+    const $xeTable = internalData.xeTable;
+    const { lastScrollLeft, lastScrollTop } = internalData;
+    const xHandleEl = $xeGanttView.$refs.refScrollXHandleElem;
+    const yHandleEl = $xeGanttView.$refs.refScrollYHandleElem;
+    if (!xHandleEl || !yHandleEl) {
+        return;
+    }
+    if (!$xeTable) {
+        return;
+    }
+    const bodyHeight = yHandleEl.clientHeight;
+    const bodyWidth = xHandleEl.clientWidth;
+    const scrollHeight = yHandleEl.scrollHeight;
+    const scrollWidth = xHandleEl.scrollWidth;
+    let isTop = false;
+    let isBottom = false;
+    let isLeft = false;
+    let isRight = false;
+    let direction = '';
+    let isTopBoundary = false;
+    let isBottomBoundary = false;
+    let isLeftBoundary = false;
+    let isRightBoundary = false;
+    if (isRollX) {
+        const xThreshold = $xeTable.computeScrollXThreshold;
+        isLeft = scrollLeft <= 0;
+        if (!isLeft) {
+            isRight = scrollLeft + bodyWidth >= scrollWidth - 1;
+        }
+        if (scrollLeft > lastScrollLeft) {
+            direction = 'right';
+            if (scrollLeft + bodyWidth >= scrollWidth - xThreshold) {
+                isRightBoundary = true;
+            }
+        }
+        else {
+            direction = 'left';
+            if (scrollLeft <= xThreshold) {
+                isLeftBoundary = true;
+            }
+        }
+    }
+    if (isRollY) {
+        const yThreshold = $xeTable.computeScrollYThreshold;
+        isTop = scrollTop <= 0;
+        if (!isTop) {
+            isBottom = scrollTop + bodyHeight >= scrollHeight - 1;
+        }
+        if (scrollTop > lastScrollTop) {
+            direction = 'bottom';
+            if (scrollTop + bodyHeight >= scrollHeight - yThreshold) {
+                isBottomBoundary = true;
+            }
+        }
+        else {
+            direction = 'top';
+            if (scrollTop <= yThreshold) {
+                isTopBoundary = true;
+            }
+        }
+    }
+    handleScrollData($xeGanttView, isRollY, isRollX, scrollTop, scrollLeft);
+    const evntParams = {
+        source: sourceType,
+        scrollTop,
+        scrollLeft,
+        bodyHeight,
+        bodyWidth,
+        scrollHeight,
+        scrollWidth,
+        isX: isRollX,
+        isY: isRollY,
+        isTop,
+        isBottom,
+        isLeft,
+        isRight,
+        direction
+    };
+    if (isBottomBoundary || isTopBoundary || isRightBoundary || isLeftBoundary) {
+        $xeGantt.dispatchEvent('scroll-boundary', evntParams, evnt);
+    }
+    $xeGantt.dispatchEvent('scroll', evntParams, evnt);
+}
 /**
  * 同步表格滚动
  */

package/es/gantt/src/gantt.js

@@ -59,6 +59,7 @@ XEUtils.each(VxeTableComponent.methods, (fn, name) => {
 });
 function createInternalData() {
     return {
+        uFoot: false,
         resizeTableWidth: 0
     };
 }
@@ -90,6 +91,7 @@ export default {
             filterData: [],
             formData: {},
             sortData: [],
+            footerData: [],
             tZindex: 0,
             tablePage: {
                 total: 0,
@@ -253,7 +255,9 @@ export default {
             const rest = {};
             const gridProps = props;
             propKeys.forEach(key => {
-                rest[key] = gridProps[key];
+                if (gridProps[key] !== undefined) {
+                    rest[key] = gridProps[key];
+                }
             });
             return rest;
         },
@@ -261,8 +265,8 @@ export default {
             const $xeGantt = this;
             const props = $xeGantt;
             const reactData = $xeGantt.reactData;
-            const { seqConfig, pagerConfig, editConfig, proxyConfig } = props;
-            const { isZMax, tablePage } = reactData;
+            const { showFooter, seqConfig, pagerConfig, editConfig, proxyConfig } = props;
+            const { isZMax, tablePage, footerData } = reactData;
             const taskViewOpts = $xeGantt.computeTaskViewOpts;
             const { tableStyle } = taskViewOpts;
             const tableExtendProps = $xeGantt.computeTableExtendProps;
@@ -281,8 +285,16 @@ export default {
                     tProps.border = border;
                 }
             }
+            if (showFooter && !tProps.footerData) {
+                // 如果未设置自己的标位数据，则使用代理的
+                tProps.footerData = footerData;
+            }
+            else if (proxyOpts.footer && footerData.length) {
+                // 如果代理标为数据，且未请求到数据，则用自己的
+                tProps.footerData = footerData;
+            }
             if (isZMax) {
-                if (tableExtendProps.maxHeight) {
+                if (tProps.maxHeight) {
                     tProps.maxHeight = '100%';
                 }
                 else {
@@ -600,6 +612,7 @@ export default {
             const $xeGantt = this;
             const props = $xeGantt;
             const reactData = $xeGantt.reactData;
+            const internalData = $xeGantt.internalData;
             const $xeTable = $xeGantt.$refs.refTable;
             const { proxyConfig } = props;
             const proxyOpts = $xeGantt.computeProxyOpts;
@@ -609,9 +622,12 @@ export default {
                 reactData.filterData = params.filterList;
                 if (proxyConfig && isEnableConf(proxyOpts)) {
                     reactData.tablePage.currentPage = 1;
+                    internalData.uFoot = true;
                     $xeGantt.commitProxy('query').then((rest) => {
                         $xeGantt.dispatchEvent('proxy-query', rest, params.$event);
                     });
+                    internalData.uFoot = false;
+                    $xeGantt.updateQueryFooter();
                 }
             }
         },
@@ -629,30 +645,38 @@ export default {
             const $xeGantt = this;
             const props = $xeGantt;
             const reactData = $xeGantt.reactData;
+            const internalData = $xeGantt.internalData;
             const { proxyConfig } = props;
             const proxyOpts = $xeGantt.computeProxyOpts;
             if (reactData.tableLoading) {
                 return;
             }
             if (proxyConfig && isEnableConf(proxyOpts)) {
+                internalData.uFoot = true;
                 $xeGantt.commitProxy('reload').then((rest) => {
                     $xeGantt.dispatchEvent('proxy-query', Object.assign(Object.assign({}, rest), { isReload: true }), params.$event);
                 });
+                internalData.uFoot = false;
+                $xeGantt.updateQueryFooter();
             }
             $xeGantt.dispatchEvent('form-submit', params, params.$event);
         },
         resetFormEvent(params) {
             const $xeGantt = this;
             const props = $xeGantt;
+            const internalData = $xeGantt.internalData;
             const $xeTable = $xeGantt.$refs.refTable;
             const { proxyConfig } = props;
             const { $event } = params;
             const proxyOpts = $xeGantt.computeProxyOpts;
             if (proxyConfig && isEnableConf(proxyOpts)) {
                 $xeTable.clearScroll();
+                internalData.uFoot = true;
                 $xeGantt.commitProxy('reload').then((rest) => {
                     $xeGantt.dispatchEvent('proxy-query', Object.assign(Object.assign({}, rest), { isReload: true }), $event);
                 });
+                internalData.uFoot = false;
+                $xeGantt.updateQueryFooter();
             }
             $xeGantt.dispatchEvent('form-reset', params, $event);
         },
@@ -798,6 +822,7 @@ export default {
             const $xeGantt = this;
             const props = $xeGantt;
             const reactData = $xeGantt.reactData;
+            const internalData = $xeGantt.internalData;
             const { proxyConfig, formConfig } = props;
             const { proxyInited } = reactData;
             const proxyOpts = $xeGantt.computeProxyOpts;
@@ -806,14 +831,30 @@ export default {
                 if (isEnableConf(formConfig) && proxyOpts.form && formOpts.items) {
                     reactData.formData = $xeGantt.getDefaultFormData();
                 }
-                if (!proxyInited && proxyOpts.autoLoad !== false) {
+                if (!proxyInited) {
                     reactData.proxyInited = true;
-                    $xeGantt.$nextTick().then(() => $xeGantt.commitProxy('initial')).then((rest) => {
-                        $xeGantt.dispatchEvent('proxy-query', Object.assign(Object.assign({}, rest), { isInited: true }), new Event('initial'));
-                    });
+                    if (proxyOpts.autoLoad !== false) {
+                        $xeGantt.$nextTick().then(() => {
+                            internalData.uFoot = true;
+                            const rest = $xeGantt.commitProxy('initial');
+                            internalData.uFoot = false;
+                            $xeGantt.updateQueryFooter();
+                            return rest;
+                        }).then((rest) => {
+                            $xeGantt.dispatchEvent('proxy-query', Object.assign(Object.assign({}, rest), { isInited: true }), new Event('initial'));
+                        });
+                    }
                 }
             }
         },
+        updateQueryFooter() {
+            const $xeGantt = this;
+            const proxyOpts = $xeGantt.computeProxyOpts;
+            const { ajax } = proxyOpts;
+            if (ajax && ajax.queryFooter) {
+                return $xeGantt.commitProxy('queryFooter');
+            }
+        },
         handleGlobalKeydownEvent(evnt) {
             const $xeGantt = this;
             const reactData = $xeGantt.reactData;
@@ -835,20 +876,21 @@ export default {
             const $xeGantt = this;
             const props = $xeGantt;
             const reactData = $xeGantt.reactData;
+            const internalData = $xeGantt.internalData;
             /**
              * 已废弃
              * @deprecated
              */
             const toolbar = props.toolbar;
-            const { proxyConfig, toolbarConfig, pagerConfig, editRules, validConfig } = props;
+            const { showFooter, proxyConfig, toolbarConfig, pagerConfig, editRules, validConfig } = props;
             const { tablePage } = reactData;
             const isActiveMsg = $xeGantt.computeIsActiveMsg;
             const isRespMsg = $xeGantt.computeIsRespMsg;
             const proxyOpts = $xeGantt.computeProxyOpts;
             const pagerOpts = $xeGantt.computePagerOpts;
             const toolbarOpts = $xeGantt.computeToolbarOpts;
-            const { beforeQuery, afterQuery, beforeDelete, afterDelete, beforeSave, afterSave, ajax = {} } = proxyOpts;
-            const resConfigs = proxyOpts.response || proxyOpts.props || {};
+            const { beforeQuery, afterQuery, beforeQueryFooter, afterQueryFooter, beforeDelete, afterDelete, beforeSave, afterSave, ajax = {} } = proxyOpts;
+            const resConfigs = (proxyOpts.response || proxyOpts.props || {});
             const $xeTable = $xeGantt.$refs.refTable;
             let formData = $xeGantt.getFormData();
             let button = null;
@@ -896,23 +938,25 @@ export default {
                 case 'initial':
                 case 'reload':
                 case 'query': {
-                    const ajaxMethods = ajax.query;
-                    const querySuccessMethods = ajax.querySuccess;
-                    const queryErrorMethods = ajax.queryError;
-                    if (ajaxMethods) {
+                    const qMethods = ajax.query;
+                    const qsMethods = ajax.querySuccess;
+                    const qeMethods = ajax.queryError;
+                    if (qMethods) {
                         const isInited = code === 'initial';
                         const isReload = code === 'reload';
                         if (!isInited && reactData.tableLoading) {
                             return $xeGantt.$nextTick();
                         }
+                        let operPromise = null;
                         let sortList = [];
                         let filterList = [];
                         let pageParams = {};
                         if (pagerConfig) {
                             if (isInited || isReload) {
+                                // 重置分页
                                 tablePage.currentPage = 1;
                             }
-                            if (isEnableConf(pagerConfig)) {
+                            if (isEnableConf(pagerOpts)) {
                                 pageParams = Object.assign({}, tablePage);
                             }
                         }
@@ -957,7 +1001,7 @@ export default {
                         else {
                             if ($xeTable) {
                                 if (isReload) {
-                                    $xeTable.clearAll();
+                                    operPromise = $xeTable.clearAll();
                                 }
                                 else {
                                     sortList = $xeTable.getSortColumns();
@@ -978,23 +1022,25 @@ export default {
                             sorts: sortList,
                             filters: filterList,
                             form: formData,
-                            options: ajaxMethods
+                            options: qMethods
                         };
                         reactData.sortData = sortList;
                         reactData.filterData = filterList;
                         reactData.tableLoading = true;
-                        const applyArgs = [commitParams].concat(args);
-                        return Promise.resolve((beforeQuery || ajaxMethods)(...applyArgs))
-                            .then(rest => {
+                        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: null, $gantt: $xeGantt };
                                 if (pagerConfig && isEnableConf(pagerOpts)) {
                                     const totalProp = resConfigs.total;
-                                    const total = (XEUtils.isFunction(totalProp) ? totalProp({ data: rest, $table: $xeTable, $grid: null, $gantt: $xeGantt }) : XEUtils.get(rest, totalProp || 'page.total')) || 0;
+                                    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({ data: rest, $table: $xeTable, $grid: null, $gantt: $xeGantt }) : XEUtils.get(rest, resultProp || '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) {
@@ -1003,36 +1049,89 @@ export default {
                                 }
                                 else {
                                     const listProp = resConfigs.list;
-                                    tableData = (listProp ? (XEUtils.isFunction(listProp) ? listProp({ data: rest, $table: $xeTable, $grid: null, $gantt: $xeGantt }) : XEUtils.get(rest, listProp)) : rest) || [];
+                                    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 {
-                                $xeTable.$nextTick(() => {
+                                $xeGantt.$nextTick(() => {
+                                    const $xeTable = $xeGantt.$refs.refTable;
                                     if ($xeTable) {
                                         $xeTable.loadData(tableData);
                                     }
                                 });
                             }
                             if (afterQuery) {
-                                afterQuery(...applyArgs);
+                                afterQuery(commitParams, ...args);
                             }
-                            if (querySuccessMethods) {
-                                querySuccessMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
+                            if (qsMethods) {
+                                qsMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
                             }
                             return { status: true };
                         }).catch((rest) => {
                             reactData.tableLoading = false;
-                            if (queryErrorMethods) {
-                                queryErrorMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
+                            if (qeMethods) {
+                                qeMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
+                            }
+                            return { status: false };
+                        });
+                    }
+                    else {
+                        errLog('vxe.error.notFunc', ['[gantt] proxy-config.ajax.query']);
+                    }
+                    break;
+                }
+                case 'queryFooter': {
+                    const qfMethods = ajax.queryFooter;
+                    const qfSuccessMethods = ajax.queryFooterSuccess;
+                    const qfErrorMethods = ajax.queryFooterError;
+                    if (qfMethods) {
+                        let filterList = [];
+                        if ($xeTable) {
+                            filterList = $xeTable.getCheckedFilters();
+                        }
+                        const commitParams = {
+                            $table: $xeTable,
+                            $grid: null,
+                            $gantt: $xeGantt,
+                            code,
+                            button,
+                            filters: filterList,
+                            form: formData,
+                            options: qfMethods
+                        };
+                        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 };
                         });
                     }
                     else {
-                        errLog('vxe.error.notFunc', ['proxy-config.ajax.query']);
+                        errLog('vxe.error.notFunc', ['[gantt] proxy-config.ajax.queryFooter']);
                     }
                     break;
                 }
@@ -1076,7 +1175,10 @@ export default {
                                         afterDelete(...applyArgs);
                                     }
                                     else {
+                                        internalData.uFoot = true;
                                         $xeGantt.commitProxy('query');
+                                        internalData.uFoot = false;
+                                        $xeGantt.updateQueryFooter();
                                     }
                                     if (deleteSuccessMethods) {
                                         deleteSuccessMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
@@ -1167,7 +1269,10 @@ export default {
                                         afterSave(...applyArgs);
                                     }
                                     else {
+                                        internalData.uFoot = true;
                                         $xeGantt.commitProxy('query');
+                                        internalData.uFoot = false;
+                                        $xeGantt.updateQueryFooter();
                                     }
                                     if (saveSuccessMethods) {
                                         saveSuccessMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
@@ -1476,12 +1581,24 @@ export default {
         },
         triggerToolbarCommitEvent(params, evnt) {
             const $xeGantt = this;
+            const internalData = $xeGantt.internalData;
             const { code } = params;
-            return $xeGantt.commitProxy(params, evnt).then((rest) => {
-                if (code && rest && rest.status && ['query', 'reload', 'delete', 'save'].includes(code)) {
-                    $xeGantt.dispatchEvent(code === 'delete' || code === 'save' ? `proxy-${code}` : 'proxy-query', Object.assign(Object.assign({}, rest), { isReload: code === 'reload' }), evnt);
+            if (code) {
+                const isUf = ['reload', 'delete', 'save'].includes(code);
+                if (isUf) {
+                    internalData.uFoot = true;
                 }
-            });
+                const rest = $xeGantt.commitProxy(params, evnt).then((rest) => {
+                    if (code && rest && rest.status && ['query', 'reload', 'delete', 'save'].includes(code)) {
+                        $xeGantt.dispatchEvent(code === 'delete' || code === 'save' ? `proxy-${code}` : 'proxy-query', Object.assign(Object.assign({}, rest), { isReload: code === 'reload' }), evnt);
+                    }
+                });
+                if (isUf) {
+                    $xeGantt.updateQueryFooter();
+                }
+                internalData.uFoot = false;
+                return rest;
+            }
         },
         triggerToolbarBtnEvent(button, evnt) {
             const $xeGantt = this;

package/es/ui/index.js

@@ -1,7 +1,7 @@
 import { VxeUI } from '@vxe-ui/core';
 import { errLog } from './src/log';
 const { setConfig, setIcon, checkVersion } = VxeUI;
-VxeUI.ganttVersion = "3.0.23";
+VxeUI.ganttVersion = "3.0.25";
 setConfig({
     gantt: {
         // size: null,

package/es/ui/src/log.js

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

package/es/ui/src/utils.js

@@ -39,3 +39,6 @@ export function eqEmptyValue(cellValue) {
 export function getStringValue(cellValue) {
     return eqEmptyValue(cellValue) ? '' : cellValue;
 }
+export function getClass(property, params) {
+    return property ? XEUtils.isFunction(property) ? property(params) : property : '';
+}