vxe-gantt 4.0.26 → 4.1.0

package/lib/index.umd.js

@@ -2780,7 +2780,7 @@ var core_ = __webpack_require__(4345);
 const {
   log
 } = core_.VxeUI;
-const version = `gantt v${"4.0.26"}`;
+const version = `gantt v${"4.1.0"}`;
 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.26";
+core_.VxeUI.ganttVersion = "4.1.0";
 setConfig({
   gantt: {
     // size: null,
@@ -2830,7 +2830,7 @@ setConfig({
       // beforeSave: null,
       // afterSave: null
     },
-    taskViewScaleConfs: {
+    taskViewScaleConfig: {
       week: {
         startDay: 1
       }
@@ -2871,6 +2871,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
@@ -3296,8 +3298,6 @@ const gridEmits = [...tableEmits, 'page-change', 'form-submit', 'form-submit-inv
 ;// ./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);
 ;// ./packages/gantt/src/util.ts
 function getRefElem(refEl) {
   if (refEl) {
@@ -3317,6 +3317,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 +3395,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) => {
@@ -3405,6 +3418,10 @@ const viewType = 'header';
             } else {
               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 = {
@@ -3420,6 +3437,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) {
@@ -4087,6 +4106,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 +4145,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 +4198,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 +4312,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 +4347,7 @@ const maxYHeight = 5e6;
           second: {}
         };
         const handleData = (type, colMaps, minCol) => {
-          if (minSType === type) {
+          if (minScale.type === type) {
             return;
           }
           const currCol = colMaps[type];
@@ -4294,14 +4365,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,7 +4432,7 @@ const maxYHeight = 5e6;
               dateObj
             }
           };
-          const minCol = colMaps[minSType];
+          const minCol = colMaps[minScale.type];
           if (minScale.level < 19) {
             handleData('year', colMaps, minCol);
           }
@@ -4388,7 +4460,7 @@ const maxYHeight = 5e6;
           fullCols.push(minCol);
         }
         taskScaleList.forEach(scaleItem => {
-          if (scaleItem.type === minSType) {
+          if (scaleItem.type === minScale.type) {
             groupCols.push({
               scaleItem,
               columns: fullCols
@@ -4407,6 +4479,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 +4747,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 +5050,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 +5407,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 +5766,7 @@ var external_root_VxeUITable_commonjs_vxe_table_commonjs2_vxe_table_amd_vxe_tabl
 
 
 
+
 const {
   getConfig,
   getIcon,
@@ -5492,7 +5816,7 @@ function getViewTypeLevel(type) {
     zoomConfig: Object,
     layouts: Array,
     taskConfig: Object,
-    taskViewScaleConfs: Object,
+    taskViewScaleConfig: Object,
     taskViewConfig: Object,
     taskBarConfig: Object,
     taskSplitConfig: Object,
@@ -5602,8 +5926,8 @@ function getViewTypeLevel(type) {
     const computeTaskOpts = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
       return Object.assign({}, getConfig().gantt.taskConfig, props.taskConfig);
     });
-    const computeTaskViewScaleMapsOpts = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
-      return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().merge({}, getConfig().gantt.taskViewScaleConfs, props.taskViewScaleConfs);
+    const computeTaskViewScaleOpts = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
+      return external_root_XEUtils_commonjs_xe_utils_commonjs2_xe_utils_amd_xe_utils_default().merge({}, getConfig().gantt.taskViewScaleConfig, props.taskViewScaleConfig);
     });
     const computeTaskViewOpts = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
       return Object.assign({}, getConfig().gantt.taskViewConfig, props.taskViewConfig);
@@ -5620,6 +5944,22 @@ function getViewTypeLevel(type) {
     const computeTaskSplitOpts = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
       return Object.assign({}, getConfig().gantt.taskSplitConfig, props.taskSplitConfig);
     });
+    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 computeTaskScaleConfs = (0,external_commonjs_vue_commonjs2_vue_root_Vue_.computed)(() => {
       const taskViewOpts = computeTaskViewOpts.value;
       const {
@@ -5874,13 +6214,16 @@ function getViewTypeLevel(type) {
       computeToolbarOpts,
       computeZoomOpts,
       computeTaskOpts,
-      computeTaskViewScaleMapsOpts,
+      computeTaskViewScaleOpts,
       computeTaskViewOpts,
       computeTaskBarOpts,
       computeTaskBarDragOpts,
       computeTaskBarResizeOpts,
       computeTaskSplitOpts,
       computeTaskScaleConfs,
+      computeScaleUnit,
+      computeMinScale,
+      computeWeekScale,
       computeTitleField,
       computeStartField,
       computeEndField,
@@ -5900,7 +6243,7 @@ function getViewTypeLevel(type) {
     };
     const handleTaskScaleConfig = () => {
       const taskScaleConfs = computeTaskScaleConfs.value;
-      const taskViewScaleMapsOpts = computeTaskViewScaleMapsOpts.value;
+      const taskViewScaleOpts = computeTaskViewScaleOpts.value;
       const scaleConfs = [];
       if (taskScaleConfs) {
         const keyMaps = {};
@@ -5920,7 +6263,7 @@ function getViewTypeLevel(type) {
             return;
           }
           keyMaps[type] = true;
-          scaleConfs.push(Object.assign({}, type ? taskViewScaleMapsOpts[type] || {} : {}, sConf, {
+          scaleConfs.push(Object.assign({}, type ? taskViewScaleOpts[type] || {} : {}, sConf, {
             level: getViewTypeLevel(type)
           }));
         });
@@ -7844,6 +8187,7 @@ function getViewTypeLevel(type) {
     });
     (0,external_commonjs_vue_commonjs2_vue_root_Vue_.watch)(computeTaskScaleConfs, () => {
       handleTaskScaleConfig();
+      $xeGantt.refreshTaskView();
     });
     hooks.forEach(options => {
       const {