gantt-task-react-powern 0.4.85 → 0.4.87

package/dist/index.modern.js

@@ -1357,22 +1357,12 @@ var Arrow = function Arrow(_ref) {
       rowHeight = _ref.rowHeight,
       taskHeight = _ref.taskHeight,
       arrowIndent = _ref.arrowIndent,
-      rtl = _ref.rtl,
-      arrowColor = _ref.arrowColor;
-  var path;
-  var trianglePoints;
+      arrowColor = _ref.arrowColor,
+      dependencyType = _ref.dependencyType;
 
-  if (rtl) {
-    var _drownPathAndTriangle = drownPathAndTriangleRTL(taskFrom, taskTo, rowHeight, taskHeight, arrowIndent);
-
-    path = _drownPathAndTriangle[0];
-    trianglePoints = _drownPathAndTriangle[1];
-  } else {
-    var _drownPathAndTriangle2 = drownPathAndTriangle(taskFrom, taskTo, rowHeight, taskHeight, arrowIndent);
-
-    path = _drownPathAndTriangle2[0];
-    trianglePoints = _drownPathAndTriangle2[1];
-  }
+  var _drawPathAndTriangle = drawPathAndTriangle(taskFrom, taskTo, rowHeight, taskHeight, arrowIndent, dependencyType),
+      path = _drawPathAndTriangle[0],
+      trianglePoints = _drawPathAndTriangle[1];
 
   return React.createElement("g", {
     className: "arrow"
@@ -1387,35 +1377,84 @@ var Arrow = function Arrow(_ref) {
   }));
 };
 
-var drownPathAndTriangle = function drownPathAndTriangle(taskFrom, taskTo, rowHeight, taskHeight, arrowIndent) {
-  var taskToStart, taskFromEnd;
+var drawPathAndTriangle = function drawPathAndTriangle(taskFrom, taskTo, rowHeight, taskHeight, arrowIndent, dependencyType) {
+  var indexCompare = taskFrom.index > taskTo.index ? -1 : 1;
+  var taskToEndY = taskTo.y + taskHeight / 2;
+  var verticalOffset = indexCompare * (rowHeight / 2);
+
+  var minX = function minX(t) {
+    if (t.x1 && t.actualx1) {
+      return Math.min(t.x1, t.actualx1);
+    } else if (t.x1) {
+      return t.x1;
+    } else if (t.actualx1) {
+      return t.actualx1;
+    } else {
+      return 0;
+    }
+  };
 
-  if (taskTo.x1 > 0 && taskTo.actualx1 > 0) {
-    taskToStart = Math.min(taskTo.x1, taskTo.actualx1);
-  } else if (taskTo.x1 > 0) taskToStart = taskTo.x1;else if (taskTo.actualx1 > 0) taskToStart = taskTo.actualx1;else taskToStart = 0;
+  var maxX = function maxX(t) {
+    return Math.max(t.x2 || 0, t.actualx2 || 0);
+  };
 
-  if (taskFrom.x2 > 0 && taskFrom.actualx2 > 0) {
-    taskFromEnd = Math.max(taskFrom.x2, taskFrom.actualx2);
-  } else if (taskFrom.x2 > 0) taskFromEnd = taskFrom.x2;else if (taskFrom.actualx2 > 0) taskFromEnd = taskFrom.actualx2;else taskFromEnd = 0;
+  var fromPoint, toPoint;
 
-  var indexCompare = taskFrom.index > taskTo.index ? -1 : 1;
-  var taskToEndPosition = taskTo.y + taskHeight / 2;
-  var taskFromEndPosition = taskFromEnd + arrowIndent * 2;
-  var taskFromHorizontalOffsetValue = taskFromEndPosition < taskToStart ? "" : "H " + (taskToStart - arrowIndent);
-  var taskToHorizontalOffsetValue = taskFromEndPosition > taskToStart ? arrowIndent : taskToStart - taskFromEnd - arrowIndent;
-  var path = "M " + taskFromEnd + " " + (taskFrom.y + taskHeight / 2) + " \n  h " + arrowIndent + " \n  v " + indexCompare * rowHeight / 2 + " \n  " + taskFromHorizontalOffsetValue + "\n  V " + taskToEndPosition + " \n  h " + taskToHorizontalOffsetValue;
-  var trianglePoints = taskToStart + "," + taskToEndPosition + " \n  " + (taskToStart - 5) + "," + (taskToEndPosition - 5) + " \n  " + (taskToStart - 5) + "," + (taskToEndPosition + 5);
-  return [path, trianglePoints];
-};
+  switch (dependencyType) {
+    case "SS":
+      fromPoint = minX(taskFrom);
+      toPoint = minX(taskTo);
+      break;
+
+    case "SF":
+      fromPoint = minX(taskFrom);
+      toPoint = maxX(taskTo);
+      break;
+
+    case "FS":
+      fromPoint = maxX(taskFrom);
+      toPoint = minX(taskTo);
+      break;
+
+    case "FF":
+      fromPoint = maxX(taskFrom);
+      toPoint = maxX(taskTo);
+      break;
+  }
+
+  var arrowPoints = function arrowPoints(x, y, right) {
+    if (right === void 0) {
+      right = true;
+    }
+
+    return right ? x + "," + y + " " + (x - 5) + "," + (y - 5) + " " + (x - 5) + "," + (y + 5) : x + "," + y + " " + (x + 5) + "," + (y - 5) + " " + (x + 5) + "," + (y + 5);
+  };
+
+  var path;
+  var trianglePoints;
+
+  switch (dependencyType) {
+    case "SS":
+      path = "M " + fromPoint + " " + (taskFrom.y + taskHeight / 2) + "\n              H " + (fromPoint + Math.min(toPoint - fromPoint, 0) - 2 * arrowIndent) + "\n              V " + taskToEndY + "\n              H " + (toPoint - 5);
+      trianglePoints = arrowPoints(toPoint, taskToEndY, true);
+      break;
+
+    case "SF":
+      path = "M " + fromPoint + " " + (taskFrom.y + taskHeight / 2) + "\n              H " + (fromPoint - 2 * arrowIndent) + "\n              V " + (taskFrom.y + taskHeight / 2 + verticalOffset) + "\n                " + (fromPoint - toPoint > 4 * arrowIndent ? "" : "H " + (toPoint + 2 * arrowIndent)) + "\n              V " + taskToEndY + "\n              H " + (toPoint + 5);
+      trianglePoints = arrowPoints(toPoint, taskToEndY, false);
+      break;
+
+    case "FS":
+      path = "M " + fromPoint + " " + (taskFrom.y + taskHeight / 2) + "\n              H " + (fromPoint + 2 * arrowIndent) + "\n              V " + (taskFrom.y + taskHeight / 2 + verticalOffset) + "\n                " + (toPoint - fromPoint > 4 * arrowIndent ? "" : "H " + (toPoint - 2 * arrowIndent)) + "\n              V " + taskToEndY + "\n              H " + (toPoint - 5);
+      trianglePoints = arrowPoints(toPoint, taskToEndY, true);
+      break;
+
+    case "FF":
+      path = "M " + fromPoint + " " + (taskFrom.y + taskHeight / 2) + "\n              H " + (fromPoint + Math.max(toPoint - fromPoint, 0) + 2 * arrowIndent) + "\n              V " + taskToEndY + "\n              H " + (toPoint + 5);
+      trianglePoints = arrowPoints(toPoint, taskToEndY, false);
+      break;
+  }
 
-var drownPathAndTriangleRTL = function drownPathAndTriangleRTL(taskFrom, taskTo, rowHeight, taskHeight, arrowIndent) {
-  var indexCompare = taskFrom.index > taskTo.index ? -1 : 1;
-  var taskToEndPosition = taskTo.y + taskHeight / 2;
-  var taskFromEndPosition = taskFrom.x1 - arrowIndent * 2;
-  var taskFromHorizontalOffsetValue = taskFromEndPosition > taskTo.x2 ? "" : "H " + (taskTo.x2 + arrowIndent);
-  var taskToHorizontalOffsetValue = taskFromEndPosition < taskTo.x2 ? -arrowIndent : taskTo.x2 - taskFrom.x1 + arrowIndent;
-  var path = "M " + taskFrom.x1 + " " + (taskFrom.y + taskHeight / 2) + " \n  h " + -arrowIndent + " \n  v " + indexCompare * rowHeight / 2 + " \n  " + taskFromHorizontalOffsetValue + "\n  V " + taskToEndPosition + " \n  h " + taskToHorizontalOffsetValue;
-  var trianglePoints = taskTo.x2 + "," + taskToEndPosition + " \n  " + (taskTo.x2 + 5) + "," + (taskToEndPosition + 5) + " \n  " + (taskTo.x2 + 5) + "," + (taskToEndPosition - 5);
   return [path, trianglePoints];
 };
 
@@ -1428,9 +1467,16 @@ var convertToBarTasks = function convertToBarTasks(tasks, dates, columnWidth, ro
 
     var _loop = function _loop(j) {
       var dependence = barTasks.findIndex(function (value) {
-        return value.id === dependencies[j];
+        return value.id === dependencies[j].id;
       });
-      if (dependence !== -1 && task.start.getTime() > 0 && task.end.getTime() > 0) barTasks[dependence].barChildren.push(task);
+
+      if (dependence !== -1 && task.start.getTime() > 0 && task.end.getTime() > 0) {
+        var barchild = _extends({}, task, {
+          dependencyType: dependencies[j].type
+        });
+
+        barTasks[dependence].barChildren.push(barchild);
+      }
     };
 
     for (var j = 0; j < dependencies.length; j++) {
@@ -1522,7 +1568,7 @@ var convertToBar = function convertToBar(task, index, dates, columnWidth, rowHei
 };
 
 var convertToMilestone = function convertToMilestone(task, index, dates, columnWidth, rowHeight, taskHeight, barCornerRadius, handleWidth, milestoneBackgroundColor, milestoneBackgroundSelectedColor) {
-  var x = task.start && task.end ? taskXCoordinate(task.end, dates, columnWidth) : 0;
+  var x = task.start && task.end ? taskXCoordinate(task.start, dates, columnWidth) : 0;
   var y = taskYCoordinate(index, rowHeight, taskHeight);
   var x1 = task.start && task.end ? x - taskHeight * 0.5 : 0;
   var x2 = task.start && task.end ? x + taskHeight * 0.5 : 0;
@@ -1840,7 +1886,10 @@ function getChildren(taskList, task) {
 
   if (task.type !== "project") {
     tasks = taskList.filter(function (t) {
-      return t.dependencies && t.dependencies.indexOf(task.id) !== -1;
+      return t.dependencies && t.dependencies.map(function (_ref) {
+        var id = _ref.id;
+        return id;
+      }).indexOf(task.id) !== -1;
     });
   } else {
     tasks = taskList.filter(function (t) {
@@ -2545,9 +2594,9 @@ var TaskGanttContent = function TaskGanttContent(_ref) {
               taskFrom: task,
               taskTo: tasks[child.index],
               rowHeight: rowHeight,
+              dependencyType: child.dependencyType,
               taskHeight: taskHeight,
               arrowIndent: arrowIndent,
-              rtl: rtl,
               arrowColor: (criticalTask === null || criticalTask === void 0 ? void 0 : criticalTask.arrowColor) || "#808080"
             });
           }
@@ -2569,21 +2618,6 @@ var TaskGanttContent = function TaskGanttContent(_ref) {
   }, tasks.map(function (_task) {
     var task = _task.start.getTime() > 0 && _task.end.getTime() > 0 || _task.actualStart.getTime() > 0 && _task.actualEnd.getTime() > 0 ? _task : undefined;
 
-    if (!task && _task.typeInternal === "milestone") {
-      return React.createElement(Milestone, {
-        task: _task,
-        arrowIndent: arrowIndent,
-        taskHeight: taskHeight,
-        isProgressChangeable: false,
-        isDateChangeable: false,
-        isDelete: !_task.isDisabled,
-        onEventStart: function onEventStart() {},
-        key: _task.id,
-        isSelected: !!selectedTask && _task.id === selectedTask.id,
-        rtl: rtl
-      });
-    }
-
     if (!task) {
       return React.createElement("g", {
         key: _task.id,
@@ -3281,7 +3315,7 @@ function topologicalOrderingHelper(taskID, taskMap, sortedTaskList) {
   taskMap[taskID].started = true;
   var task = taskMap[taskID].task;
   if (task.dependencies) for (var i = 0; i < task.dependencies.length; i++) {
-    var successVal = topologicalOrderingHelper(task.dependencies[i], taskMap, sortedTaskList);
+    var successVal = topologicalOrderingHelper(task.dependencies[i].id, taskMap, sortedTaskList);
     if (!successVal) return false;
   }
   taskMap[taskID].finished = true;
@@ -3313,7 +3347,7 @@ function getCriticalPaths(leafTasks) {
     if (task.dependencies) for (var j = 0; j < task.dependencies.length; j++) {
       var _taskMap$task$depende;
 
-      (_taskMap$task$depende = taskMap[task.dependencies[j]]) === null || _taskMap$task$depende === void 0 ? void 0 : _taskMap$task$depende.dependents.push(task.id);
+      (_taskMap$task$depende = taskMap[task.dependencies[j].id]) === null || _taskMap$task$depende === void 0 ? void 0 : _taskMap$task$depende.dependents.push(task.id);
     }
   }