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

package/es/schema-component/antd/gantt/components/task-item/project/project.js

@@ -0,0 +1,31 @@
+import { cx } from '@emotion/css';
+import React from 'react';
+import { projectBackground, projectWrapper } from './style';
+export var Project = function Project(_ref) {
+  var task = _ref.task,
+    isSelected = _ref.isSelected;
+  var barColor = isSelected ? task.styles.backgroundSelectedColor : task.styles.backgroundColor;
+  var processColor = isSelected ? task.styles.progressSelectedColor : task.styles.progressColor;
+  var projectWith = task.x2 - task.x1;
+  return /*#__PURE__*/React.createElement("g", {
+    tabIndex: 0,
+    className: cx(projectWrapper)
+  }, /*#__PURE__*/React.createElement("rect", {
+    fill: task.color || barColor,
+    x: task.x1,
+    width: projectWith,
+    y: task.y,
+    height: task.height,
+    rx: task.barCornerRadius,
+    ry: task.barCornerRadius,
+    className: cx(projectBackground)
+  }), /*#__PURE__*/React.createElement("rect", {
+    x: task.progressX,
+    width: task.progressWidth,
+    y: task.y,
+    height: task.height,
+    ry: task.barCornerRadius,
+    rx: task.barCornerRadius,
+    fill: task.color || processColor
+  }));
+};

package/es/schema-component/antd/gantt/components/task-item/project/style.d.ts

@@ -0,0 +1,3 @@
+export declare const projectWrapper: string;
+export declare const projectBackground: string;
+export declare const projectTop: string;

package/es/schema-component/antd/gantt/components/task-item/project/style.js

@@ -0,0 +1,6 @@
+var _templateObject, _templateObject2, _templateObject3;
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+import { css } from '@emotion/css';
+export var projectWrapper = css(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  cursor: pointer;\n  outline: none;\n"])));
+export var projectBackground = css(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  user-select: none;\n  opacity: 0.6;\n"])));
+export var projectTop = css(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  user-select: none;\n"])));

package/es/schema-component/antd/gantt/components/task-item/style.d.ts

@@ -0,0 +1,3 @@
+export declare const barLabel: string;
+export declare const projectLabel: string;
+export declare const barLabelOutside: string;

package/es/schema-component/antd/gantt/components/task-item/style.js

@@ -0,0 +1,6 @@
+var _templateObject, _templateObject2, _templateObject3;
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+import { css } from '@emotion/css';
+export var barLabel = css(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  fill: #fff;\n  text-anchor: middle;\n  font-weight: 400;\n  dominant-baseline: central;\n  -webkit-touch-callout: none;\n  -webkit-user-select: none;\n  -moz-user-select: none;\n  -ms-user-select: none;\n  user-select: none;\n  pointer-events: none;\n"])));
+export var projectLabel = css(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  fill: #130d0d;\n  font-weight: 500;\n  font-size: 0.9em;\n  dominant-baseline: central;\n  -webkit-touch-callout: none;\n  -webkit-user-select: none;\n  -moz-user-select: none;\n  -ms-user-select: none;\n  user-select: none;\n  pointer-events: none;\n"])));
+export var barLabelOutside = css(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  fill: #555;\n  text-anchor: start;\n  -webkit-touch-callout: none;\n  -webkit-user-select: none;\n  -moz-user-select: none;\n  -ms-user-select: none;\n  user-select: none;\n  pointer-events: none;\n"])));

package/es/schema-component/antd/gantt/components/task-item/task-item.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { BarTask } from '../../types/bar-task';
+import { GanttContentMoveAction } from '../../types/gantt-task-actions';
+export declare type TaskItemProps = {
+    task: BarTask;
+    arrowIndent: number;
+    taskHeight: number;
+    isProgressChangeable: boolean;
+    isDateChangeable: boolean;
+    isDelete: boolean;
+    isSelected: boolean;
+    rtl: boolean;
+    onEventStart: (action: GanttContentMoveAction, selectedTask: BarTask, event?: React.MouseEvent | React.KeyboardEvent) => any;
+};
+export declare const TaskItem: React.FC<TaskItemProps>;

package/es/schema-component/antd/gantt/components/task-item/task-item.js

@@ -0,0 +1,105 @@
+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); }
+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; }
+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); }
+import { cx } from '@emotion/css';
+import React, { useEffect, useRef, useState } from 'react';
+import { getYmd } from '../../helpers/other-helper';
+import { Bar } from './bar/bar';
+import { BarSmall } from './bar/bar-small';
+import { Milestone } from './milestone/milestone';
+import { Project } from './project/project';
+import { barLabel, barLabelOutside, projectLabel } from './style';
+export var TaskItem = function TaskItem(props) {
+  var _props = _objectSpread({}, props),
+    task = _props.task,
+    arrowIndent = _props.arrowIndent,
+    isDelete = _props.isDelete,
+    taskHeight = _props.taskHeight,
+    isSelected = _props.isSelected,
+    rtl = _props.rtl,
+    onEventStart = _props.onEventStart;
+  var textRef = useRef(null);
+  var _useState = useState( /*#__PURE__*/React.createElement("div", null)),
+    _useState2 = _slicedToArray(_useState, 2),
+    taskItem = _useState2[0],
+    setTaskItem = _useState2[1];
+  var _useState3 = useState(true),
+    _useState4 = _slicedToArray(_useState3, 2),
+    isTextInside = _useState4[0],
+    setIsTextInside = _useState4[1];
+  var isProjectBar = task.typeInternal === 'project';
+  useEffect(function () {
+    switch (task.typeInternal) {
+      case 'milestone':
+        setTaskItem( /*#__PURE__*/React.createElement(Milestone, _objectSpread({}, props)));
+        break;
+      case 'project':
+        setTaskItem( /*#__PURE__*/React.createElement(Project, _objectSpread({}, props)));
+        break;
+      case 'smalltask':
+        setTaskItem( /*#__PURE__*/React.createElement(BarSmall, _objectSpread({}, props)));
+        break;
+      default:
+        setTaskItem( /*#__PURE__*/React.createElement(Bar, _objectSpread({}, props)));
+        break;
+    }
+  }, [task, isSelected]);
+  useEffect(function () {
+    if (textRef.current) {
+      setIsTextInside(textRef.current.getBBox().width < task.x2 - task.x1);
+    }
+  }, [textRef, task]);
+  var getX = function getX() {
+    var width = task.x2 - task.x1;
+    var hasChild = task.barChildren.length > 0;
+    if (isTextInside) {
+      return task.x1 + width * 0.5;
+    }
+    if (rtl && textRef.current) {
+      return task.x1 - textRef.current.getBBox().width - arrowIndent * +hasChild - arrowIndent * 0.2;
+    } else {
+      return task.x1 + width + arrowIndent * +hasChild + arrowIndent * 0.2;
+    }
+  };
+  return /*#__PURE__*/React.createElement("g", {
+    onKeyDown: function onKeyDown(e) {
+      switch (e.key) {
+        case 'Delete':
+          {
+            if (isDelete) onEventStart('delete', task, e);
+            break;
+          }
+      }
+      e.stopPropagation();
+    },
+    onMouseEnter: function onMouseEnter(e) {
+      onEventStart('mouseenter', task, e);
+    },
+    onMouseLeave: function onMouseLeave(e) {
+      onEventStart('mouseleave', task, e);
+    },
+    onDoubleClick: function onDoubleClick(e) {
+      onEventStart('dblclick', task, e);
+    },
+    onClick: function onClick(e) {
+      onEventStart('click', task, e);
+    },
+    onFocus: function onFocus() {
+      onEventStart('select', task);
+    }
+  }, taskItem, /*#__PURE__*/React.createElement("text", {
+    x: isProjectBar ? task.x1 : getX(),
+    y: isProjectBar ? task.y - 8 : isTextInside ? task.y + taskHeight * 0.5 : task.y + taskHeight * 0.65,
+    className: isProjectBar ? cx(projectLabel) : isTextInside ? cx(barLabel) : cx(barLabel) && cx(barLabelOutside),
+    ref: textRef
+  }, isProjectBar ? "".concat(task.name, ": ").concat(getYmd(task.start), " ~ ").concat(getYmd(task.end)) : task.name));
+};

package/es/schema-component/antd/gantt/context.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+export declare const CalendarContext: import("react").Context<any>;
+export declare const DeleteEventContext: import("react").Context<any>;

package/es/schema-component/antd/gantt/context.js

@@ -0,0 +1,4 @@
+import { createContext } from 'react';
+// export const GanttToolbarContext = createContext<any>(null);
+export var CalendarContext = /*#__PURE__*/createContext(null);
+export var DeleteEventContext = /*#__PURE__*/createContext(null);

package/es/schema-component/antd/gantt/helpers/bar-helper.d.ts

@@ -0,0 +1,14 @@
+import { Task } from '../types/public-types';
+import { BarTask } from '../types/bar-task';
+import { BarMoveAction } from '../types/gantt-task-actions';
+export declare const convertToBarTasks: (tasks: Task[], dates: Date[], columnWidth: number, rowHeight: number, taskHeight: number, barCornerRadius: number, handleWidth: number, rtl: boolean, barProgressColor: string, barProgressSelectedColor: string, barBackgroundColor: string, barBackgroundSelectedColor: string, projectProgressColor: string, projectProgressSelectedColor: string, projectBackgroundColor: string, projectBackgroundSelectedColor: string, milestoneBackgroundColor: string, milestoneBackgroundSelectedColor: string) => BarTask[];
+export declare const progressWithByParams: (taskX1: number, taskX2: number, progress: number, rtl: boolean) => number[];
+export declare const progressByProgressWidth: (progressWidth: number, barTask: BarTask) => number;
+export declare const getProgressPoint: (progressX: number, taskY: number, taskHeight: number) => string;
+/**
+ * Method handles event in real time(mousemove) and on finish(mouseup)
+ */
+export declare const handleTaskBySVGMouseEvent: (svgX: number, action: BarMoveAction, selectedTask: BarTask, xStep: number, timeStep: number, initEventX1Delta: number, rtl: boolean) => {
+    isChanged: boolean;
+    changedTask: BarTask;
+};

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

@@ -0,0 +1,329 @@
+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); }
+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; }
+export 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;
+};
+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;
+};
+export 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];
+};
+export 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;
+};
+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;
+  }
+};
+export 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(',');
+};
+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)
+ */
+export 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;
+};
+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/es/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 {};