gantt-task-react-powern 0.4.84 → 0.4.86

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;
-
-  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);
+      arrowColor = _ref.arrowColor,
+      dependencyType = _ref.dependencyType;
 
-    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,76 @@ 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);
 
-  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 minX = function minX(t) {
+    return Math.min(t.x1 || 0, t.actualx1 || 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 maxX = function maxX(t) {
+    return Math.max(t.x2 || 0, t.actualx2 || 0);
+  };
 
-  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];
-};
+  var fromPoint, toPoint;
+
+  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 +1459,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++) {
@@ -2545,9 +2583,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"
             });
           }
@@ -2889,6 +2927,8 @@ var Gantt = function Gantt(_ref) {
         primaryPath = _getCriticalPaths[0],
         secondaryPath = _getCriticalPaths[1];
 
+    console.debug(primaryPath, secondaryPath);
+
     if (leafTasks.length > 0 && primaryPath.length === 0 && secondaryPath.length === 0) {
       setHasCircularDeps(true);
     } else {
@@ -3266,7 +3306,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;
@@ -3298,7 +3338,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);
     }
   }