gantt-lib 0.123.0 → 0.124.0

package/dist/core/scheduling/index.d.mts

@@ -1,2 +1,2 @@
-export { a7 as CascadeContext, D as DAY_MS, e as DependencyError, L as LinkType, a8 as ScheduleCommandOptions, a9 as ScheduleCommandResult, aa as ScheduleDependency, ab as ScheduleTask, ac as ScheduleTaskUpdate, T as Task, ad as TaskDependency, V as ValidationResult, ae as addBusinessDays, n as alignToWorkingDay, o as areTasksHierarchicallyRelated, p as buildAdjacencyList, q as buildTaskRangeFromEnd, r as buildTaskRangeFromStart, s as calculateSuccessorDate, t as cascadeByLinks, u as clampTaskRangeForIncomingFS, v as computeLagFromDates, w as computeParentDates, x as computeParentProgress, af as createCascadeContext, y as detectCycles, z as findParentId, A as getAllDependencyEdges, C as getAllDescendants, E as getBusinessDayOffset, ag as getBusinessDaysCount, F as getChildren, H as getDependencyLag, I as getSuccessorChain, J as getTaskDuration, K as getTransitiveCascadeChain, N as isAncestorTask, O as isTaskParent, P as moveTaskRange, Q as moveTaskWithCascade, S as normalizeDependencyLag, U as normalizePredecessorDates, X as normalizeTaskDependencyLags, Y as normalizeUTCDate, Z as parseDateOnly, _ as recalculateIncomingLags, $ as recalculateProjectSchedule, a0 as recalculateTaskFromDependencies, a1 as reflowTasksOnModeSwitch, a2 as removeDependenciesBetweenTasks, a3 as resizeTaskWithCascade, a4 as shiftBusinessDayOffset, ah as subtractBusinessDays, a5 as universalCascade, a6 as validateDependencies } from '../../index-OZVb2o_D.mjs';
+export { aa as CascadeContext, C as CriticalPathOptions, D as DAY_MS, e as DependencyError, L as LinkType, ab as ScheduleCommandOptions, ac as ScheduleCommandResult, ad as ScheduleDependency, ae as ScheduleTask, af as ScheduleTaskUpdate, T as Task, ag as TaskDependency, V as ValidationResult, ah as addBusinessDays, n as alignToWorkingDay, o as areTasksHierarchicallyRelated, p as buildAdjacencyList, q as buildTaskRangeFromEnd, r as buildTaskRangeFromStart, s as calculateSuccessorDate, t as cascadeByLinks, u as clampTaskRangeForIncomingFS, v as computeCriticalPath, w as computeLagFromDates, x as computeParentDates, y as computeParentProgress, ai as createCascadeContext, z as detectCycles, A as extendCriticalIdsToParents, E as findParentId, F as getAllDependencyEdges, H as getAllDescendants, I as getBusinessDayOffset, aj as getBusinessDaysCount, J as getChildren, K as getDependencyLag, N as getSuccessorChain, O as getTaskDuration, P as getTransitiveCascadeChain, Q as isAncestorTask, S as isTaskParent, U as moveTaskRange, X as moveTaskWithCascade, Y as normalizeDependencyLag, Z as normalizePredecessorDates, _ as normalizeTaskDependencyLags, $ as normalizeUTCDate, a0 as parseDateOnly, a1 as recalculateIncomingLags, a2 as recalculateProjectSchedule, a3 as recalculateTaskFromDependencies, a4 as reflowTasksOnModeSwitch, a5 as removeDependenciesBetweenTasks, a6 as resizeTaskWithCascade, a7 as shiftBusinessDayOffset, ak as subtractBusinessDays, a8 as universalCascade, a9 as validateDependencies } from '../../index-DD3YvhvA.mjs';
 import 'react';

package/dist/core/scheduling/index.d.ts

@@ -1,2 +1,2 @@
-export { a7 as CascadeContext, D as DAY_MS, e as DependencyError, L as LinkType, a8 as ScheduleCommandOptions, a9 as ScheduleCommandResult, aa as ScheduleDependency, ab as ScheduleTask, ac as ScheduleTaskUpdate, T as Task, ad as TaskDependency, V as ValidationResult, ae as addBusinessDays, n as alignToWorkingDay, o as areTasksHierarchicallyRelated, p as buildAdjacencyList, q as buildTaskRangeFromEnd, r as buildTaskRangeFromStart, s as calculateSuccessorDate, t as cascadeByLinks, u as clampTaskRangeForIncomingFS, v as computeLagFromDates, w as computeParentDates, x as computeParentProgress, af as createCascadeContext, y as detectCycles, z as findParentId, A as getAllDependencyEdges, C as getAllDescendants, E as getBusinessDayOffset, ag as getBusinessDaysCount, F as getChildren, H as getDependencyLag, I as getSuccessorChain, J as getTaskDuration, K as getTransitiveCascadeChain, N as isAncestorTask, O as isTaskParent, P as moveTaskRange, Q as moveTaskWithCascade, S as normalizeDependencyLag, U as normalizePredecessorDates, X as normalizeTaskDependencyLags, Y as normalizeUTCDate, Z as parseDateOnly, _ as recalculateIncomingLags, $ as recalculateProjectSchedule, a0 as recalculateTaskFromDependencies, a1 as reflowTasksOnModeSwitch, a2 as removeDependenciesBetweenTasks, a3 as resizeTaskWithCascade, a4 as shiftBusinessDayOffset, ah as subtractBusinessDays, a5 as universalCascade, a6 as validateDependencies } from '../../index-OZVb2o_D.js';
+export { aa as CascadeContext, C as CriticalPathOptions, D as DAY_MS, e as DependencyError, L as LinkType, ab as ScheduleCommandOptions, ac as ScheduleCommandResult, ad as ScheduleDependency, ae as ScheduleTask, af as ScheduleTaskUpdate, T as Task, ag as TaskDependency, V as ValidationResult, ah as addBusinessDays, n as alignToWorkingDay, o as areTasksHierarchicallyRelated, p as buildAdjacencyList, q as buildTaskRangeFromEnd, r as buildTaskRangeFromStart, s as calculateSuccessorDate, t as cascadeByLinks, u as clampTaskRangeForIncomingFS, v as computeCriticalPath, w as computeLagFromDates, x as computeParentDates, y as computeParentProgress, ai as createCascadeContext, z as detectCycles, A as extendCriticalIdsToParents, E as findParentId, F as getAllDependencyEdges, H as getAllDescendants, I as getBusinessDayOffset, aj as getBusinessDaysCount, J as getChildren, K as getDependencyLag, N as getSuccessorChain, O as getTaskDuration, P as getTransitiveCascadeChain, Q as isAncestorTask, S as isTaskParent, U as moveTaskRange, X as moveTaskWithCascade, Y as normalizeDependencyLag, Z as normalizePredecessorDates, _ as normalizeTaskDependencyLags, $ as normalizeUTCDate, a0 as parseDateOnly, a1 as recalculateIncomingLags, a2 as recalculateProjectSchedule, a3 as recalculateTaskFromDependencies, a4 as reflowTasksOnModeSwitch, a5 as removeDependenciesBetweenTasks, a6 as resizeTaskWithCascade, a7 as shiftBusinessDayOffset, ak as subtractBusinessDays, a8 as universalCascade, a9 as validateDependencies } from '../../index-DD3YvhvA.js';
 import 'react';

package/dist/core/scheduling/index.js

@@ -30,11 +30,13 @@ __export(scheduling_exports, {
   calculateSuccessorDate: () => calculateSuccessorDate,
   cascadeByLinks: () => cascadeByLinks,
   clampTaskRangeForIncomingFS: () => clampTaskRangeForIncomingFS,
+  computeCriticalPath: () => computeCriticalPath,
   computeLagFromDates: () => computeLagFromDates,
   computeParentDates: () => computeParentDates,
   computeParentProgress: () => computeParentProgress,
   createCascadeContext: () => createCascadeContext,
   detectCycles: () => detectCycles,
+  extendCriticalIdsToParents: () => extendCriticalIdsToParents,
   findParentId: () => findParentId,
   getAllDependencyEdges: () => getAllDependencyEdges,
   getAllDescendants: () => getAllDescendants,
@@ -277,6 +279,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);
@@ -1260,11 +1415,13 @@ function validateDependencies(tasks) {
   calculateSuccessorDate,
   cascadeByLinks,
   clampTaskRangeForIncomingFS,
+  computeCriticalPath,
   computeLagFromDates,
   computeParentDates,
   computeParentProgress,
   createCascadeContext,
   detectCycles,
+  extendCriticalIdsToParents,
   findParentId,
   getAllDependencyEdges,
   getAllDescendants,