gantt-lib 0.145.0 → 0.145.2

package/dist/index.mjs

@@ -733,6 +733,29 @@ var ACTIVITY_LANES_PADDING = 2;
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 function packIntervals(intervals) {
   const sorted = [...intervals].sort((a, b) => a.start - b.start);
+  if (intervals.some((item) => item.laneGroup !== void 0)) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const item of intervals) {
+      const key = item.laneGroup ?? item;
+      const group = groups.get(key) ?? [];
+      group.push(item);
+      groups.set(key, group);
+    }
+    const lanes = [];
+    const assigned = /* @__PURE__ */ new Map();
+    for (const group of groups.values()) {
+      const compatible = lanes.findIndex((lane) => group.every((item) => !lane.some((other) => item.start < other.end && other.start < item.end)));
+      const preferred = compatible < 0 ? lanes.length : compatible;
+      for (const item of [...group].sort((a, b) => a.start - b.start)) {
+        const free = (lane2) => !lanes[lane2]?.some((other) => item.start < other.end && other.start < item.end);
+        let lane = free(preferred) ? preferred : lanes.findIndex((_, index) => free(index));
+        if (lane < 0) lane = lanes.length;
+        (lanes[lane] ?? (lanes[lane] = [])).push(item);
+        assigned.set(item, lane);
+      }
+    }
+    return sorted.map((item) => ({ ...item, lane: assigned.get(item) }));
+  }
   const laneEnds = [];
   return sorted.map((item) => {
     let lane = 0;
@@ -751,6 +774,7 @@ function computeActivityLanes(activities, monthStart, dayWidth) {
     const bar = calculateTaskBar(parseUTCDate(activity.startDate), parseUTCDate(activity.endDate), monthStart, dayWidth);
     return {
       id: activity.id,
+      laneGroup: activity.laneGroup,
       name: activity.name,
       color: activity.color,
       lag: activity.lag,
@@ -2046,8 +2070,8 @@ function recalculateProjectSchedule(snapshot, options) {
     }
   }
   const queue = snapshot.filter((task) => (indegree.get(task.id) ?? 0) === 0).map((task) => task.id);
-  while (queue.length > 0) {
-    const currentId = queue.shift();
+  for (let queueIndex = 0; queueIndex < queue.length; queueIndex++) {
+    const currentId = queue[queueIndex];
     for (const successorId of successorIdsByTask.get(currentId) ?? []) {
       const nextIndegree = (indegree.get(successorId) ?? 0) - 1;
       indegree.set(successorId, nextIndegree);
@@ -2098,7 +2122,13 @@ function recalculateProjectSchedule(snapshot, options) {
       queue.push(successorId);
     }
   }
-  const parentsByDepth = snapshot.filter((task) => isTaskParent(task.id, snapshot)).map((task) => {
+  const childrenByParent = /* @__PURE__ */ new Map();
+  for (const task of snapshot) if (task.parentId) {
+    const children = childrenByParent.get(task.parentId) ?? [];
+    children.push(task.id);
+    childrenByParent.set(task.parentId, children);
+  }
+  const parentsByDepth = snapshot.filter((task) => childrenByParent.has(task.id)).map((task) => {
     let depth = 0;
     let current = task.parentId ? workingMap.get(task.parentId) : void 0;
     while (current) {
@@ -2107,17 +2137,21 @@ function recalculateProjectSchedule(snapshot, options) {
     }
     return { taskId: task.id, depth };
   }).sort((left, right) => right.depth - left.depth);
-  const workingTasks = () => Array.from(workingMap.values());
   for (const { taskId } of parentsByDepth) {
     const parent = workingMap.get(taskId);
     if (!parent || parent.locked) {
       continue;
     }
-    const { startDate, endDate } = computeParentDates(taskId, workingTasks());
+    let startTime = Infinity, endTime = -Infinity;
+    for (const childId of childrenByParent.get(taskId)) {
+      const child = workingMap.get(childId);
+      startTime = Math.min(startTime, new Date(child.startDate).getTime());
+      endTime = Math.max(endTime, new Date(child.endDate).getTime());
+    }
     workingMap.set(taskId, {
       ...parent,
-      startDate: toIsoDate(startDate),
-      endDate: toIsoDate(endDate)
+      startDate: toIsoDate(new Date(startTime)),
+      endDate: toIsoDate(new Date(endTime))
     });
   }
   return createChangedResult(snapshot, Array.from(workingMap.values()));