gantt-task-react-powern 0.4.24 → 0.4.26

package/dist/index.modern.js

@@ -1877,7 +1877,8 @@ var Project = function Project(_ref) {
     height: task.height,
     rx: task.barCornerRadius,
     ry: task.barCornerRadius,
-    className: styles$8.projectBackground
+    className: styles$8.projectBackground,
+    stroke: task.styles.criticalPathColor
   }), React.createElement("rect", {
     x: task.progressX,
     width: task.progressWidth,
@@ -1885,7 +1886,8 @@ var Project = function Project(_ref) {
     height: task.height,
     ry: task.barCornerRadius,
     rx: task.barCornerRadius,
-    fill: processColor
+    fill: processColor,
+    stroke: task.styles.criticalPathColor
   }), React.createElement("rect", {
     fill: barColor,
     x: task.x1,
@@ -1894,15 +1896,18 @@ var Project = function Project(_ref) {
     height: task.height / 2,
     rx: task.barCornerRadius,
     ry: task.barCornerRadius,
-    className: styles$8.projectTop
+    className: styles$8.projectTop,
+    stroke: task.styles.criticalPathColor
   }), React.createElement("polygon", {
     className: styles$8.projectTop,
     points: projectLeftTriangle,
-    fill: barColor
+    fill: barColor,
+    stroke: task.styles.criticalPathColor
   }), React.createElement("polygon", {
     className: styles$8.projectTop,
     points: projectRightTriangle,
-    fill: barColor
+    fill: barColor,
+    stroke: task.styles.criticalPathColor
   }));
 };
 
@@ -2524,6 +2529,7 @@ var Gantt = function Gantt(_ref) {
         primaryPath = _getCriticalPaths[0],
         secondaryPath = _getCriticalPaths[1];
 
+    uncolorAll(tasks);
     colorPath(secondaryPath, "#00ff00", tasks);
     colorPath(primaryPath, "#ff0000", tasks);
     setBarTasks(convertToBarTasks(filteredTasks, newDates, columnWidth, rowHeight, taskHeight, barCornerRadius, handleWidth, rtl, barProgressColor, barProgressSelectedColor, barBackgroundColor, barBackgroundSelectedColor, projectProgressColor, projectProgressSelectedColor, projectBackgroundColor, projectBackgroundSelectedColor, milestoneBackgroundColor, milestoneBackgroundSelectedColor));
@@ -2740,89 +2746,162 @@ 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 [[], []];
+    }
+
+    for (var _i4 = sortedTaskList.length - 1; _i4 >= 0; _i4--) {
+      computeCriticalPath(sortedTaskList[_i4], taskMap);
+    }
+
+    var primaryLeaf;
+    var primaryDuration = 0;
 
-  function criticalPath(task, tasks) {
-    var _task$dependencies;
+    for (var _i5 = 0; _i5 < sortedTaskList.length; _i5++) {
+      var newDuration = taskMap[sortedTaskList[_i5]].end - leafTasks[_i5].start.getTime();
 
-    if (!task) {
-      return [];
+      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;
+
+      var _newDuration = taskMap[sortedTaskList[_i6]].end - leafTasks[_i6].start.getTime();
 
-    return [].concat(longestPath, [task]);
+      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) {
+    tasks.forEach(function (task) {
+      if (task.styles) delete task.styles.criticalPathColor;
+      delete task.criticalPathArrows;
+    });
   }
 
   function colorPath(path, color, tasks) {
     for (var i = 0; i < path.length; i++) {
-      for (var j = 0; j < tasks.length; j++) {
-        if (path[i].id.startsWith(tasks[j].id + ".") || path[i].id === tasks[j].id) {
-          var _tasks$j$styles;
+      var longestIDLength = 0;
+      var longestTask = void 0;
 
-          var _styles = (_tasks$j$styles = tasks[j].styles) != null ? _tasks$j$styles : {};
+      for (var j = 0; j < tasks.length; j++) {
+        if (path[i].id === tasks[j].id) {
+          longestTask = tasks[j];
+          break;
+        }
 
-          _styles.criticalPathColor = color;
-          tasks[j].styles = _styles;
+        if (path[i].id.startsWith(tasks[j].id + ".") && tasks[j].id.length > longestIDLength) {
+          longestIDLength = tasks[j].id.length;
+          longestTask = tasks[j];
         }
       }
+
+      if (longestTask) {
+        var _longestTask$styles;
+
+        console.log("Colored " + longestTask.id + " " + color);
+
+        var _styles = (_longestTask$styles = longestTask.styles) != null ? _longestTask$styles : {};
+
+        _styles.criticalPathColor = color;
+        longestTask.styles = _styles;
+      }
     }
 
-    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);
     }
   }