gantt-lib 0.122.0 → 0.124.0

package/dist/core/scheduling/index.mjs

@@ -208,6 +208,159 @@ function calculateSuccessorDate(predecessorStart, predecessorEnd, linkType, lag
   return shiftBusinessDayOffset(anchorDate, offset, weekendPredicate);
 }
 
+// src/core/scheduling/criticalPath.ts
+function computeCriticalPath(tasks, options = {}) {
+  const { businessDays = false, weekendPredicate } = options;
+  const taskById = new Map(tasks.map((task) => [task.id, task]));
+  const childIds = /* @__PURE__ */ new Set();
+  for (const task of tasks) {
+    if (task.parentId) childIds.add(task.parentId);
+  }
+  const leafTasks = tasks.filter((task) => !childIds.has(task.id));
+  const leafIds = new Set(leafTasks.map((task) => task.id));
+  const leafIdsByAncestor = /* @__PURE__ */ new Map();
+  for (const leaf of leafTasks) {
+    let ancestor = leaf.parentId;
+    while (ancestor) {
+      const set = leafIdsByAncestor.get(ancestor) ?? /* @__PURE__ */ new Set();
+      set.add(leaf.id);
+      leafIdsByAncestor.set(ancestor, set);
+      ancestor = taskById.get(ancestor)?.parentId;
+    }
+  }
+  const durationOf = (task) => getTaskDuration(task.startDate, task.endDate, businessDays, weekendPredicate);
+  const projectStartDate = leafTasks.reduce((earliest, task) => {
+    const taskStart = parseDateOnly(task.startDate);
+    return taskStart.getTime() < earliest.getTime() ? taskStart : earliest;
+  }, parseDateOnly(leafTasks[0]?.startDate ?? /* @__PURE__ */ new Date()));
+  const offsetFromProjectStart = (date) => {
+    const targetDate = parseDateOnly(date);
+    if (businessDays && weekendPredicate) {
+      return getBusinessDayOffset(projectStartDate, targetDate, weekendPredicate);
+    }
+    return Math.round((targetDate.getTime() - projectStartDate.getTime()) / DAY_MS);
+  };
+  const scheduledStart = /* @__PURE__ */ new Map();
+  for (const leaf of leafTasks) {
+    scheduledStart.set(leaf.id, offsetFromProjectStart(leaf.startDate));
+  }
+  const succByPred = /* @__PURE__ */ new Map();
+  const predBySucc = /* @__PURE__ */ new Map();
+  const seenEdges = /* @__PURE__ */ new Set();
+  const addEdge = (predecessorId, succId, lag, type) => {
+    const edgeKey = `${predecessorId}|${succId}|${type}`;
+    if (seenEdges.has(edgeKey)) return;
+    seenEdges.add(edgeKey);
+    const outEdges = succByPred.get(predecessorId) ?? [];
+    outEdges.push({ succId, lag, type });
+    succByPred.set(predecessorId, outEdges);
+    const inEdges = predBySucc.get(succId) ?? [];
+    inEdges.push({ predId: predecessorId, lag, type });
+    predBySucc.set(succId, inEdges);
+  };
+  for (const succ of leafTasks) {
+    for (const dep of succ.dependencies ?? []) {
+      const lag = getDependencyLag(dep);
+      if (leafIds.has(dep.taskId)) {
+        addEdge(dep.taskId, succ.id, lag, dep.type);
+        continue;
+      }
+      const descendants = leafIdsByAncestor.get(dep.taskId);
+      if (!descendants || descendants.size === 0) continue;
+      for (const leafId of descendants) {
+        if (leafId === succ.id) continue;
+        addEdge(leafId, succ.id, lag, dep.type);
+      }
+    }
+  }
+  const indegree = /* @__PURE__ */ new Map();
+  for (const leaf of leafTasks) indegree.set(leaf.id, 0);
+  for (const edges of succByPred.values()) {
+    for (const { succId } of edges) {
+      indegree.set(succId, (indegree.get(succId) ?? 0) + 1);
+    }
+  }
+  const order = [];
+  const enqueued = /* @__PURE__ */ new Set();
+  const queue = leafTasks.filter((leaf) => (indegree.get(leaf.id) ?? 0) === 0).map((leaf) => leaf.id);
+  for (const id of queue) enqueued.add(id);
+  while (queue.length > 0) {
+    const current = queue.shift();
+    order.push(current);
+    for (const { succId } of succByPred.get(current) ?? []) {
+      const next = (indegree.get(succId) ?? 0) - 1;
+      indegree.set(succId, next);
+      if (next === 0 && !enqueued.has(succId)) {
+        enqueued.add(succId);
+        queue.push(succId);
+      }
+    }
+  }
+  const projectFinish = Math.max(
+    0,
+    ...leafTasks.map((leaf) => (scheduledStart.get(leaf.id) ?? 0) + durationOf(leaf))
+  );
+  const LF = /* @__PURE__ */ new Map();
+  const LS = /* @__PURE__ */ new Map();
+  for (const leaf of leafTasks) LF.set(leaf.id, projectFinish);
+  for (let i = order.length - 1; i >= 0; i--) {
+    const id = order[i];
+    const task = taskById.get(id);
+    const durPred = durationOf(task);
+    const outEdges = succByPred.get(id) ?? [];
+    let lf = projectFinish;
+    if (outEdges.length > 0) {
+      const candidates = outEdges.map(({ succId, lag, type }) => {
+        const succLs = LS.get(succId) ?? projectFinish;
+        const durSucc = durationOf(taskById.get(succId));
+        switch (type) {
+          case "FS":
+            return succLs - lag;
+          case "SS":
+            return succLs - lag + durPred;
+          case "FF":
+            return succLs + durSucc - lag;
+          case "SF":
+            return succLs + durSucc - lag + durPred;
+          default:
+            return projectFinish;
+        }
+      });
+      lf = Math.min(projectFinish, ...candidates);
+    }
+    LF.set(id, lf);
+    LS.set(id, lf - durPred);
+  }
+  const critical = /* @__PURE__ */ new Set();
+  const ordered = new Set(order);
+  for (const leaf of leafTasks) {
+    if (!ordered.has(leaf.id)) continue;
+    const hasGraphEdge = (succByPred.get(leaf.id)?.length ?? 0) > 0 || (predBySucc.get(leaf.id)?.length ?? 0) > 0;
+    if (!hasGraphEdge && (leaf.dependencies?.length ?? 0) > 0) continue;
+    const es = scheduledStart.get(leaf.id) ?? 0;
+    const ls = LS.get(leaf.id) ?? 0;
+    if (ls - es <= 0) critical.add(leaf.id);
+  }
+  return critical;
+}
+function extendCriticalIdsToParents(criticalLeafIds, tasks) {
+  const result = new Set(criticalLeafIds);
+  const parentByChild = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    if (task.parentId) parentByChild.set(task.id, task.parentId);
+  }
+  const stack = Array.from(criticalLeafIds);
+  while (stack.length > 0) {
+    const id = stack.pop();
+    const parentId = parentByChild.get(id);
+    if (parentId && !result.has(parentId)) {
+      result.add(parentId);
+      stack.push(parentId);
+    }
+  }
+  return result;
+}
+
 // src/core/scheduling/commands.ts
 function buildTaskRangeFromStart(startDate, duration, businessDays = false, weekendPredicate, snapDirection = 1) {
   const normalizedStart = businessDays && weekendPredicate ? alignToWorkingDay(startDate, snapDirection, weekendPredicate) : normalizeUTCDate(startDate);
@@ -1190,11 +1343,13 @@ export {
   calculateSuccessorDate,
   cascadeByLinks,
   clampTaskRangeForIncomingFS,
+  computeCriticalPath,
   computeLagFromDates,
   computeParentDates,
   computeParentProgress,
   createCascadeContext,
   detectCycles,
+  extendCriticalIdsToParents,
   findParentId,
   getAllDependencyEdges,
   getAllDescendants,