vxe-gantt 4.0.27 → 4.1.1

package/lib/index.umd.js

@@ -2780,7 +2780,7 @@ var core_ = __webpack_require__(4345);
 const {
   log
 } = core_.VxeUI;
-const version = `gantt v${"4.0.27"}`;
+const version = `gantt v${"4.1.1"}`;
 const warnLog = log.create('warn', version);
 const errLog = log.create('error', version);
 ;// ./packages/ui/index.ts
@@ -2791,7 +2791,7 @@ const {
   setIcon,
   checkVersion
 } = core_.VxeUI;
-core_.VxeUI.ganttVersion = "4.0.27";
+core_.VxeUI.ganttVersion = "4.1.1";
 setConfig({
   gantt: {
     // size: null,
@@ -2830,6 +2830,9 @@ setConfig({
       // beforeSave: null,
       // afterSave: null
     },
+    taskBarTooltipConfig: {
+      enterable: true
+    },
     taskViewScaleConfig: {
       week: {
         startDay: 1
@@ -2871,6 +2874,8 @@ var es_array_push = __webpack_require__(4114);
 var es_iterator_constructor = __webpack_require__(8111);
 // EXTERNAL MODULE: ./node_modules/core-js/modules/es.iterator.filter.js
 var es_iterator_filter = __webpack_require__(2489);
+// EXTERNAL MODULE: ./node_modules/core-js/modules/es.iterator.find.js
+var es_iterator_find = __webpack_require__(116);
 // EXTERNAL MODULE: ./node_modules/core-js/modules/es.iterator.for-each.js
 var es_iterator_for_each = __webpack_require__(7588);
 // EXTERNAL MODULE: ./node_modules/core-js/modules/es.iterator.map.js
@@ -3077,7 +3082,7 @@ function getFuncText(content, args) {
   return '';
 }
 function formatText(value, placeholder) {
-  return '' + (isEmptyValue(value) ? placeholder ? VxeUI.getConfig().emptyCell : '' : value);
+  return '' + (isEmptyValue(value) ? placeholder ? core_.VxeUI.getConfig().emptyCell : '' : value);
 }
 /**
  * 判断值为：'' | null | undefined 时都属于空值
@@ -3295,9 +3300,7 @@ const tableEmits = ['update:data', 'keydown-start', 'keydown', 'keydown-end', 'p
 const gridEmits = [...tableEmits, 'page-change', 'form-submit', 'form-submit-invalid', 'form-reset', 'form-collapse', 'form-toggle-collapse', 'proxy-query', 'proxy-delete', 'proxy-save', 'toolbar-button-click', 'toolbar-tool-click', 'zoom'];
 ;// ./packages/gantt/src/emits.ts
 
-const ganttEmits = [...gridEmits, 'task-cell-click', 'task-cell-dblclick', 'task-bar-click', 'task-bar-dblclick', 'task-view-cell-click', 'task-view-cell-dblclick'];
-// EXTERNAL MODULE: ./node_modules/core-js/modules/es.iterator.find.js
-var es_iterator_find = __webpack_require__(116);
+const ganttEmits = [...gridEmits, 'task-cell-click', 'task-cell-dblclick', 'task-bar-mouseenter', 'task-bar-mouseleave', 'task-bar-click', 'task-bar-dblclick', 'task-view-cell-click', 'task-view-cell-dblclick'];
 ;// ./packages/gantt/src/util.ts
 function getRefElem(refEl) {
   if (refEl) {
@@ -3317,6 +3320,17 @@ function getCalcHeight(height) {
 function getCellRestHeight(rowRest, cellOpts, rowOpts, defaultRowHeight) {
   return rowRest.resizeHeight || cellOpts.height || rowOpts.height || rowRest.height || defaultRowHeight;
 }
+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;
+}
 ;// ./packages/gantt/src/gantt-header.ts
 
 
@@ -3384,12 +3398,14 @@ const viewType = 'header';
       }, $rowIndex) => {
         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 (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('tr', {
           key: $rowIndex
         }, columns.map((column, cIndex) => {
@@ -3399,11 +3415,17 @@ const viewType = 'header';
             dateObj
           } = column;
           let label = `${column.title}`;
-          if ($rowIndex < headerGroups.length - 1) {
-            if (scaleItem.type === 'day') {
-              label = getI18n(`vxe.gantt.dayss.w${dateObj.e}`);
+          if (scaleItem.type === 'day') {
+            label = getI18n(`vxe.gantt.dayss.w${dateObj.e}`);
+          } else {
+            if ($rowIndex) {
+              label = getI18n(`vxe.gantt.tSimpleFormat.${type}`, dateObj);
             } else {
-              label = getI18n(`vxe.gantt.${!$rowIndex && headerGroups.length > 1 ? 'tFullFormat' : 'tSimpleFormat'}.${type}`, dateObj);
+              if (isLast && scaleItem.type === 'week') {
+                label = getI18n(`vxe.gantt.tSimpleFormat.${type}`, dateObj);
+              } else {
+                label = getI18n(`vxe.gantt.tFullFormat.${type}`, dateObj);
+              }
             }
           }
           let cellVNs = label;
@@ -3420,6 +3442,8 @@ const viewType = 'header';
             cellVNs = $xeGantt.callSlot(titleSlot, ctParams);
           } else if (titleMethod) {
             cellVNs = `${titleMethod(ctParams)}`;
+          } else if (titleFormat) {
+            cellVNs = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(dateObj.date, titleFormat);
           }
           let cellStys = {};
           if (headerCellStyle) {
@@ -3532,7 +3556,8 @@ const gantt_chart_viewType = 'chart';
         showContent,
         contentMethod,
         barStyle,
-        drag
+        drag,
+        showTooltip
       } = taskBarOpts;
       const isBarRowStyle = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().isFunction(barStyle);
       const barStyObj = (barStyle ? isBarRowStyle ? barStyle(barParams) : barStyle : {}) || {};
@@ -3573,8 +3598,38 @@ const gantt_chart_viewType = 'chart';
         row,
         $rowIndex,
         rowIndex,
-        _rowIndex
+        _rowIndex,
+        $gantt: $xeGantt
       };
+      const ons = {
+        onClick(evnt) {
+          $xeGantt.handleTaskBarClickEvent(evnt, barParams);
+        },
+        onDblclick(evnt) {
+          $xeGantt.handleTaskBarDblclickEvent(evnt, barParams);
+        },
+        onMousedown(evnt) {
+          if ($xeGantt.handleTaskBarMousedownEvent) {
+            $xeGantt.handleTaskBarMousedownEvent(evnt, barParams);
+          }
+        }
+      };
+      if (showTooltip) {
+        ons.onMouseover = evnt => {
+          const ttParams = Object.assign({
+            $event: evnt
+          }, ctParams);
+          $xeGantt.triggerTaskBarTooltipEvent(evnt, ttParams);
+          $xeGantt.dispatchEvent('task-bar-mouseenter', ttParams, evnt);
+        };
+        ons.onMouseleave = evnt => {
+          const ttParams = Object.assign({
+            $event: evnt
+          }, ctParams);
+          $xeGantt.handleTaskBarTooltipLeaveEvent(evnt, ttParams);
+          $xeGantt.dispatchEvent('task-bar-mouseleave', ttParams, evnt);
+        };
+      }
       return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
         key: treeConfig ? rowid : $rowIndex,
         rowid,
@@ -3593,17 +3648,7 @@ const gantt_chart_viewType = 'chart';
         class: taskBarSlot ? 'vxe-gantt-view--chart-custom-bar' : 'vxe-gantt-view--chart-bar',
         style: vbStyle,
         rowid,
-        onClick(evnt) {
-          $xeGantt.handleTaskBarClickEvent(evnt, barParams);
-        },
-        onDblclick(evnt) {
-          $xeGantt.handleTaskBarDblclickEvent(evnt, barParams);
-        },
-        onMousedown(evnt) {
-          if ($xeGantt.handleTaskBarMousedownEvent) {
-            $xeGantt.handleTaskBarMousedownEvent(evnt, barParams);
-          }
-        }
+        ...ons
       }, taskBarSlot ? $xeGantt.callSlot(taskBarSlot, barParams) : [showProgress ? (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
         class: 'vxe-gantt-view--chart-progress',
         style: vpStyle
@@ -4087,6 +4132,8 @@ const {
   globalEvents
 } = core_.VxeUI;
 const gantt_view_sourceType = 'gantt';
+const minuteMs = 1000 * 60;
+const dayMs = minuteMs * 60 * 24;
 function createInternalData() {
   return {
     xeTable: null,
@@ -4124,7 +4171,10 @@ const maxYHeight = 5e6;
       computeEndField,
       computeScrollbarOpts,
       computeScrollbarXToTop,
-      computeScrollbarYToLeft
+      computeScrollbarYToLeft,
+      computeScaleUnit,
+      computeWeekScale,
+      computeMinScale
     } = $xeGantt.getComputeMaps();
     const refElem = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
     const refScrollXVirtualElem = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
@@ -4174,7 +4224,80 @@ const maxYHeight = 5e6;
     const refMaps = {
       refElem
     };
-    const computeMaps = {};
+    const computeScaleDateList = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
+      const {
+        minViewDate,
+        maxViewDate
+      } = reactData;
+      const minScale = computeMinScale.value;
+      const dateList = [];
+      if (!minViewDate || !maxViewDate) {
+        return dateList;
+      }
+      const startTime = minViewDate.getTime();
+      const endTime = maxViewDate.getTime();
+      switch (minScale.type) {
+        case 'year':
+          {
+            let currDate = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getWhatYear(minViewDate, 0, 'first');
+            while (currDate <= maxViewDate) {
+              const itemDate = currDate;
+              dateList.push(itemDate);
+              currDate = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getWhatYear(currDate, 1);
+            }
+            break;
+          }
+        case 'quarter':
+          {
+            let currDate = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getWhatQuarter(minViewDate, 0, 'first');
+            while (currDate <= maxViewDate) {
+              const itemDate = currDate;
+              dateList.push(itemDate);
+              currDate = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getWhatQuarter(currDate, 1);
+            }
+            break;
+          }
+        case 'month':
+          {
+            let currDate = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getWhatMonth(minViewDate, 0, 'first');
+            while (currDate <= maxViewDate) {
+              const itemDate = currDate;
+              dateList.push(itemDate);
+              currDate = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getWhatMonth(currDate, 1);
+            }
+            break;
+          }
+        case 'week':
+          {
+            let currDate = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getWhatWeek(minViewDate, 0, minScale.startDay, minScale.startDay);
+            while (currDate <= maxViewDate) {
+              const itemDate = currDate;
+              dateList.push(itemDate);
+              currDate = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().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;
+    });
+    const computeMaps = {
+      computeScaleDateList
+    };
     const $xeGanttView = {
       xID,
       props,
@@ -4215,44 +4338,18 @@ const maxYHeight = 5e6;
         second: `${yyyy}_${MM}_${dd}_${HH}_${mm}_${ss}`
       };
     };
-    const handleParseColumn = () => {
-      const ganttProps = $xeGantt.props;
+    const handleColumnHeader = () => {
       const ganttReactData = $xeGantt.reactData;
-      const {
-        treeConfig
-      } = ganttProps;
       const {
         taskScaleList
       } = ganttReactData;
-      const {
-        minViewDate,
-        maxViewDate
-      } = reactData;
-      const minScale = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().last(taskScaleList);
+      const scaleUnit = computeScaleUnit.value;
+      const minScale = computeMinScale.value;
+      const weekScale = computeWeekScale.value;
+      const scaleDateList = computeScaleDateList.value;
       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: [],
@@ -4276,7 +4373,7 @@ const maxYHeight = 5e6;
           second: {}
         };
         const handleData = (type, colMaps, minCol) => {
-          if (minSType === type) {
+          if (minScale.type === type) {
             return;
           }
           const currCol = colMaps[type];
@@ -4294,14 +4391,15 @@ const maxYHeight = 5e6;
             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] = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().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 = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getYearWeek(itemDate, weekScale ? weekScale.startDay : undefined);
           const dateObj = {
+            date: itemDate,
             yy: yyyy,
             M: MM,
             d: dd,
@@ -4360,14 +4458,14 @@ const maxYHeight = 5e6;
               dateObj
             }
           };
-          const minCol = colMaps[minSType];
+          const minCol = colMaps[minScale.type];
           if (minScale.level < 19) {
             handleData('year', colMaps, minCol);
           }
           if (minScale.level < 17) {
             handleData('quarter', colMaps, minCol);
           }
-          if (minScale.level < 14) {
+          if (minScale.level < 15) {
             handleData('month', colMaps, minCol);
           }
           if (minScale.level < 13) {
@@ -4376,7 +4474,7 @@ const maxYHeight = 5e6;
           if (minScale.level < 11) {
             handleData('day', colMaps, minCol);
           }
-          if (minScale.level < 12) {
+          if (minScale.level < 9) {
             handleData('date', colMaps, minCol);
           }
           if (minScale.level < 7) {
@@ -4385,10 +4483,13 @@ const maxYHeight = 5e6;
           if (minScale.level < 5) {
             handleData('minute', colMaps, minCol);
           }
+          if (minScale.level < 3) {
+            handleData('second', colMaps, minCol);
+          }
           fullCols.push(minCol);
         }
         taskScaleList.forEach(scaleItem => {
-          if (scaleItem.type === minSType) {
+          if (scaleItem.type === minScale.type) {
             groupCols.push({
               scaleItem,
               columns: fullCols
@@ -4407,6 +4508,249 @@ const maxYHeight = 5e6;
             columns: list
           });
         });
+      }
+      return {
+        fullCols,
+        groupCols
+      };
+    };
+    const createChartRender = fullCols => {
+      const {
+        minViewDate
+      } = reactData;
+      const minScale = computeMinScale.value;
+      const scaleUnit = computeScaleUnit.value;
+      const weekScale = computeWeekScale.value;
+      switch (scaleUnit) {
+        case 'year':
+          {
+            const indexMaps = {};
+            fullCols.forEach(({
+              dateObj
+            }, i) => {
+              const yyyyMM = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(dateObj.date, 'yyyy');
+              indexMaps[yyyyMM] = i;
+            });
+            return (startValue, endValue) => {
+              const startDate = parseStringDate(startValue);
+              const endDate = parseStringDate(endValue);
+              const startStr = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(startDate, 'yyyy');
+              const startFirstDate = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getWhatYear(startDate, 0, 'first');
+              const endStr = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(endDate, 'yyyy');
+              const endFirstDate = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getWhatYear(endDate, 0, 'first');
+              const dateSize = Math.floor((external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().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 = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(dateObj.date, 'yyyy-q');
+              indexMaps[q] = i;
+            });
+            return (startValue, endValue) => {
+              const startDate = parseStringDate(startValue);
+              const endDate = parseStringDate(endValue);
+              const startStr = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(startDate, 'yyyy-q');
+              const startFirstDate = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getWhatQuarter(startDate, 0, 'first');
+              const endStr = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(endDate, 'yyyy-q');
+              const endFirstDate = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getWhatQuarter(endDate, 0, 'first');
+              const dateSize = Math.floor((external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().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 = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(dateObj.date, 'yyyy-MM');
+              indexMaps[yyyyMM] = i;
+            });
+            return (startValue, endValue) => {
+              const startDate = parseStringDate(startValue);
+              const endDate = parseStringDate(endValue);
+              const startStr = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(startDate, 'yyyy-MM');
+              const startFirstDate = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getWhatMonth(startDate, 0, 'first');
+              const endStr = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(endDate, 'yyyy-MM');
+              const endFirstDate = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getWhatMonth(endDate, 0, 'first');
+              const dateSize = Math.floor((external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().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 = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(dateObj.date, 'yyyy-W', {
+                firstDay: weekScale ? weekScale.startDay : undefined
+              });
+              indexMaps[yyyyW] = i;
+            });
+            return (startValue, endValue) => {
+              const startDate = parseStringDate(startValue);
+              const endDate = parseStringDate(endValue);
+              const startStr = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(startDate, 'yyyy-W', {
+                firstDay: weekScale ? weekScale.startDay : undefined
+              });
+              const startFirstDate = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getWhatWeek(startDate, 0, weekScale ? weekScale.startDay : undefined, weekScale ? weekScale.startDay : undefined);
+              const endStr = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(endDate, 'yyyy-W', {
+                firstDay: weekScale ? weekScale.startDay : undefined
+              });
+              const endFirstDate = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getWhatWeek(endDate, 0, weekScale ? weekScale.startDay : undefined, weekScale ? weekScale.startDay : undefined);
+              const dateSize = Math.floor((external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().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 = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(dateObj.date, 'yyyy-MM-dd');
+              indexMaps[yyyyMM] = i;
+            });
+            return (startValue, endValue) => {
+              const startDate = parseStringDate(startValue);
+              const endDate = parseStringDate(endValue);
+              const startStr = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(startDate, 'yyyy-MM-dd');
+              const startFirstDate = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getWhatDay(startDate, 0, 'first');
+              const endStr = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(endDate, 'yyyy-MM-dd');
+              const endFirstDate = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getWhatDay(endDate, 0, 'first');
+              const minuteSize = Math.floor((external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().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 = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(dateObj.date, 'yyyy-MM-dd HH');
+              indexMaps[yyyyMM] = i;
+            });
+            return (startValue, endValue) => {
+              const startDate = parseStringDate(startValue);
+              const endDate = parseStringDate(endValue);
+              const startStr = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(startDate, 'yyyy-MM-dd HH');
+              const startFirstDate = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getWhatHours(startDate, 0, 'first');
+              const endStr = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(endDate, 'yyyy-MM-dd HH');
+              const endFirstDate = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getWhatHours(endDate, 0, 'first');
+              const minuteSize = Math.floor((external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().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 = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(dateObj.date, 'yyyy-MM-dd HH:mm');
+              indexMaps[yyyyMM] = i;
+            });
+            return (startValue, endValue) => {
+              const startDate = parseStringDate(startValue);
+              const endDate = parseStringDate(endValue);
+              const startStr = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(startDate, 'yyyy-MM-dd HH:mm');
+              const startFirstDate = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getWhatMinutes(startDate, 0, 'first');
+              const endStr = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().toDateString(endDate, 'yyyy-MM-dd HH:mm');
+              const endFirstDate = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().getWhatMinutes(endDate, 0, 'first');
+              const minuteSize = Math.floor((external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().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(startValue);
+              const endDate = parseStringDate(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
+        };
+      };
+    };
+    const handleParseColumn = () => {
+      const ganttProps = $xeGantt.props;
+      const {
+        treeConfig
+      } = ganttProps;
+      const {
+        minViewDate,
+        maxViewDate
+      } = reactData;
+      const {
+        fullCols,
+        groupCols
+      } = handleColumnHeader();
+      if (minViewDate && maxViewDate && fullCols.length) {
         const $xeTable = internalData.xeTable;
         if ($xeTable) {
           const startField = computeStartField.value;
@@ -4432,20 +4776,21 @@ const maxYHeight = 5e6;
           } = treeOpts;
           const childrenField = treeOpts.children || treeOpts.childrenField;
           const ctMaps = {};
+          const renderFn = createChartRender(fullCols);
           const handleParseRender = row => {
             const rowid = $xeTable.getRowid(row);
             const startValue = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().get(row, startField);
             const endValue = external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().get(row, endField);
             if (startValue && endValue) {
-              const startDate = parseStringDate(startValue);
-              const endDate = parseStringDate(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
               };
             }
           };
@@ -4734,13 +5079,13 @@ const maxYHeight = 5e6;
           rceRunTime
         } = internalData;
         const $xeTable = internalData.xeTable;
-        let refreshDelay = 50;
+        let refreshDelay = 30;
         if ($xeTable) {
           const {
             computeResizeOpts
           } = $xeTable.getComputeMaps();
           const resizeOpts = computeResizeOpts.value;
-          refreshDelay = resizeOpts.refreshDelay || 50;
+          refreshDelay = resizeOpts.refreshDelay || refreshDelay;
         }
         if (rceTimeout) {
           clearTimeout(rceTimeout);
@@ -5091,7 +5436,14 @@ const maxYHeight = 5e6;
     const ganttViewMethods = {
       refreshData() {
         handleUpdateData();
-        return handleLazyRecalculate();
+        handleRecalculateStyle();
+        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)().then(() => {
+          const $xeTable = internalData.xeTable;
+          handleRecalculateStyle();
+          if ($xeTable) {
+            return $xeTable.recalculate();
+          }
+        });
       },
       updateViewData() {
         const $xeTable = internalData.xeTable;
@@ -5443,6 +5795,7 @@ var external_root_VxeUITable_commonjs_vxe_table_commonjs2_vxe_table_amd_vxe_tabl
 
 
 
+
 const {
   getConfig,
   getIcon,
@@ -5463,6 +5816,7 @@ function gantt_createInternalData() {
   return {
     uFoot: false,
     resizeTableWidth: 0
+    // barTipTimeout: undefined
   };
 }
 const viewTypeLevelMaps = {
@@ -5495,6 +5849,7 @@ function getViewTypeLevel(type) {
     taskViewScaleConfig: Object,
     taskViewConfig: Object,
     taskBarConfig: Object,
+    taskBarTooltipConfig: Object,
     taskSplitConfig: Object,
     taskBarResizeConfig: Object,
     taskBarDragConfig: Object,
@@ -5515,6 +5870,7 @@ function getViewTypeLevel(type) {
     const VxeUIPagerComponent = core_.VxeUI.getComponent('VxePager');
     const VxeTableComponent = core_.VxeUI.getComponent('VxeTable');
     const VxeToolbarComponent = core_.VxeUI.getComponent('VxeToolbar');
+    const VxeUITooltipComponent = core_.VxeUI.getComponent('VxeTooltip');
     const {
       computeSize
     } = useFns.useSize(props);
@@ -5535,7 +5891,13 @@ function getViewTypeLevel(type) {
       },
       showLeftView: true,
       showRightView: true,
-      taskScaleList: []
+      taskScaleList: [],
+      barTipStore: {
+        row: null,
+        content: '',
+        visible: false,
+        params: null
+      }
     });
     const internalData = gantt_createInternalData();
     const refElem = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
@@ -5554,6 +5916,7 @@ function getViewTypeLevel(type) {
     const refPagerWrapper = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
     const refTableWrapper = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
     const refGanttWrapper = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
+    const refTooltip = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
     const refResizableSplitTip = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.ref)();
     const extendTableMethods = methodKeys => {
       const funcs = {};
@@ -5620,7 +5983,26 @@ function getViewTypeLevel(type) {
     const computeTaskSplitOpts = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
       return Object.assign({}, getConfig().gantt.taskSplitConfig, props.taskSplitConfig);
     });
-    const computeTaskScaleConfs = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
+    const computeTaskBarTooltipOpts = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
+      return Object.assign({}, getConfig().gantt.taskBarTooltipConfig, props.taskBarTooltipConfig);
+    });
+    const computeScaleUnit = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
+      const minScale = computeMinScale.value;
+      return minScale ? minScale.type : 'date';
+    });
+    const computeMinScale = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
+      const {
+        taskScaleList
+      } = reactData;
+      return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().last(taskScaleList);
+    });
+    const computeWeekScale = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
+      const {
+        taskScaleList
+      } = reactData;
+      return taskScaleList.find(item => item.type === 'week');
+    });
+    const computeTaskViewScales = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
       const taskViewOpts = computeTaskViewOpts.value;
       const {
         scales
@@ -5880,7 +6262,11 @@ function getViewTypeLevel(type) {
       computeTaskBarDragOpts,
       computeTaskBarResizeOpts,
       computeTaskSplitOpts,
-      computeTaskScaleConfs,
+      computeTaskBarTooltipOpts,
+      computeTaskViewScales,
+      computeScaleUnit,
+      computeMinScale,
+      computeWeekScale,
       computeTitleField,
       computeStartField,
       computeEndField,
@@ -5889,6 +6275,7 @@ function getViewTypeLevel(type) {
       computeScrollbarXToTop,
       computeScrollbarYToLeft
     };
+    computeMaps.computeTaskScaleConfs = computeTaskViewScales;
     const $xeGantt = {
       xID,
       props: props,
@@ -5899,7 +6286,7 @@ function getViewTypeLevel(type) {
       getComputeMaps: () => computeMaps
     };
     const handleTaskScaleConfig = () => {
-      const taskScaleConfs = computeTaskScaleConfs.value;
+      const taskScaleConfs = computeTaskViewScales.value;
       const taskViewScaleOpts = computeTaskViewScaleOpts.value;
       const scaleConfs = [];
       if (taskScaleConfs) {
@@ -6436,6 +6823,17 @@ function getViewTypeLevel(type) {
         $gantt: $xeGantt
       }, params));
     };
+    const handleTargetEnterEvent = isClear => {
+      const $tooltip = refTooltip.value;
+      clearTimeout(internalData.barTipTimeout);
+      if (isClear) {
+        $xeGantt.closeTaskBarTooltip();
+      } else {
+        if ($tooltip && $tooltip.setActived) {
+          $tooltip.setActived(true);
+        }
+      }
+    };
     const ganttMethods = {
       dispatchEvent,
       getEl() {
@@ -7171,6 +7569,27 @@ function getViewTypeLevel(type) {
       hideTaskView() {
         reactData.showRightView = false;
         return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
+      },
+      /**
+       * 关闭 bar tooltip
+       */
+      closeTaskBarTooltip() {
+        const {
+          barTipStore
+        } = reactData;
+        const $tooltip = refTooltip.value;
+        if (barTipStore.visible) {
+          Object.assign(barTipStore, {
+            row: null,
+            content: null,
+            visible: false,
+            params: {}
+          });
+          if ($tooltip && $tooltip.close) {
+            $tooltip.close();
+          }
+        }
+        return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)();
       }
     };
     const ganttPrivateMethods = {
@@ -7316,6 +7735,58 @@ function getViewTypeLevel(type) {
       handleTaskBarDblclickEvent(evnt, params) {
         $xeGantt.dispatchEvent('task-bar-dblclick', params, evnt);
       },
+      triggerTaskBarTooltipEvent(evnt, params) {
+        const {
+          barTipStore
+        } = reactData;
+        const taskBarTooltipOpts = computeTaskBarTooltipOpts.value;
+        const titleField = computeTitleField.value;
+        const {
+          contentMethod
+        } = taskBarTooltipOpts;
+        const {
+          row
+        } = params;
+        let content = formatText(external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().get(row, titleField));
+        if (contentMethod) {
+          content = formatText(contentMethod(params));
+        }
+        handleTargetEnterEvent(barTipStore.row !== row);
+        const tipContent = formatText(content);
+        Object.assign(barTipStore, {
+          row,
+          visible: true,
+          content: tipContent,
+          params
+        });
+        (0,external_commonjs_vue_commonjs2_vue_root_Vue_.nextTick)(() => {
+          const $tooltip = refTooltip.value;
+          if ($tooltip) {
+            if ($tooltip.openByEvent) {
+              $tooltip.openByEvent(evnt, evnt.currentTarget, tipContent);
+            } else if ($tooltip.open) {
+              $tooltip.open(evnt.currentTarget, tipContent);
+            }
+          }
+        });
+      },
+      handleTaskBarTooltipLeaveEvent() {
+        const taskBarTooltipOpts = computeTaskBarTooltipOpts.value;
+        let $tooltip = refTooltip.value;
+        if ($tooltip && $tooltip.setActived) {
+          $tooltip.setActived(false);
+        }
+        if (taskBarTooltipOpts.enterable) {
+          internalData.barTipTimeout = setTimeout(() => {
+            $tooltip = refTooltip.value;
+            if ($tooltip && $tooltip.isActived && !$tooltip.isActived()) {
+              $xeGantt.closeTaskBarTooltip();
+            }
+          }, taskBarTooltipOpts.leaveDelay);
+        } else {
+          $xeGantt.closeTaskBarTooltip();
+        }
+      },
       handleTaskHeaderContextmenuEvent(evnt, params) {
         const $xeTable = refTable.value;
         if ($xeTable) {
@@ -7769,14 +8240,19 @@ function getViewTypeLevel(type) {
       return childVNs;
     };
     const renderLayout = () => {
+      const {
+        barTipStore
+      } = reactData;
       const currLayoutConf = computeCurrLayoutConf.value;
       const {
         headKeys,
         bodyKeys,
         footKeys
       } = currLayoutConf;
+      const taskBarTooltipOpts = computeTaskBarTooltipOpts.value;
       const asideLeftSlot = slots.asideLeft || slots['aside-left'];
       const asideRightSlot = slots.asideRight || slots['aside-right'];
+      const taskBarTooltipSlot = slots.taskBarTooltip || slots['task-bar-tooltip'];
       return [(0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
         class: 'vxe-gantt--layout-header-wrapper'
       }, renderChildLayout(headKeys)), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
@@ -7791,7 +8267,40 @@ function getViewTypeLevel(type) {
         class: 'vxe-gantt--layout-footer-wrapper'
       }, renderChildLayout(footKeys)), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {
         ref: refPopupContainerElem
-      })];
+      }), (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {}, [
+      /**
+        * 任务条提示
+        */
+      (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)(VxeUITooltipComponent, {
+        key: 'gtp',
+        ref: refTooltip,
+        theme: taskBarTooltipOpts.theme,
+        enterable: taskBarTooltipOpts.enterable,
+        enterDelay: taskBarTooltipOpts.enterDelay,
+        leaveDelay: taskBarTooltipOpts.leaveDelay,
+        useHTML: taskBarTooltipOpts.useHTML,
+        width: taskBarTooltipOpts.width,
+        height: taskBarTooltipOpts.height,
+        minWidth: taskBarTooltipOpts.minWidth,
+        minHeight: taskBarTooltipOpts.minHeight,
+        maxWidth: taskBarTooltipOpts.maxWidth,
+        maxHeight: taskBarTooltipOpts.maxHeight,
+        isArrow: false
+      }, taskBarTooltipSlot ? {
+        content: () => {
+          const {
+            row,
+            content: tooltipContent
+          } = barTipStore;
+          if (row) {
+            return (0,external_commonjs_vue_commonjs2_vue_root_Vue_.h)('div', {}, taskBarTooltipSlot(Object.assign({
+              tooltipContent,
+              $gantt: $xeGantt
+            }, barTipStore.params)));
+          }
+          return gantt_renderEmptyElement($xeGantt);
+        }
+      } : {})])];
     };
     const renderVN = () => {
       const {
@@ -7842,8 +8351,9 @@ function getViewTypeLevel(type) {
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.watch)(() => props.proxyConfig, () => {
       initProxy();
     });
-    (0,external_commonjs_vue_commonjs2_vue_root_Vue_.watch)(computeTaskScaleConfs, () => {
+    (0,external_commonjs_vue_commonjs2_vue_root_Vue_.watch)(computeTaskViewScales, () => {
       handleTaskScaleConfig();
+      $xeGantt.refreshTaskView();
     });
     hooks.forEach(options => {
       const {