gantt-task-react-powern 0.5.6 → 0.5.8

package/dist/index.modern.js

@@ -3504,60 +3504,141 @@ function getCriticalPaths(leafTasks) {
     computeCriticalPath(sortedTaskList[_i4], taskMap);
   }
 
-  var primaryLeaf;
-  var primaryDuration = 0;
+  var taskChainList = [];
 
   for (var _i5 = 0; _i5 < sortedTaskList.length; _i5++) {
-    var newDuration = taskMap[sortedTaskList[_i5]].end - taskMap[sortedTaskList[_i5]].task.start.getTime();
-
-    if (primaryDuration < newDuration) {
-      primaryLeaf = sortedTaskList[_i5];
-      primaryDuration = newDuration;
+    for (var _j = 0; _j < taskMap[sortedTaskList[_i5]].paths.length; _j++) {
+      taskChainList.push(taskMap[sortedTaskList[_i5]].paths[_j]);
     }
   }
 
-  var primaryPath = [];
+  if (taskChainList.length > 0) {
+    taskChainList.sort(function (a, b) {
+      return b.duration - a.duration;
+    });
+    var primaryLeaf = taskChainList[0].parent;
+    var primaryPath = [];
+
+    while (primaryLeaf !== undefined) {
+      primaryPath.push(taskMap[primaryLeaf].task);
 
-  while (primaryLeaf !== undefined) {
-    taskMap[primaryLeaf].excluded = true;
-    primaryPath.push(taskMap[primaryLeaf].task);
-    primaryLeaf = taskMap[primaryLeaf].next;
-  }
+      if (taskMap[primaryLeaf].paths.length === 0) {
+        primaryLeaf = undefined;
+        break;
+      }
+
+      var primaryDuration = taskMap[primaryLeaf].paths[0].duration;
+      var nextPath = taskMap[primaryLeaf].paths[0];
+
+      for (var _i6 = 1; _i6 < taskMap[primaryLeaf].paths.length; _i6++) {
+        var newDuration = taskMap[primaryLeaf].paths[_i6].duration;
 
-  var secondaryLeaf;
-  var secondaryDuration = 0;
+        if (newDuration > primaryDuration) {
+          nextPath = taskMap[primaryLeaf].paths[_i6];
+          primaryDuration = newDuration;
+        }
+      }
 
-  for (var _i6 = 0; _i6 < sortedTaskList.length; _i6++) {
-    if (taskMap[sortedTaskList[_i6]].excluded) continue;
+      nextPath.visited = true;
+      primaryLeaf = nextPath.task;
+    }
 
-    var _newDuration = taskMap[sortedTaskList[_i6]].end - taskMap[sortedTaskList[_i6]].task.start.getTime();
+    var secondaryLeaf = taskChainList[0].parent;
 
-    if (secondaryDuration < _newDuration) {
-      secondaryLeaf = sortedTaskList[_i6];
-      secondaryDuration = _newDuration;
+    for (var _i7 = 0; _i7 < taskChainList.length; _i7++) {
+      if (!taskChainList[_i7].visited) {
+        secondaryLeaf = taskChainList[_i7].parent;
+        break;
+      }
     }
-  }
 
-  var secondaryPath = [];
+    var secondaryPath = [];
+
+    while (secondaryLeaf !== undefined) {
+      secondaryPath.push(taskMap[secondaryLeaf].task);
+
+      if (taskMap[secondaryLeaf].paths.length === 0) {
+        secondaryLeaf = undefined;
+        break;
+      }
+
+      var secondaryDuration = taskMap[secondaryLeaf].paths[0].duration;
+      var _nextPath = taskMap[secondaryLeaf].paths[0];
+      if (_nextPath.visited) secondaryDuration = 0;
+
+      for (var _i8 = 1; _i8 < taskMap[secondaryLeaf].paths.length; _i8++) {
+        var _newDuration = taskMap[secondaryLeaf].paths[_i8].duration;
+
+        if (_newDuration > secondaryDuration && !taskMap[secondaryLeaf].paths[_i8].visited) {
+          _nextPath = taskMap[secondaryLeaf].paths[_i8];
+          secondaryDuration = _newDuration;
+        }
+      }
+
+      if (_nextPath.visited) {
+        break;
+      }
+
+      _nextPath.visited = true;
+      secondaryLeaf = _nextPath.task;
+    }
 
-  while (secondaryLeaf !== undefined) {
-    secondaryPath.push(taskMap[secondaryLeaf].task);
-    secondaryLeaf = taskMap[secondaryLeaf].next;
+    return [primaryPath, secondaryPath];
   }
 
-  return [primaryPath, secondaryPath];
+  return [[], []];
 }
 function computeCriticalPath(taskID, taskMap) {
   var task = taskMap[taskID].task;
   var dependents = taskMap[taskID].dependents;
+  taskMap[taskID].start = task.start.getTime();
   taskMap[taskID].end = task.end.getTime();
+  taskMap[taskID].paths = [];
 
   for (var j = 0; j < dependents.length; j++) {
-    var newDependentEnd = taskMap[dependents[j]].end;
+    var duration = taskMap[dependents[j]].task.end.getTime() - taskMap[dependents[j]].task.start.getTime() - Math.max(taskMap[taskID].end - taskMap[dependents[j]].task.start.getTime(), 0);
+    var paths = taskMap[dependents[j]].paths;
+
+    for (var k = 0; k < paths.length; k++) {
+      var totalDuration = taskMap[taskID].end - taskMap[taskID].start + duration + paths[k].duration;
+
+      if (taskMap[taskID].paths.length < 2) {
+        taskMap[taskID].paths.push({
+          duration: totalDuration,
+          task: dependents[j],
+          parent: taskID,
+          visited: false
+        });
+      } else if (totalDuration > taskMap[taskID].paths[0].duration) {
+        taskMap[taskID].paths[0].duration = totalDuration;
+        taskMap[taskID].paths[0].task = dependents[j];
+        taskMap[taskID].paths[0].parent = taskID;
+        taskMap[taskID].paths[0].visited = false;
+      } else if (totalDuration > taskMap[taskID].paths[1].duration) {
+        taskMap[taskID].paths[1].duration = totalDuration;
+        taskMap[taskID].paths[1].task = dependents[j];
+        taskMap[taskID].paths[1].parent = taskID;
+        taskMap[taskID].paths[1].visited = false;
+      }
+    }
 
-    if (newDependentEnd > taskMap[taskID].end) {
-      taskMap[taskID].next = dependents[j];
-      taskMap[taskID].end = newDependentEnd;
+    if (taskMap[taskID].paths.length < 2) {
+      taskMap[taskID].paths.push({
+        duration: duration,
+        task: dependents[j],
+        parent: taskID,
+        visited: false
+      });
+    } else if (duration > taskMap[taskID].paths[0].duration) {
+      taskMap[taskID].paths[0].duration = duration;
+      taskMap[taskID].paths[0].task = dependents[j];
+      taskMap[taskID].paths[0].parent = taskID;
+      taskMap[taskID].paths[0].visited = false;
+    } else if (duration > taskMap[taskID].paths[1].duration) {
+      taskMap[taskID].paths[1].duration = duration;
+      taskMap[taskID].paths[1].task = dependents[j];
+      taskMap[taskID].paths[1].parent = taskID;
+      taskMap[taskID].paths[1].visited = false;
     }
   }
 }
@@ -3594,12 +3675,12 @@ function colorPath(path, color, tasks, criticalPathType) {
     }
   }
 
-  var _loop = function _loop(_i7) {
+  var _loop = function _loop(_i9) {
     var taskFromTasks = void 0;
 
-    for (var _j = 0; _j < tasks.length; _j++) {
-      if (path[_i7].id === tasks[_j].id) {
-        taskFromTasks = tasks[_j];
+    for (var _j2 = 0; _j2 < tasks.length; _j2++) {
+      if (path[_i9].id === tasks[_j2].id) {
+        taskFromTasks = tasks[_j2];
         break;
       }
     }
@@ -3608,14 +3689,14 @@ function colorPath(path, color, tasks, criticalPathType) {
       var arrows = taskFromTasks.criticalPathArrows;
       if (!arrows) arrows = [];
       var arrow = arrows.find(function (arrow) {
-        return arrow.taskId === path[_i7 + 1].id;
+        return arrow.taskId === path[_i9 + 1].id;
       });
 
       if (arrow) {
         arrow.arrowColor = color;
         arrow.criticalPathType = criticalPathType;
       } else arrows.push({
-        taskId: path[_i7 + 1].id,
+        taskId: path[_i9 + 1].id,
         arrowColor: color,
         criticalPathType: criticalPathType
       });
@@ -3624,8 +3705,8 @@ function colorPath(path, color, tasks, criticalPathType) {
     }
   };
 
-  for (var _i7 = 0; _i7 + 1 < path.length; _i7++) {
-    _loop(_i7);
+  for (var _i9 = 0; _i9 + 1 < path.length; _i9++) {
+    _loop(_i9);
   }
 }
 var getParentWbs = function getParentWbs(wbs) {