gantt-task-react-powern 0.4.25 → 0.4.27

package/dist/index.modern.js

@@ -2746,58 +2746,109 @@ var Gantt = function Gantt(_ref) {
     }
   };
 
+  function topologicalOrderingHelper(taskID, taskMap, sortedTaskList) {
+    if (!taskMap[taskID]) return false;
+    if (taskMap[taskID].finished) return true;
+    if (taskMap[taskID].started) return false;
+    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);
+      if (!successVal) return false;
+    }
+    taskMap[taskID].finished = true;
+    sortedTaskList.push(taskID);
+    return true;
+  }
+
   function getCriticalPaths(leafTasks) {
-    var _leafTasks$reduce = leafTasks.reduce(function (_ref2, leafTask) {
-      var primaryPath = _ref2[0],
-          secondaryPath = _ref2[1],
-          primaryDuration = _ref2[2],
-          secondaryDuration = _ref2[3];
-      var newPath = criticalPath(leafTask, leafTasks);
-      var newDuration = computeDuration(newPath);
-      if (newDuration <= secondaryDuration) return [primaryPath, secondaryPath, primaryDuration, secondaryDuration];
-
-      if (newDuration > primaryDuration) {
-        var _primaryPath$;
-
-        if (((_primaryPath$ = primaryPath[0]) === null || _primaryPath$ === void 0 ? void 0 : _primaryPath$.id) !== newPath[0].id) return [newPath, primaryPath, newDuration, primaryDuration];else return [newPath, secondaryPath, newDuration, secondaryDuration];
-      } else {
-        var _primaryPath$2;
+    var taskMap = {};
 
-        if (((_primaryPath$2 = primaryPath[0]) === null || _primaryPath$2 === void 0 ? void 0 : _primaryPath$2.id) !== newPath[0].id) return [primaryPath, newPath, primaryDuration, newDuration];else return [primaryPath, secondaryPath, primaryDuration, secondaryDuration];
+    for (var i = 0; i < leafTasks.length; i++) {
+      taskMap[leafTasks[i].id] = {
+        task: leafTasks[i]
+      };
+    }
+
+    for (var _i = 0; _i < leafTasks.length; _i++) {
+      taskMap[leafTasks[_i].id].dependents = [];
+    }
+
+    for (var _i2 = 0; _i2 < leafTasks.length; _i2++) {
+      var task = leafTasks[_i2];
+      if (task.dependencies) for (var j = 0; j < task.dependencies.length; j++) {
+        taskMap[task.dependencies[j]].dependents.push(task.id);
       }
-    }, [[], [], 0, 0]),
-        primaryPath = _leafTasks$reduce[0],
-        secondaryPath = _leafTasks$reduce[1];
+    }
 
-    return [primaryPath, secondaryPath];
-  }
+    var sortedTaskList = [];
 
-  function computeDuration(path) {
-    return path.length ? path[path.length - 1].end.getTime() - path[0].start.getTime() : 0;
-  }
+    for (var _i3 = 0; _i3 < leafTasks.length; _i3++) {
+      var successVal = topologicalOrderingHelper(leafTasks[_i3].id, taskMap, sortedTaskList);
+      if (!successVal) return [[], []];
+    }
 
-  function criticalPath(task, tasks) {
-    var _task$dependencies;
+    for (var _i4 = sortedTaskList.length - 1; _i4 >= 0; _i4--) {
+      computeCriticalPath(sortedTaskList[_i4], taskMap);
+    }
 
-    if (!task) {
-      return [];
+    var primaryLeaf;
+    var primaryDuration = 0;
+
+    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;
+      }
     }
 
-    if (!task.dependencies) return [task];
+    var primaryPath = [];
 
-    var _task$dependencies$re = (_task$dependencies = task.dependencies) === null || _task$dependencies === void 0 ? void 0 : _task$dependencies.reduce(function (_ref3, dependencyTaskId) {
-      var longestPath = _ref3[0],
-          longestDuration = _ref3[1];
-      var dependencyTask = tasks.find(function (otherTask) {
-        return otherTask.id === dependencyTaskId;
-      });
-      var dependencyPath = criticalPath(dependencyTask, tasks);
-      var dependencyDuration = computeDuration(dependencyPath);
-      if (dependencyDuration > longestDuration) return [dependencyPath, dependencyDuration];else return [longestPath, longestDuration];
-    }, [[], 0]),
-        longestPath = _task$dependencies$re[0];
+    while (primaryLeaf) {
+      taskMap[primaryLeaf].excluded = true;
+      primaryPath.push(taskMap[primaryLeaf].task);
+      primaryLeaf = taskMap[primaryLeaf].next;
+    }
+
+    var secondaryLeaf;
+    var secondaryDuration = 0;
+
+    for (var _i6 = 0; _i6 < sortedTaskList.length; _i6++) {
+      if (taskMap[sortedTaskList[_i6]].excluded) continue;
 
-    return [].concat(longestPath, [task]);
+      var _newDuration = taskMap[sortedTaskList[_i6]].end - taskMap[sortedTaskList[_i6]].task.start.getTime();
+
+      if (secondaryDuration < _newDuration) {
+        secondaryLeaf = sortedTaskList[_i6];
+        secondaryDuration = _newDuration;
+      }
+    }
+
+    var secondaryPath = [];
+
+    while (secondaryLeaf) {
+      secondaryPath.push(taskMap[secondaryLeaf].task);
+      secondaryLeaf = taskMap[secondaryLeaf].next;
+    }
+
+    return [primaryPath, secondaryPath];
+  }
+
+  function computeCriticalPath(taskID, taskMap) {
+    var task = taskMap[taskID].task;
+    var dependents = taskMap[taskID].dependents;
+    taskMap[taskID].end = task.end.getTime();
+
+    for (var j = 0; j < dependents.length; j++) {
+      var newDependentEnd = taskMap[dependents[j]].end;
+
+      if (newDependentEnd > taskMap[taskID].end) {
+        taskMap[taskID].next = dependents[j];
+        taskMap[taskID].end = newDependentEnd;
+      }
+    }
   }
 
   function uncolorAll(tasks) {
@@ -2836,21 +2887,21 @@ var Gantt = function Gantt(_ref) {
       }
     }
 
-    var _loop = function _loop(_i) {
-      var arrows = path[_i].criticalPathArrows;
+    var _loop = function _loop(_i7) {
+      var arrows = path[_i7].criticalPathArrows;
       if (!arrows) arrows = [];
       var arrow = arrows.find(function (arrow) {
-        return arrow.taskId === path[_i + 1].id;
+        return arrow.taskId === path[_i7 + 1].id;
       });
       if (arrow) arrow.arrowColor = color;else arrows.push({
-        taskId: path[_i + 1].id,
+        taskId: path[_i7 + 1].id,
         arrowColor: color
       });
-      path[_i].criticalPathArrows = arrows;
+      path[_i7].criticalPathArrows = arrows;
     };
 
-    for (var _i = 0; _i + 1 < path.length; _i++) {
-      _loop(_i);
+    for (var _i7 = 0; _i7 + 1 < path.length; _i7++) {
+      _loop(_i7);
     }
   }