vxe-gantt 3.0.27 → 3.1.0

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

@@ -57,9 +57,10 @@ export default defineVxeComponent({
                             });
                         })),
                         h('thead', {}, headerGroups.map(({ scaleItem, columns }, $rowIndex) => {
-                            const { type, titleMethod, headerCellStyle, slots } = scaleItem;
+                            const { type, titleFormat, titleMethod, headerCellStyle, slots } = scaleItem;
                             const titleSlot = slots ? slots.title : null;
-                            const todayValue = showNowLine && $rowIndex === headerGroups.length - 1 ? todayDateMaps[type] : null;
+                            const isLast = $rowIndex === headerGroups.length - 1;
+                            const todayValue = isLast && showNowLine ? todayDateMaps[type] : null;
                             return h('tr', {
                                 key: $rowIndex
                             }, columns.map((column, cIndex) => {
@@ -73,6 +74,11 @@ export default defineVxeComponent({
                                         label = getI18n(`vxe.gantt.${!$rowIndex && headerGroups.length > 1 ? 'tFullFormat' : 'tSimpleFormat'}.${type}`, dateObj);
                                     }
                                 }
+                                else {
+                                    if (isLast && scaleItem.type === 'week') {
+                                        label = getI18n(`vxe.gantt.tSimpleFormat.${type}`, dateObj);
+                                    }
+                                }
                                 let cellVNs = label;
                                 const ctParams = { source: sourceType, type: viewType, column, scaleObj: scaleItem, title: label, dateObj: dateObj, $rowIndex };
                                 if (titleSlot) {
@@ -81,6 +87,9 @@ export default defineVxeComponent({
                                 else if (titleMethod) {
                                     cellVNs = `${titleMethod(ctParams)}`;
                                 }
+                                else if (titleFormat) {
+                                    cellVNs = XEUtils.toDateString(dateObj.date, titleFormat);
+                                }
                                 let cellStys = {};
                                 if (headerCellStyle) {
                                     if (XEUtils.isFunction(headerCellStyle)) {

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

@@ -1,13 +1,15 @@
 import { defineVxeComponent } from '../../ui/src/comp';
 import { VxeUI } from '@vxe-ui/core';
 import { setScrollTop, setScrollLeft, removeClass, addClass } from '../../ui/src/dom';
-import { getRefElem } from './util';
+import { getRefElem, getStandardGapTime } from './util';
 import XEUtils from 'xe-utils';
 import GanttViewHeaderComponent from './gantt-header';
 import GanttViewBodyComponent from './gantt-body';
 import GanttViewFooterComponent from './gantt-footer';
 const { globalEvents } = VxeUI;
 const sourceType = 'gantt';
+const minuteMs = 1000 * 60;
+const dayMs = minuteMs * 60 * 24;
 function createInternalData() {
     return {
         xeTable: null,
@@ -64,39 +66,17 @@ function updateTodayData($xeGanttView) {
         second: `${yyyy}_${MM}_${dd}_${HH}_${mm}_${ss}`
     };
 }
-function handleParseColumn($xeGanttView) {
+function handleColumnHeader($xeGanttView) {
     const $xeGantt = $xeGanttView.$xeGantt;
-    const reactData = $xeGanttView.reactData;
-    const internalData = $xeGanttView.internalData;
-    const ganttProps = $xeGantt;
     const ganttReactData = $xeGantt.reactData;
-    const { treeConfig } = ganttProps;
     const { taskScaleList } = ganttReactData;
-    const { minViewDate, maxViewDate } = reactData;
-    const minScale = XEUtils.last(taskScaleList);
+    const scaleUnit = $xeGantt.computeScaleUnit;
+    const minScale = $xeGantt.computeMinScale;
+    const weekScale = $xeGantt.computeWeekScale;
+    const scaleDateList = $xeGanttView.computeScaleDateList;
     const fullCols = [];
     const groupCols = [];
-    if (minScale && minViewDate && maxViewDate) {
-        const minSType = minScale.type;
-        const weekScale = taskScaleList.find(item => item.type === 'week');
-        let gapTime = 1000 * 60 * 60 * 24;
-        switch (minScale.type) {
-            case 'hour':
-                gapTime = 1000 * 60 * 60;
-                break;
-            case 'minute':
-                gapTime = 1000 * 60;
-                break;
-            case 'second':
-                gapTime = 1000;
-                break;
-            default: {
-                break;
-            }
-        }
-        const currTime = minViewDate.getTime();
-        const diffDayNum = maxViewDate.getTime() - minViewDate.getTime();
-        const countSize = Math.max(5, Math.floor(diffDayNum / gapTime) + 1);
+    if (minScale && scaleUnit && scaleDateList.length) {
         const renderListMaps = {
             year: [],
             quarter: [],
@@ -120,7 +100,7 @@ function handleParseColumn($xeGanttView) {
             second: {}
         };
         const handleData = (type, colMaps, minCol) => {
-            if (minSType === type) {
+            if (minScale.type === type) {
                 return;
             }
             const currCol = colMaps[type];
@@ -138,14 +118,14 @@ function handleParseColumn($xeGanttView) {
                 currGpCol.children.push(minCol);
             }
         };
-        for (let i = 0; i < countSize; i++) {
-            const itemDate = new Date(currTime + (i * gapTime));
+        for (let i = 0; i < scaleDateList.length; i++) {
+            const itemDate = scaleDateList[i];
             const [yyyy, MM, dd, HH, mm, ss] = XEUtils.toDateString(itemDate, 'yyyy-M-d-H-m-s').split('-');
             const e = itemDate.getDay();
             const E = e + 1;
             const q = Math.ceil((itemDate.getMonth() + 1) / 3);
             const W = XEUtils.getYearWeek(itemDate, weekScale ? weekScale.startDay : undefined);
-            const dateObj = { yy: yyyy, M: MM, d: dd, H: HH, m: mm, s: ss, q, W, E, e };
+            const dateObj = { date: itemDate, yy: yyyy, M: MM, d: dd, H: HH, m: mm, s: ss, q, W, E, e };
             const colMaps = {
                 year: {
                     field: yyyy,
@@ -193,7 +173,7 @@ function handleParseColumn($xeGanttView) {
                     dateObj
                 }
             };
-            const minCol = colMaps[minSType];
+            const minCol = colMaps[minScale.type];
             if (minScale.level < 19) {
                 handleData('year', colMaps, minCol);
             }
@@ -221,7 +201,7 @@ function handleParseColumn($xeGanttView) {
             fullCols.push(minCol);
         }
         taskScaleList.forEach(scaleItem => {
-            if (scaleItem.type === minSType) {
+            if (scaleItem.type === minScale.type) {
                 groupCols.push({
                     scaleItem,
                     columns: fullCols
@@ -240,6 +220,216 @@ function handleParseColumn($xeGanttView) {
                 columns: list
             });
         });
+    }
+    return {
+        fullCols,
+        groupCols
+    };
+}
+function createChartRender($xeGanttView, fullCols) {
+    const $xeGantt = $xeGanttView.$xeGantt;
+    const reactData = $xeGanttView.reactData;
+    const { minViewDate } = reactData;
+    const minScale = $xeGantt.computeMinScale;
+    const scaleUnit = $xeGantt.computeScaleUnit;
+    const weekScale = $xeGantt.computeWeekScale;
+    switch (scaleUnit) {
+        case 'year': {
+            const indexMaps = {};
+            fullCols.forEach(({ dateObj }, i) => {
+                const yyyyMM = XEUtils.toDateString(dateObj.date, 'yyyy');
+                indexMaps[yyyyMM] = i;
+            });
+            return (startValue, endValue) => {
+                const startDate = parseStringDate($xeGanttView, startValue);
+                const endDate = parseStringDate($xeGanttView, endValue);
+                const startStr = XEUtils.toDateString(startDate, 'yyyy');
+                const startFirstDate = XEUtils.getWhatYear(startDate, 0, 'first');
+                const endStr = XEUtils.toDateString(endDate, 'yyyy');
+                const endFirstDate = XEUtils.getWhatYear(endDate, 0, 'first');
+                const dateSize = Math.floor((XEUtils.getWhatYear(endDate, 1, 'first').getTime() - endFirstDate.getTime()) / dayMs);
+                const subtract = (startDate.getTime() - startFirstDate.getTime()) / dayMs / dateSize;
+                const addSize = Math.max(0, (endDate.getTime() - endFirstDate.getTime()) / dayMs + 1) / dateSize;
+                const offsetLeftSize = (indexMaps[startStr] || 0) + subtract;
+                return {
+                    offsetLeftSize,
+                    offsetWidthSize: (indexMaps[endStr] || 0) - offsetLeftSize + addSize
+                };
+            };
+        }
+        case 'quarter': {
+            const indexMaps = {};
+            fullCols.forEach(({ dateObj }, i) => {
+                const q = XEUtils.toDateString(dateObj.date, 'yyyy-q');
+                indexMaps[q] = i;
+            });
+            return (startValue, endValue) => {
+                const startDate = parseStringDate($xeGanttView, startValue);
+                const endDate = parseStringDate($xeGanttView, endValue);
+                const startStr = XEUtils.toDateString(startDate, 'yyyy-q');
+                const startFirstDate = XEUtils.getWhatQuarter(startDate, 0, 'first');
+                const endStr = XEUtils.toDateString(endDate, 'yyyy-q');
+                const endFirstDate = XEUtils.getWhatQuarter(endDate, 0, 'first');
+                const dateSize = Math.floor((XEUtils.getWhatQuarter(endDate, 1, 'first').getTime() - endFirstDate.getTime()) / dayMs);
+                const subtract = (startDate.getTime() - startFirstDate.getTime()) / dayMs / dateSize;
+                const addSize = Math.max(0, (endDate.getTime() - endFirstDate.getTime()) / dayMs + 1) / dateSize;
+                const offsetLeftSize = (indexMaps[startStr] || 0) + subtract;
+                return {
+                    offsetLeftSize,
+                    offsetWidthSize: (indexMaps[endStr] || 0) - offsetLeftSize + addSize
+                };
+            };
+        }
+        case 'month': {
+            const indexMaps = {};
+            fullCols.forEach(({ dateObj }, i) => {
+                const yyyyMM = XEUtils.toDateString(dateObj.date, 'yyyy-MM');
+                indexMaps[yyyyMM] = i;
+            });
+            return (startValue, endValue) => {
+                const startDate = parseStringDate($xeGanttView, startValue);
+                const endDate = parseStringDate($xeGanttView, endValue);
+                const startStr = XEUtils.toDateString(startDate, 'yyyy-MM');
+                const startFirstDate = XEUtils.getWhatMonth(startDate, 0, 'first');
+                const endStr = XEUtils.toDateString(endDate, 'yyyy-MM');
+                const endFirstDate = XEUtils.getWhatMonth(endDate, 0, 'first');
+                const dateSize = Math.floor((XEUtils.getWhatMonth(endDate, 1, 'first').getTime() - endFirstDate.getTime()) / dayMs);
+                const subtract = (startDate.getTime() - startFirstDate.getTime()) / dayMs / dateSize;
+                const addSize = Math.max(0, (endDate.getTime() - endFirstDate.getTime()) / dayMs + 1) / dateSize;
+                const offsetLeftSize = (indexMaps[startStr] || 0) + subtract;
+                return {
+                    offsetLeftSize,
+                    offsetWidthSize: (indexMaps[endStr] || 0) - offsetLeftSize + addSize
+                };
+            };
+        }
+        case 'week': {
+            const indexMaps = {};
+            fullCols.forEach(({ dateObj }, i) => {
+                const yyyyW = XEUtils.toDateString(dateObj.date, 'yyyy-W', { firstDay: weekScale ? weekScale.startDay : undefined });
+                indexMaps[yyyyW] = i;
+            });
+            return (startValue, endValue) => {
+                const startDate = parseStringDate($xeGanttView, startValue);
+                const endDate = parseStringDate($xeGanttView, endValue);
+                const startStr = XEUtils.toDateString(startDate, 'yyyy-W', { firstDay: weekScale ? weekScale.startDay : undefined });
+                const startFirstDate = XEUtils.getWhatWeek(startDate, 0, weekScale ? weekScale.startDay : undefined, weekScale ? weekScale.startDay : undefined);
+                const endStr = XEUtils.toDateString(endDate, 'yyyy-W', { firstDay: weekScale ? weekScale.startDay : undefined });
+                const endFirstDate = XEUtils.getWhatWeek(endDate, 0, weekScale ? weekScale.startDay : undefined, weekScale ? weekScale.startDay : undefined);
+                const dateSize = Math.floor((XEUtils.getWhatWeek(endDate, 1, weekScale ? weekScale.startDay : undefined, weekScale ? weekScale.startDay : undefined).getTime() - endFirstDate.getTime()) / dayMs);
+                const subtract = (startDate.getTime() - startFirstDate.getTime()) / dayMs / dateSize;
+                const addSize = Math.max(0, (endDate.getTime() - endFirstDate.getTime()) / dayMs + 1) / dateSize;
+                const offsetLeftSize = (indexMaps[startStr] || 0) + subtract;
+                return {
+                    offsetLeftSize,
+                    offsetWidthSize: (indexMaps[endStr] || 0) - offsetLeftSize + addSize
+                };
+            };
+        }
+        case 'day':
+        case 'date': {
+            const indexMaps = {};
+            fullCols.forEach(({ dateObj }, i) => {
+                const yyyyMM = XEUtils.toDateString(dateObj.date, 'yyyy-MM-dd');
+                indexMaps[yyyyMM] = i;
+            });
+            return (startValue, endValue) => {
+                const startDate = parseStringDate($xeGanttView, startValue);
+                const endDate = parseStringDate($xeGanttView, endValue);
+                const startStr = XEUtils.toDateString(startDate, 'yyyy-MM-dd');
+                const startFirstDate = XEUtils.getWhatDay(startDate, 0, 'first');
+                const endStr = XEUtils.toDateString(endDate, 'yyyy-MM-dd');
+                const endFirstDate = XEUtils.getWhatDay(endDate, 0, 'first');
+                const minuteSize = Math.floor((XEUtils.getWhatDay(endDate, 1, 'first').getTime() - endFirstDate.getTime()) / minuteMs);
+                const subtract = (startDate.getTime() - startFirstDate.getTime()) / minuteMs / minuteSize;
+                const addSize = Math.max(0, (endDate.getTime() - endFirstDate.getTime()) / minuteMs + 1) / minuteSize;
+                const offsetLeftSize = (indexMaps[startStr] || 0) + subtract;
+                return {
+                    offsetLeftSize,
+                    offsetWidthSize: (indexMaps[endStr] || 0) - offsetLeftSize + addSize
+                };
+            };
+        }
+        case 'hour': {
+            const indexMaps = {};
+            fullCols.forEach(({ dateObj }, i) => {
+                const yyyyMM = XEUtils.toDateString(dateObj.date, 'yyyy-MM-dd HH');
+                indexMaps[yyyyMM] = i;
+            });
+            return (startValue, endValue) => {
+                const startDate = parseStringDate($xeGanttView, startValue);
+                const endDate = parseStringDate($xeGanttView, endValue);
+                const startStr = XEUtils.toDateString(startDate, 'yyyy-MM-dd HH');
+                const startFirstDate = XEUtils.getWhatHours(startDate, 0, 'first');
+                const endStr = XEUtils.toDateString(endDate, 'yyyy-MM-dd HH');
+                const endFirstDate = XEUtils.getWhatHours(endDate, 0, 'first');
+                const minuteSize = Math.floor((XEUtils.getWhatHours(endDate, 1, 'first').getTime() - endFirstDate.getTime()) / minuteMs);
+                const subtract = (startDate.getTime() - startFirstDate.getTime()) / minuteMs / minuteSize;
+                const addSize = Math.max(0, (endDate.getTime() - endFirstDate.getTime()) / minuteMs + 1) / minuteSize;
+                const offsetLeftSize = (indexMaps[startStr] || 0) + subtract;
+                return {
+                    offsetLeftSize,
+                    offsetWidthSize: (indexMaps[endStr] || 0) - offsetLeftSize + addSize
+                };
+            };
+        }
+        case 'minute': {
+            const indexMaps = {};
+            fullCols.forEach(({ dateObj }, i) => {
+                const yyyyMM = XEUtils.toDateString(dateObj.date, 'yyyy-MM-dd HH:mm');
+                indexMaps[yyyyMM] = i;
+            });
+            return (startValue, endValue) => {
+                const startDate = parseStringDate($xeGanttView, startValue);
+                const endDate = parseStringDate($xeGanttView, endValue);
+                const startStr = XEUtils.toDateString(startDate, 'yyyy-MM-dd HH:mm');
+                const startFirstDate = XEUtils.getWhatMinutes(startDate, 0, 'first');
+                const endStr = XEUtils.toDateString(endDate, 'yyyy-MM-dd HH:mm');
+                const endFirstDate = XEUtils.getWhatMinutes(endDate, 0, 'first');
+                const minuteSize = Math.floor((XEUtils.getWhatMinutes(endDate, 1, 'first').getTime() - endFirstDate.getTime()) / minuteMs);
+                const subtract = (startDate.getTime() - startFirstDate.getTime()) / minuteMs / minuteSize;
+                const addSize = Math.max(0, (endDate.getTime() - endFirstDate.getTime()) / minuteMs + 1) / minuteSize;
+                const offsetLeftSize = (indexMaps[startStr] || 0) + subtract;
+                return {
+                    offsetLeftSize,
+                    offsetWidthSize: (indexMaps[endStr] || 0) - offsetLeftSize + addSize
+                };
+            };
+        }
+        case 'second': {
+            const gapTime = getStandardGapTime(minScale.type);
+            return (startValue, endValue) => {
+                const startDate = parseStringDate($xeGanttView, startValue);
+                const endDate = parseStringDate($xeGanttView, endValue);
+                let offsetLeftSize = 0;
+                let offsetWidthSize = 0;
+                if (minViewDate) {
+                    offsetLeftSize = (startDate.getTime() - minViewDate.getTime()) / gapTime;
+                    offsetWidthSize = ((endDate.getTime() - startDate.getTime()) / gapTime) + 1;
+                }
+                return {
+                    offsetLeftSize,
+                    offsetWidthSize
+                };
+            };
+        }
+    }
+    return () => {
+        return {
+            offsetLeftSize: 0,
+            offsetWidthSize: 0
+        };
+    };
+}
+function handleParseColumn($xeGanttView) {
+    const $xeGantt = $xeGanttView.$xeGantt;
+    const reactData = $xeGanttView.reactData;
+    const internalData = $xeGanttView.internalData;
+    const ganttProps = $xeGantt;
+    const { treeConfig } = ganttProps;
+    const { minViewDate, maxViewDate } = reactData;
+    const { fullCols, groupCols } = handleColumnHeader($xeGanttView);
+    if (minViewDate && maxViewDate) {
         const $xeTable = internalData.xeTable;
         if ($xeTable) {
             const startField = $xeGantt.computeStartField;
@@ -253,20 +443,18 @@ function handleParseColumn($xeGanttView) {
             const { transform } = treeOpts;
             const childrenField = treeOpts.children || treeOpts.childrenField;
             const ctMaps = {};
+            const renderFn = createChartRender($xeGanttView, fullCols);
             const handleParseRender = (row) => {
                 const rowid = $xeTable.getRowid(row);
                 const startValue = XEUtils.get(row, startField);
                 const endValue = XEUtils.get(row, endField);
                 if (startValue && endValue) {
-                    const startDate = parseStringDate($xeGanttView, startValue);
-                    const endDate = parseStringDate($xeGanttView, endValue);
-                    const oLeftSize = Math.floor((startDate.getTime() - minViewDate.getTime()) / gapTime);
-                    const oWidthSize = Math.floor((endDate.getTime() - startDate.getTime()) / gapTime) + 1;
+                    const { offsetLeftSize, offsetWidthSize } = renderFn(startValue, endValue);
                     ctMaps[rowid] = {
                         row,
                         rowid,
-                        oLeftSize,
-                        oWidthSize
+                        oLeftSize: offsetLeftSize,
+                        oWidthSize: offsetWidthSize
                     };
                 }
             };
@@ -527,10 +715,10 @@ function handleLazyRecalculate($xeGanttView) {
     return new Promise(resolve => {
         const { rceTimeout, rceRunTime } = internalData;
         const $xeTable = internalData.xeTable;
-        let refreshDelay = 50;
+        let refreshDelay = 30;
         if ($xeTable) {
             const resizeOpts = $xeTable.computeResizeOpts;
-            refreshDelay = resizeOpts.refreshDelay || 50;
+            refreshDelay = resizeOpts.refreshDelay || refreshDelay;
         }
         if (rceTimeout) {
             clearTimeout(rceTimeout);
@@ -918,15 +1106,88 @@ export default defineVxeComponent({
             internalData
         };
     },
-    computed: Object.assign({}, {}),
+    computed: Object.assign(Object.assign({}, {}), { computeScaleDateList() {
+            const $xeGanttView = this;
+            const $xeGantt = $xeGanttView.$xeGantt;
+            const reactData = $xeGanttView.reactData;
+            const { minViewDate, maxViewDate } = reactData;
+            const minScale = $xeGantt.computeMinScale;
+            const dateList = [];
+            if (!minViewDate || !maxViewDate) {
+                return dateList;
+            }
+            const startTime = minViewDate.getTime();
+            const endTime = maxViewDate.getTime();
+            switch (minScale.type) {
+                case 'year': {
+                    let currDate = XEUtils.getWhatYear(minViewDate, 0, 'first');
+                    while (currDate <= maxViewDate) {
+                        const itemDate = currDate;
+                        dateList.push(itemDate);
+                        currDate = XEUtils.getWhatYear(currDate, 1);
+                    }
+                    break;
+                }
+                case 'quarter': {
+                    let currDate = XEUtils.getWhatQuarter(minViewDate, 0, 'first');
+                    while (currDate <= maxViewDate) {
+                        const itemDate = currDate;
+                        dateList.push(itemDate);
+                        currDate = XEUtils.getWhatQuarter(currDate, 1);
+                    }
+                    break;
+                }
+                case 'month': {
+                    let currDate = XEUtils.getWhatMonth(minViewDate, 0, 'first');
+                    while (currDate <= maxViewDate) {
+                        const itemDate = currDate;
+                        dateList.push(itemDate);
+                        currDate = XEUtils.getWhatMonth(currDate, 1);
+                    }
+                    break;
+                }
+                case 'week': {
+                    let currDate = XEUtils.getWhatWeek(minViewDate, 0, minScale.startDay, minScale.startDay);
+                    while (currDate <= maxViewDate) {
+                        const itemDate = currDate;
+                        dateList.push(itemDate);
+                        currDate = XEUtils.getWhatWeek(currDate, 1);
+                    }
+                    break;
+                }
+                case 'day':
+                case 'date':
+                case 'hour':
+                case 'minute':
+                case 'second': {
+                    const gapTime = getStandardGapTime(minScale.type);
+                    let currTime = startTime;
+                    while (currTime <= endTime) {
+                        const itemDate = new Date(currTime);
+                        dateList.push(itemDate);
+                        currTime += gapTime;
+                    }
+                    break;
+                }
+            }
+            return dateList;
+        } }),
     methods: {
         //
         // Method
         //
         refreshData() {
             const $xeGanttView = this;
+            const internalData = $xeGanttView.internalData;
             handleUpdateData($xeGanttView);
-            return handleLazyRecalculate($xeGanttView);
+            handleRecalculateStyle($xeGanttView);
+            return $xeGanttView.$nextTick().then(() => {
+                const $xeTable = internalData.xeTable;
+                handleRecalculateStyle($xeGanttView);
+                if ($xeTable) {
+                    return $xeTable.recalculate();
+                }
+            });
         },
         updateViewData() {
             const $xeGanttView = this;

package/es/gantt/src/gantt.js

@@ -179,6 +179,23 @@ export default {
             const props = $xeGantt;
             return Object.assign({}, getConfig().gantt.taskSplitConfig, props.taskSplitConfig);
         },
+        computeScaleUnit() {
+            const $xeGantt = this;
+            const minScale = $xeGantt.computeMinScale;
+            return minScale ? minScale.type : 'date';
+        },
+        computeMinScale() {
+            const $xeGantt = this;
+            const reactData = $xeGantt.reactData;
+            const { taskScaleList } = reactData;
+            return XEUtils.last(taskScaleList);
+        },
+        computeWeekScale() {
+            const $xeGantt = this;
+            const reactData = $xeGantt.reactData;
+            const { taskScaleList } = reactData;
+            return taskScaleList.find(item => item.type === 'week');
+        },
         computeTaskScaleConfs() {
             const $xeGantt = this;
             const taskViewOpts = $xeGantt.computeTaskViewOpts;
@@ -435,6 +452,7 @@ export default {
         computeTaskScaleConfs() {
             const $xeGantt = this;
             $xeGantt.handleTaskScaleConfig();
+            $xeGantt.refreshTaskView();
         }
     },
     methods: Object.assign(Object.assign({}, tableMethods), { dispatchEvent(type, params, evnt) {

package/es/gantt/src/util.js

@@ -7,3 +7,14 @@ export function getRefElem(refEl) {
 export function getCellRestHeight(rowRest, cellOpts, rowOpts, defaultRowHeight) {
     return rowRest.resizeHeight || cellOpts.height || rowOpts.height || rowRest.height || defaultRowHeight;
 }
+export function getStandardGapTime(type) {
+    switch (type) {
+        case 'hour':
+            return 1000 * 60 * 60;
+        case 'minute':
+            return 1000 * 60;
+        case 'second':
+            return 1000;
+    }
+    return 1000 * 60 * 60 * 24;
+}

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.27";
+VxeUI.ganttVersion = "3.1.0";
 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.27"}`;
+const version = `gantt v${"3.1.0"}`;
 export const warnLog = log.create('warn', version);
 export const errLog = log.create('error', version);

package/lib/gantt/src/gantt-header.js

@@ -64,11 +64,13 @@ var _default = exports.default = (0, _comp.defineVxeComponent)({
         var scaleItem = _ref.scaleItem,
           columns = _ref.columns;
         var type = scaleItem.type,
+          titleFormat = scaleItem.titleFormat,
           titleMethod = scaleItem.titleMethod,
           headerCellStyle = scaleItem.headerCellStyle,
           slots = scaleItem.slots;
         var titleSlot = slots ? slots.title : null;
-        var todayValue = showNowLine && $rowIndex === headerGroups.length - 1 ? todayDateMaps[type] : null;
+        var isLast = $rowIndex === headerGroups.length - 1;
+        var todayValue = isLast && showNowLine ? todayDateMaps[type] : null;
         return h('tr', {
           key: $rowIndex
         }, columns.map(function (column, cIndex) {
@@ -82,6 +84,10 @@ var _default = exports.default = (0, _comp.defineVxeComponent)({
             } else {
               label = getI18n("vxe.gantt.".concat(!$rowIndex && headerGroups.length > 1 ? 'tFullFormat' : 'tSimpleFormat', ".").concat(type), dateObj);
             }
+          } else {
+            if (isLast && scaleItem.type === 'week') {
+              label = getI18n("vxe.gantt.tSimpleFormat.".concat(type), dateObj);
+            }
           }
           var cellVNs = label;
           var ctParams = {
@@ -97,6 +103,8 @@ var _default = exports.default = (0, _comp.defineVxeComponent)({
             cellVNs = $xeGantt.callSlot(titleSlot, ctParams, h);
           } else if (titleMethod) {
             cellVNs = "".concat(titleMethod(ctParams));
+          } else if (titleFormat) {
+            cellVNs = _xeUtils.default.toDateString(dateObj.date, titleFormat);
           }
           var cellStys = {};
           if (headerCellStyle) {

package/lib/gantt/src/gantt-header.min.js

@@ -1 +1 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.default=void 0;var _comp=require("../../ui/src/comp"),_core=require("@vxe-ui/core"),_xeUtils=_interopRequireDefault(require("xe-utils"));function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}var getI18n=_core.VxeUI.getI18n,sourceType="gantt",viewType="header",_default=exports.default=(0,_comp.defineVxeComponent)({name:"VxeGanttViewHeader",inject:{$xeGantt:{default:null},$xeGanttView:{default:null}},computed:Object.assign({},{}),methods:{renderVN:function(x){var m=this.$xeGantt,e=this.$xeGanttView,t=e.reactData,a=e.internalData,h=t.headerGroups,n=t.viewCellWidth,r=a.todayDateMaps,t=a.visibleColumn,w=m.computeTaskViewOpts.showNowLine;return x("div",{ref:"refElem",class:"vxe-gantt-view--header-wrapper"},[x("div",{ref:"refHeaderScroll",class:"vxe-gantt-view--header-inner-wrapper",on:{scroll:e.triggerHeaderScrollEvent}},[x("div",{ref:"refHeaderXSpace",class:"vxe-body--x-space"}),x("table",{ref:"refHeaderTable",class:"vxe-gantt-view--header-table"},[x("colgroup",{},t.map(function(e,t){return x("col",{key:t,style:{width:"".concat(n,"px")}})})),x("thead",{},h.map(function(e,i){var u=e.scaleItem,e=e.columns,s=u.type,d=u.titleMethod,p=u.headerCellStyle,t=u.slots,f=t?t.title:null,v=w&&i===h.length-1?r[s]:null;return x("tr",{key:i},e.map(function(e,t){var a=e.field,n=e.childCount,r=e.dateObj,l="".concat(e.title),o=l=i<h.length-1?"day"===u.type?getI18n("vxe.gantt.dayss.w".concat(r.e)):getI18n("vxe.gantt.".concat(!i&&1<h.length?"tFullFormat":"tSimpleFormat",".").concat(s),r):l,c={source:sourceType,type:viewType,column:e,scaleObj:u,title:l,dateObj:r,$rowIndex:i},e=(f?o=m.callSlot(f,c,x):d&&(o="".concat(d(c))),{});return p&&(e=_xeUtils.default.isFunction(p)?p(c):p),x("th",{key:t,class:["vxe-gantt-view--header-column",{"is--now":w&&v&&v===a}],attrs:{colspan:n||null,title:f?null:l},style:e,on:{contextmenu:function(e){m.handleTaskHeaderContextmenuEvent(e,c)}}},o)}))}))])])])}},mounted:function(){var e=this,t=e.$xeGanttView.internalData.elemStore,a="main-header-";t["".concat(a,"wrapper")]=e.$refs.refElem,t["".concat(a,"scroll")]=e.$refs.refHeaderScroll,t["".concat(a,"table")]=e.$refs.refHeaderTable,t["".concat(a,"xSpace")]=e.$refs.refHeaderXSpace},destroyed:function(){var e=this.$xeGanttView.internalData.elemStore,t="main-header-";e["".concat(t,"wrapper")]=null,e["".concat(t,"scroll")]=null,e["".concat(t,"table")]=null,e["".concat(t,"xSpace")]=null},render:function(e){return this.renderVN(e)}});
+Object.defineProperty(exports,"__esModule",{value:!0}),exports.default=void 0;var _comp=require("../../ui/src/comp"),_core=require("@vxe-ui/core"),_xeUtils=_interopRequireDefault(require("xe-utils"));function _interopRequireDefault(e){return e&&e.__esModule?e:{default:e}}var getI18n=_core.VxeUI.getI18n,sourceType="gantt",viewType="header",_default=exports.default=(0,_comp.defineVxeComponent)({name:"VxeGanttViewHeader",inject:{$xeGantt:{default:null},$xeGanttView:{default:null}},computed:Object.assign({},{}),methods:{renderVN:function(h){var w=this.$xeGantt,e=this.$xeGanttView,t=e.reactData,a=e.internalData,g=t.headerGroups,n=t.viewCellWidth,r=a.todayDateMaps,t=a.visibleColumn,y=w.computeTaskViewOpts.showNowLine;return h("div",{ref:"refElem",class:"vxe-gantt-view--header-wrapper"},[h("div",{ref:"refHeaderScroll",class:"vxe-gantt-view--header-inner-wrapper",on:{scroll:e.triggerHeaderScrollEvent}},[h("div",{ref:"refHeaderXSpace",class:"vxe-body--x-space"}),h("table",{ref:"refHeaderTable",class:"vxe-gantt-view--header-table"},[h("colgroup",{},t.map(function(e,t){return h("col",{key:t,style:{width:"".concat(n,"px")}})})),h("thead",{},g.map(function(e,i){var u=e.scaleItem,e=e.columns,s=u.type,d=u.titleFormat,p=u.titleMethod,f=u.headerCellStyle,t=u.slots,x=t?t.title:null,m=i===g.length-1,v=m&&y?r[s]:null;return h("tr",{key:i},e.map(function(e,t){var a=e.field,n=e.childCount,r=e.dateObj,l="".concat(e.title),o=(i<g.length-1?l="day"===u.type?getI18n("vxe.gantt.dayss.w".concat(r.e)):getI18n("vxe.gantt.".concat(!i&&1<g.length?"tFullFormat":"tSimpleFormat",".").concat(s),r):m&&"week"===u.type&&(l=getI18n("vxe.gantt.tSimpleFormat.".concat(s),r)),l),c={source:sourceType,type:viewType,column:e,scaleObj:u,title:l,dateObj:r,$rowIndex:i},e=(x?o=w.callSlot(x,c,h):p?o="".concat(p(c)):d&&(o=_xeUtils.default.toDateString(r.date,d)),{});return f&&(e=_xeUtils.default.isFunction(f)?f(c):f),h("th",{key:t,class:["vxe-gantt-view--header-column",{"is--now":y&&v&&v===a}],attrs:{colspan:n||null,title:x?null:l},style:e,on:{contextmenu:function(e){w.handleTaskHeaderContextmenuEvent(e,c)}}},o)}))}))])])])}},mounted:function(){var e=this,t=e.$xeGanttView.internalData.elemStore,a="main-header-";t["".concat(a,"wrapper")]=e.$refs.refElem,t["".concat(a,"scroll")]=e.$refs.refHeaderScroll,t["".concat(a,"table")]=e.$refs.refHeaderTable,t["".concat(a,"xSpace")]=e.$refs.refHeaderXSpace},destroyed:function(){var e=this.$xeGanttView.internalData.elemStore,t="main-header-";e["".concat(t,"wrapper")]=null,e["".concat(t,"scroll")]=null,e["".concat(t,"table")]=null,e["".concat(t,"xSpace")]=null},render:function(e){return this.renderVN(e)}});