@nocobase/client 0.9.1-alpha.2 → 0.9.2-alpha.1

package/lib/schema-component/antd/gantt/helpers/bar-helper.js

@@ -0,0 +1,340 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.progressWithByParams = exports.progressByProgressWidth = exports.handleTaskBySVGMouseEvent = exports.getProgressPoint = exports.convertToBarTasks = void 0;
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+var convertToBarTasks = function convertToBarTasks(tasks, dates, columnWidth, rowHeight, taskHeight, barCornerRadius, handleWidth, rtl, barProgressColor, barProgressSelectedColor, barBackgroundColor, barBackgroundSelectedColor, projectProgressColor, projectProgressSelectedColor, projectBackgroundColor, projectBackgroundSelectedColor, milestoneBackgroundColor, milestoneBackgroundSelectedColor) {
+  var barTasks = tasks.map(function (t, i) {
+    return convertToBarTask(t, i, dates, columnWidth, rowHeight, taskHeight, barCornerRadius, handleWidth, rtl, barProgressColor, barProgressSelectedColor, barBackgroundColor, barBackgroundSelectedColor, projectProgressColor, projectProgressSelectedColor, projectBackgroundColor, projectBackgroundSelectedColor, milestoneBackgroundColor, milestoneBackgroundSelectedColor);
+  });
+  // set dependencies
+  barTasks = barTasks.map(function (task) {
+    var dependencies = task.dependencies || [];
+    var _loop = function _loop(j) {
+      var dependence = barTasks.findIndex(function (value) {
+        return value.id === dependencies[j];
+      });
+      if (dependence !== -1) barTasks[dependence].barChildren.push(task);
+    };
+    for (var j = 0; j < dependencies.length; j++) {
+      _loop(j);
+    }
+    return task;
+  });
+  return barTasks;
+};
+exports.convertToBarTasks = convertToBarTasks;
+var convertToBarTask = function convertToBarTask(task, index, dates, columnWidth, rowHeight, taskHeight, barCornerRadius, handleWidth, rtl, barProgressColor, barProgressSelectedColor, barBackgroundColor, barBackgroundSelectedColor, projectProgressColor, projectProgressSelectedColor, projectBackgroundColor, projectBackgroundSelectedColor, milestoneBackgroundColor, milestoneBackgroundSelectedColor) {
+  var barTask;
+  switch (task.type) {
+    case 'milestone':
+      barTask = convertToMilestone(task, index, dates, columnWidth, rowHeight, taskHeight, barCornerRadius, handleWidth, milestoneBackgroundColor, milestoneBackgroundSelectedColor);
+      break;
+    case 'project':
+      barTask = convertToBar(task, index, dates, columnWidth, rowHeight, taskHeight * 0.5, barCornerRadius, handleWidth, rtl, projectProgressColor, projectProgressSelectedColor, projectBackgroundColor, projectBackgroundSelectedColor);
+      break;
+    default:
+      barTask = convertToBar(task, index, dates, columnWidth, rowHeight, taskHeight, barCornerRadius, handleWidth, rtl, barProgressColor, barProgressSelectedColor, barBackgroundColor, barBackgroundSelectedColor);
+      break;
+  }
+  return barTask;
+};
+var convertToBar = function convertToBar(task, index, dates, columnWidth, rowHeight, taskHeight, barCornerRadius, handleWidth, rtl, barProgressColor, barProgressSelectedColor, barBackgroundColor, barBackgroundSelectedColor) {
+  var x1;
+  var x2;
+  if (rtl) {
+    x2 = taskXCoordinateRTL(task.start, dates, columnWidth);
+    x1 = taskXCoordinateRTL(task.end, dates, columnWidth);
+  } else {
+    x1 = taskXCoordinate(task.start, dates, columnWidth);
+    x2 = taskXCoordinate(task.end, dates, columnWidth);
+  }
+  var typeInternal = task.type;
+  if (typeInternal === 'task' && x2 - x1 < handleWidth * 2) {
+    typeInternal = 'smalltask';
+    x2 = x1 + handleWidth * 2;
+  }
+  var _progressWithByParams = progressWithByParams(x1, x2, task.progress, rtl),
+    _progressWithByParams2 = _slicedToArray(_progressWithByParams, 2),
+    progressWidth = _progressWithByParams2[0],
+    progressX = _progressWithByParams2[1];
+  var y = task.type === 'project' ? taskYCoordinate(index, rowHeight, taskHeight) + 8 : taskYCoordinate(index, rowHeight, taskHeight);
+  var hideChildren = task.type === 'project' ? task.hideChildren : undefined;
+  var styles = _objectSpread({
+    backgroundColor: barBackgroundColor,
+    backgroundSelectedColor: barBackgroundSelectedColor,
+    progressColor: barProgressColor,
+    progressSelectedColor: barProgressSelectedColor
+  }, task.styles);
+  return _objectSpread(_objectSpread({}, task), {}, {
+    typeInternal: typeInternal,
+    x1: x1,
+    x2: x2,
+    y: y,
+    index: index,
+    progressX: progressX,
+    progressWidth: progressWidth,
+    barCornerRadius: barCornerRadius,
+    handleWidth: handleWidth,
+    hideChildren: hideChildren,
+    height: taskHeight,
+    barChildren: [],
+    styles: styles
+  });
+};
+var convertToMilestone = function convertToMilestone(task, index, dates, columnWidth, rowHeight, taskHeight, barCornerRadius, handleWidth, milestoneBackgroundColor, milestoneBackgroundSelectedColor) {
+  var x = taskXCoordinate(task.start, dates, columnWidth);
+  var y = taskYCoordinate(index, rowHeight, taskHeight);
+  var x1 = x - taskHeight * 0.5;
+  var x2 = x + taskHeight * 0.5;
+  var rotatedHeight = taskHeight / 1.414;
+  var styles = _objectSpread({
+    backgroundColor: milestoneBackgroundColor,
+    backgroundSelectedColor: milestoneBackgroundSelectedColor,
+    progressColor: '',
+    progressSelectedColor: ''
+  }, task.styles);
+  return _objectSpread(_objectSpread({}, task), {}, {
+    end: task.start,
+    x1: x1,
+    x2: x2,
+    y: y,
+    index: index,
+    progressX: 0,
+    progressWidth: 0,
+    barCornerRadius: barCornerRadius,
+    handleWidth: handleWidth,
+    typeInternal: task.type,
+    progress: 0,
+    height: rotatedHeight,
+    hideChildren: undefined,
+    barChildren: [],
+    styles: styles
+  });
+};
+var taskXCoordinate = function taskXCoordinate(xDate, dates, columnWidth) {
+  var _dates$index, _dates, _dates$index2;
+  var index = dates.findIndex(function (d) {
+    return (d === null || d === void 0 ? void 0 : d.getTime()) >= (xDate === null || xDate === void 0 ? void 0 : xDate.getTime());
+  }) - 1;
+  var remainderMillis = (xDate === null || xDate === void 0 ? void 0 : xDate.getTime()) - ((_dates$index = dates[index]) === null || _dates$index === void 0 ? void 0 : _dates$index.getTime());
+  var percentOfInterval = remainderMillis / (((_dates = dates[index + 1]) === null || _dates === void 0 ? void 0 : _dates.getTime()) - ((_dates$index2 = dates[index]) === null || _dates$index2 === void 0 ? void 0 : _dates$index2.getTime()));
+  var x = index * columnWidth + percentOfInterval * columnWidth;
+  return x;
+};
+var taskXCoordinateRTL = function taskXCoordinateRTL(xDate, dates, columnWidth) {
+  var x = taskXCoordinate(xDate, dates, columnWidth);
+  x += columnWidth;
+  return x;
+};
+var taskYCoordinate = function taskYCoordinate(index, rowHeight, taskHeight) {
+  var y = index * rowHeight + (rowHeight - taskHeight) / 2;
+  return y;
+};
+var progressWithByParams = function progressWithByParams(taskX1, taskX2, progress, rtl) {
+  var progressWidth = (taskX2 - taskX1) * progress * 0.01;
+  var progressX;
+  if (rtl) {
+    progressX = taskX2 - progressWidth;
+  } else {
+    progressX = taskX1;
+  }
+  return [progressWidth, progressX];
+};
+exports.progressWithByParams = progressWithByParams;
+var progressByProgressWidth = function progressByProgressWidth(progressWidth, barTask) {
+  var barWidth = barTask.x2 - barTask.x1;
+  var progressPercent = Math.round(progressWidth * 100 / barWidth);
+  if (progressPercent >= 100) return 100;else if (progressPercent <= 0) return 0;else return progressPercent;
+};
+exports.progressByProgressWidth = progressByProgressWidth;
+var progressByX = function progressByX(x, task) {
+  if (x >= task.x2) return 100;else if (x <= task.x1) return 0;else {
+    var barWidth = task.x2 - task.x1;
+    var progressPercent = Math.round((x - task.x1) * 100 / barWidth);
+    return progressPercent;
+  }
+};
+var progressByXRTL = function progressByXRTL(x, task) {
+  if (x >= task.x2) return 0;else if (x <= task.x1) return 100;else {
+    var barWidth = task.x2 - task.x1;
+    var progressPercent = Math.round((task.x2 - x) * 100 / barWidth);
+    return progressPercent;
+  }
+};
+var getProgressPoint = function getProgressPoint(progressX, taskY, taskHeight) {
+  var point = [progressX - 5, taskY + taskHeight, progressX + 5, taskY + taskHeight, progressX, taskY + taskHeight - 8.66];
+  return point.join(',');
+};
+exports.getProgressPoint = getProgressPoint;
+var startByX = function startByX(x, xStep, task) {
+  if (x >= task.x2 - task.handleWidth * 2) {
+    x = task.x2 - task.handleWidth * 2;
+  }
+  var steps = Math.round((x - task.x1) / xStep);
+  var additionalXValue = steps * xStep;
+  var newX = task.x1 + additionalXValue;
+  return newX;
+};
+var endByX = function endByX(x, xStep, task) {
+  if (x <= task.x1 + task.handleWidth * 2) {
+    x = task.x1 + task.handleWidth * 2;
+  }
+  var steps = Math.round((x - task.x2) / xStep);
+  var additionalXValue = steps * xStep;
+  var newX = task.x2 + additionalXValue;
+  return newX;
+};
+var moveByX = function moveByX(x, xStep, task) {
+  var steps = Math.round((x - task.x1) / xStep);
+  var additionalXValue = steps * xStep;
+  var newX1 = task.x1 + additionalXValue;
+  var newX2 = newX1 + task.x2 - task.x1;
+  return [newX1, newX2];
+};
+var dateByX = function dateByX(x, taskX, taskDate, xStep, timeStep) {
+  var newDate = new Date((x - taskX) / xStep * timeStep + taskDate.getTime());
+  newDate = new Date(newDate.getTime() + (newDate.getTimezoneOffset() - taskDate.getTimezoneOffset()) * 60000);
+  return newDate;
+};
+/**
+ * Method handles event in real time(mousemove) and on finish(mouseup)
+ */
+var handleTaskBySVGMouseEvent = function handleTaskBySVGMouseEvent(svgX, action, selectedTask, xStep, timeStep, initEventX1Delta, rtl) {
+  var result;
+  switch (selectedTask.type) {
+    case 'milestone':
+      result = handleTaskBySVGMouseEventForMilestone(svgX, action, selectedTask, xStep, timeStep, initEventX1Delta);
+      break;
+    default:
+      result = handleTaskBySVGMouseEventForBar(svgX, action, selectedTask, xStep, timeStep, initEventX1Delta, rtl);
+      break;
+  }
+  return result;
+};
+exports.handleTaskBySVGMouseEvent = handleTaskBySVGMouseEvent;
+var handleTaskBySVGMouseEventForBar = function handleTaskBySVGMouseEventForBar(svgX, action, selectedTask, xStep, timeStep, initEventX1Delta, rtl) {
+  var changedTask = _objectSpread({}, selectedTask);
+  var isChanged = false;
+  switch (action) {
+    case 'progress':
+      if (rtl) {
+        changedTask.progress = progressByXRTL(svgX, selectedTask);
+      } else {
+        changedTask.progress = progressByX(svgX, selectedTask);
+      }
+      isChanged = changedTask.progress !== selectedTask.progress;
+      if (isChanged) {
+        var _progressWithByParams3 = progressWithByParams(changedTask.x1, changedTask.x2, changedTask.progress, rtl),
+          _progressWithByParams4 = _slicedToArray(_progressWithByParams3, 2),
+          progressWidth = _progressWithByParams4[0],
+          progressX = _progressWithByParams4[1];
+        changedTask.progressWidth = progressWidth;
+        changedTask.progressX = progressX;
+      }
+      break;
+    case 'start':
+      {
+        var newX1 = startByX(svgX, xStep, selectedTask);
+        changedTask.x1 = newX1;
+        isChanged = changedTask.x1 !== selectedTask.x1;
+        if (isChanged) {
+          if (rtl) {
+            changedTask.end = dateByX(newX1, selectedTask.x1, selectedTask.end, xStep, timeStep);
+          } else {
+            changedTask.start = dateByX(newX1, selectedTask.x1, selectedTask.start, xStep, timeStep);
+          }
+          var _progressWithByParams5 = progressWithByParams(changedTask.x1, changedTask.x2, changedTask.progress, rtl),
+            _progressWithByParams6 = _slicedToArray(_progressWithByParams5, 2),
+            _progressWidth = _progressWithByParams6[0],
+            _progressX = _progressWithByParams6[1];
+          changedTask.progressWidth = _progressWidth;
+          changedTask.progressX = _progressX;
+        }
+        break;
+      }
+    case 'end':
+      {
+        var newX2 = endByX(svgX, xStep, selectedTask);
+        changedTask.x2 = newX2;
+        isChanged = changedTask.x2 !== selectedTask.x2;
+        if (isChanged) {
+          if (rtl) {
+            changedTask.start = dateByX(newX2, selectedTask.x2, selectedTask.start, xStep, timeStep);
+          } else {
+            changedTask.end = dateByX(newX2, selectedTask.x2, selectedTask.end, xStep, timeStep);
+          }
+          var _progressWithByParams7 = progressWithByParams(changedTask.x1, changedTask.x2, changedTask.progress, rtl),
+            _progressWithByParams8 = _slicedToArray(_progressWithByParams7, 2),
+            _progressWidth2 = _progressWithByParams8[0],
+            _progressX2 = _progressWithByParams8[1];
+          changedTask.progressWidth = _progressWidth2;
+          changedTask.progressX = _progressX2;
+        }
+        break;
+      }
+    case 'move':
+      {
+        var _moveByX = moveByX(svgX - initEventX1Delta, xStep, selectedTask),
+          _moveByX2 = _slicedToArray(_moveByX, 2),
+          newMoveX1 = _moveByX2[0],
+          newMoveX2 = _moveByX2[1];
+        isChanged = newMoveX1 !== selectedTask.x1;
+        if (isChanged) {
+          changedTask.start = dateByX(newMoveX1, selectedTask.x1, selectedTask.start, xStep, timeStep);
+          changedTask.end = dateByX(newMoveX2, selectedTask.x2, selectedTask.end, xStep, timeStep);
+          changedTask.x1 = newMoveX1;
+          changedTask.x2 = newMoveX2;
+          var _progressWithByParams9 = progressWithByParams(changedTask.x1, changedTask.x2, changedTask.progress, rtl),
+            _progressWithByParams10 = _slicedToArray(_progressWithByParams9, 2),
+            _progressWidth3 = _progressWithByParams10[0],
+            _progressX3 = _progressWithByParams10[1];
+          changedTask.progressWidth = _progressWidth3;
+          changedTask.progressX = _progressX3;
+        }
+        break;
+      }
+  }
+  return {
+    isChanged: isChanged,
+    changedTask: changedTask
+  };
+};
+var handleTaskBySVGMouseEventForMilestone = function handleTaskBySVGMouseEventForMilestone(svgX, action, selectedTask, xStep, timeStep, initEventX1Delta) {
+  var changedTask = _objectSpread({}, selectedTask);
+  var isChanged = false;
+  switch (action) {
+    case 'move':
+      {
+        var _moveByX3 = moveByX(svgX - initEventX1Delta, xStep, selectedTask),
+          _moveByX4 = _slicedToArray(_moveByX3, 2),
+          newMoveX1 = _moveByX4[0],
+          newMoveX2 = _moveByX4[1];
+        isChanged = newMoveX1 !== selectedTask.x1;
+        if (isChanged) {
+          changedTask.start = dateByX(newMoveX1, selectedTask.x1, selectedTask.start, xStep, timeStep);
+          changedTask.end = changedTask.start;
+          changedTask.x1 = newMoveX1;
+          changedTask.x2 = newMoveX2;
+        }
+        break;
+      }
+  }
+  return {
+    isChanged: isChanged,
+    changedTask: changedTask
+  };
+};

package/lib/schema-component/antd/gantt/helpers/date-helper.d.ts

@@ -0,0 +1,18 @@
+import { Task, ViewMode } from '../types/public-types';
+declare const DateTimeFormat: {
+    (locales?: string | string[], options?: Intl.DateTimeFormatOptions): Intl.DateTimeFormat;
+    new (locales?: string | string[], options?: Intl.DateTimeFormatOptions): Intl.DateTimeFormat;
+    supportedLocalesOf(locales: string | string[], options?: Intl.DateTimeFormatOptions): string[];
+};
+declare type DateTimeFormat = typeof DateTimeFormat;
+declare type DateHelperScales = 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond';
+export declare const getCachedDateTimeFormat: (locString: string | string[], opts?: any) => DateTimeFormat;
+export declare const addToDate: (date: Date, quantity: number, scale: DateHelperScales) => Date;
+export declare const startOfDate: (date: Date, scale: DateHelperScales) => Date;
+export declare const ganttDateRange: (tasks: Task[], viewMode: ViewMode, preStepsCount: number) => Date[];
+export declare const seedDates: (startDate: Date, endDate: Date, viewMode: ViewMode) => Date[];
+export declare const getLocaleMonth: (date: Date, locale: string) => any;
+export declare const getLocalDayOfWeek: (date: Date, locale: string, format?: 'long' | 'short' | 'narrow' | undefined) => any;
+export declare const getWeekNumberISO8601: (date: Date) => string;
+export declare const getDaysInMonth: (month: number, year: number) => number;
+export {};

package/lib/schema-component/antd/gantt/helpers/date-helper.js

@@ -0,0 +1,197 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.startOfDate = exports.seedDates = exports.getWeekNumberISO8601 = exports.getLocaleMonth = exports.getLocalDayOfWeek = exports.getDaysInMonth = exports.getCachedDateTimeFormat = exports.ganttDateRange = exports.addToDate = void 0;
+var _publicTypes = require("../types/public-types");
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+var DateTimeFormat = Intl.DateTimeFormat;
+//@ts-ignore
+var DateTimeFormatOptions = Intl.DateTimeFormatOptions;
+var intlDTCache = {};
+var getCachedDateTimeFormat = function getCachedDateTimeFormat(locString) {
+  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var key = JSON.stringify([locString, opts]);
+  var dtf = intlDTCache[key];
+  if (!dtf) {
+    dtf = new Intl.DateTimeFormat(locString, opts);
+    intlDTCache[key] = dtf;
+  }
+  return dtf;
+};
+exports.getCachedDateTimeFormat = getCachedDateTimeFormat;
+var addToDate = function addToDate(date, quantity, scale) {
+  var newDate = new Date(date.getFullYear() + (scale === 'year' ? quantity : 0), date.getMonth() + (scale === 'month' ? quantity : 0), date.getDate() + (scale === 'day' ? quantity : 0), date.getHours() + (scale === 'hour' ? quantity : 0), date.getMinutes() + (scale === 'minute' ? quantity : 0), date.getSeconds() + (scale === 'second' ? quantity : 0), date.getMilliseconds() + (scale === 'millisecond' ? quantity : 0));
+  return newDate;
+};
+exports.addToDate = addToDate;
+var startOfDate = function startOfDate(date, scale) {
+  var scores = ['millisecond', 'second', 'minute', 'hour', 'day', 'month', 'year'];
+  var shouldReset = function shouldReset(_scale) {
+    var maxScore = scores.indexOf(scale);
+    return scores.indexOf(_scale) <= maxScore;
+  };
+  var newDate = new Date(date === null || date === void 0 ? void 0 : date.getFullYear(), shouldReset('year') ? 0 : date.getMonth(), shouldReset('month') ? 1 : date.getDate(), shouldReset('day') ? 0 : date.getHours(), shouldReset('hour') ? 0 : date.getMinutes(), shouldReset('minute') ? 0 : date.getSeconds(), shouldReset('second') ? 0 : date.getMilliseconds());
+  return newDate;
+};
+exports.startOfDate = startOfDate;
+var ganttDateRange = function ganttDateRange(tasks, viewMode, preStepsCount) {
+  var _tasks$, _tasks$2;
+  var newStartDate = ((_tasks$ = tasks[0]) === null || _tasks$ === void 0 ? void 0 : _tasks$.start) || new Date();
+  var newEndDate = ((_tasks$2 = tasks[0]) === null || _tasks$2 === void 0 ? void 0 : _tasks$2.start) || new Date();
+  var _iterator = _createForOfIteratorHelper(tasks),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var task = _step.value;
+      if (task.start < newStartDate) {
+        newStartDate = task.start;
+      }
+      if (task.end > newEndDate) {
+        newEndDate = task.end;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  switch (viewMode) {
+    case _publicTypes.ViewMode.Year:
+      newStartDate = addToDate(newStartDate, -1, 'year');
+      newStartDate = startOfDate(newStartDate, 'year');
+      newEndDate = addToDate(newEndDate, 1, 'year');
+      newEndDate = startOfDate(newEndDate, 'year');
+      break;
+    case _publicTypes.ViewMode.QuarterYear:
+      newStartDate = addToDate(newStartDate, -3, 'month');
+      newStartDate = startOfDate(newStartDate, 'month');
+      newEndDate = addToDate(newEndDate, 3, 'year');
+      newEndDate = startOfDate(newEndDate, 'year');
+      break;
+    case _publicTypes.ViewMode.Month:
+      newStartDate = addToDate(newStartDate, -1 * preStepsCount, 'month');
+      newStartDate = startOfDate(newStartDate, 'month');
+      newEndDate = addToDate(newEndDate, 1, 'year');
+      newEndDate = startOfDate(newEndDate, 'year');
+      break;
+    case _publicTypes.ViewMode.Week:
+      newStartDate = startOfDate(newStartDate, 'day');
+      newStartDate = addToDate(getMonday(newStartDate), -7 * preStepsCount, 'day');
+      newEndDate = startOfDate(newEndDate, 'day');
+      newEndDate = addToDate(newEndDate, 1.5, 'month');
+      break;
+    case _publicTypes.ViewMode.Day:
+      newStartDate = startOfDate(newStartDate, 'day');
+      newStartDate = addToDate(newStartDate, -1 * preStepsCount, 'day');
+      newEndDate = startOfDate(newEndDate, 'day');
+      newEndDate = addToDate(newEndDate, 19, 'day');
+      break;
+    case _publicTypes.ViewMode.QuarterDay:
+      newStartDate = startOfDate(newStartDate, 'day');
+      newStartDate = addToDate(newStartDate, -1 * preStepsCount, 'day');
+      newEndDate = startOfDate(newEndDate, 'day');
+      newEndDate = addToDate(newEndDate, 66, 'hour'); // 24(1 day)*3 - 6
+      break;
+    case _publicTypes.ViewMode.HalfDay:
+      newStartDate = startOfDate(newStartDate, 'day');
+      newStartDate = addToDate(newStartDate, -1 * preStepsCount, 'day');
+      newEndDate = startOfDate(newEndDate, 'day');
+      newEndDate = addToDate(newEndDate, 108, 'hour'); // 24(1 day)*5 - 12
+      break;
+    case _publicTypes.ViewMode.Hour:
+      newStartDate = startOfDate(newStartDate, 'hour');
+      newStartDate = addToDate(newStartDate, -1 * preStepsCount, 'hour');
+      newEndDate = startOfDate(newEndDate, 'day');
+      newEndDate = addToDate(newEndDate, 1, 'day');
+      break;
+  }
+  return [newStartDate, newEndDate];
+};
+exports.ganttDateRange = ganttDateRange;
+var seedDates = function seedDates(startDate, endDate, viewMode) {
+  var currentDate = new Date(startDate);
+  var dates = [currentDate];
+  while (currentDate < endDate) {
+    switch (viewMode) {
+      case _publicTypes.ViewMode.Year:
+        currentDate = addToDate(currentDate, 1, 'year');
+        break;
+      case _publicTypes.ViewMode.QuarterYear:
+        currentDate = addToDate(currentDate, 3, 'month');
+        break;
+      case _publicTypes.ViewMode.Month:
+        currentDate = addToDate(currentDate, 1, 'month');
+        break;
+      case _publicTypes.ViewMode.Week:
+        currentDate = addToDate(currentDate, 7, 'day');
+        break;
+      case _publicTypes.ViewMode.Day:
+        currentDate = addToDate(currentDate, 1, 'day');
+        break;
+      case _publicTypes.ViewMode.HalfDay:
+        currentDate = addToDate(currentDate, 12, 'hour');
+        break;
+      case _publicTypes.ViewMode.QuarterDay:
+        currentDate = addToDate(currentDate, 6, 'hour');
+        break;
+      case _publicTypes.ViewMode.Hour:
+        currentDate = addToDate(currentDate, 1, 'hour');
+        break;
+    }
+    dates.push(currentDate);
+  }
+  return dates;
+};
+exports.seedDates = seedDates;
+var getLocaleMonth = function getLocaleMonth(date, locale) {
+  var bottomValue = getCachedDateTimeFormat(locale, {
+    month: 'long'
+    //@ts-ignore
+  }).format(date);
+  bottomValue = bottomValue.replace(bottomValue[0], bottomValue[0].toLocaleUpperCase());
+  return bottomValue;
+};
+exports.getLocaleMonth = getLocaleMonth;
+var getLocalDayOfWeek = function getLocalDayOfWeek(date, locale, format) {
+  var bottomValue = getCachedDateTimeFormat(locale, {
+    weekday: format
+    //@ts-ignore
+  }).format(date);
+  bottomValue = bottomValue.replace(bottomValue[0], bottomValue[0].toLocaleUpperCase());
+  return bottomValue;
+};
+/**
+ * Returns monday of current week
+ * @param date date for modify
+ */
+exports.getLocalDayOfWeek = getLocalDayOfWeek;
+var getMonday = function getMonday(date) {
+  var day = date.getDay();
+  var diff = date.getDate() - day + (day === 0 ? -6 : 1); // adjust when day is sunday
+  return new Date(date.setDate(diff));
+};
+var getWeekNumberISO8601 = function getWeekNumberISO8601(date) {
+  var tmpDate = new Date(date.valueOf());
+  var dayNumber = (tmpDate.getDay() + 6) % 7;
+  tmpDate.setDate(tmpDate.getDate() - dayNumber + 3);
+  var firstThursday = tmpDate.valueOf();
+  tmpDate.setMonth(0, 1);
+  if (tmpDate.getDay() !== 4) {
+    tmpDate.setMonth(0, 1 + (4 - tmpDate.getDay() + 7) % 7);
+  }
+  var weekNumber = (1 + Math.ceil((firstThursday - tmpDate.valueOf()) / 604800000)).toString();
+  if (weekNumber.length === 1) {
+    return "0".concat(weekNumber);
+  } else {
+    return weekNumber;
+  }
+};
+exports.getWeekNumberISO8601 = getWeekNumberISO8601;
+var getDaysInMonth = function getDaysInMonth(month, year) {
+  return new Date(year, month + 1, 0).getDate();
+};
+exports.getDaysInMonth = getDaysInMonth;

package/lib/schema-component/antd/gantt/helpers/other-helper.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { BarTask } from '../types/bar-task';
+import { Task } from '../types/public-types';
+export declare function isKeyboardEvent(event: React.MouseEvent | React.KeyboardEvent | React.FocusEvent): event is React.KeyboardEvent;
+export declare function isMouseEvent(event: React.MouseEvent | React.KeyboardEvent | React.FocusEvent): event is React.MouseEvent;
+export declare function isBarTask(task: Task | BarTask): task is BarTask;
+export declare function removeHiddenTasks(tasks: Task[]): Task[];
+export declare const sortTasks: (taskA: Task, taskB: Task) => 1 | 0 | -1;
+export declare const getYmd: (date: Date) => string;

package/lib/schema-component/antd/gantt/helpers/other-helper.js

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getYmd = void 0;
+exports.isBarTask = isBarTask;
+exports.isKeyboardEvent = isKeyboardEvent;
+exports.isMouseEvent = isMouseEvent;
+exports.removeHiddenTasks = removeHiddenTasks;
+exports.sortTasks = void 0;
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function isKeyboardEvent(event) {
+  return event.key !== undefined;
+}
+function isMouseEvent(event) {
+  return event.clientX !== undefined;
+}
+function isBarTask(task) {
+  return task.x1 !== undefined;
+}
+function removeHiddenTasks(tasks) {
+  var groupedTasks = tasks.filter(function (t) {
+    return t.hideChildren && t.type === 'project';
+  });
+  if (groupedTasks.length > 0) {
+    var _loop = function _loop() {
+      var groupedTask = groupedTasks[i];
+      var children = getChildren(tasks, groupedTask);
+      tasks = tasks.filter(function (t) {
+        return children.indexOf(t) === -1;
+      });
+    };
+    for (var i = 0; groupedTasks.length > i; i++) {
+      _loop();
+    }
+  }
+  return tasks;
+}
+function getChildren(taskList, task) {
+  var tasks = [];
+  if (task.type !== 'project') {
+    tasks = taskList.filter(function (t) {
+      return t.dependencies && t.dependencies.indexOf(task.id) !== -1;
+    });
+  } else {
+    tasks = taskList.filter(function (t) {
+      return t.project && t.project === task.id;
+    });
+  }
+  var taskChildren = [];
+  tasks.forEach(function (t) {
+    taskChildren.push.apply(taskChildren, _toConsumableArray(getChildren(taskList, t)));
+  });
+  tasks = tasks.concat(tasks, taskChildren);
+  return tasks;
+}
+var sortTasks = function sortTasks(taskA, taskB) {
+  var orderA = taskA.displayOrder || Number.MAX_VALUE;
+  var orderB = taskB.displayOrder || Number.MAX_VALUE;
+  if (orderA > orderB) {
+    return 1;
+  } else if (orderA < orderB) {
+    return -1;
+  } else {
+    return 0;
+  }
+};
+exports.sortTasks = sortTasks;
+var getYmd = function getYmd(date) {
+  return date.getFullYear() + '/' + "".concat(date.getMonth() + 1) + '/' + date.getDate();
+};
+exports.getYmd = getYmd;

package/lib/schema-component/antd/gantt/index.d.ts

@@ -0,0 +1,2 @@
+import { Gantt } from './components/gantt/gantt';
+export { Gantt };

package/lib/schema-component/antd/gantt/index.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Gantt", {
+  enumerable: true,
+  get: function get() {
+    return _gantt.Gantt;
+  }
+});
+var _action = require("../action");
+var _gantt = require("./components/gantt/gantt");
+var _Gantt = require("./Gantt.Designer");
+var _publicTypes = require("./types/public-types");
+var _Event = require("./components/gantt/Event");
+_gantt.Gantt.ActionBar = _action.ActionBar;
+_gantt.Gantt.ViewMode = _publicTypes.ViewMode;
+_gantt.Gantt.Designer = _Gantt.GanttDesigner;
+_gantt.Gantt.Event = _Event.Event;
+// const GanttV2 = Gantt;