gantt-lib 0.110.1 → 0.112.0

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

@@ -1,2 +1,2 @@
-export { D as DAY_MS, e as DependencyError, L as LinkType, a7 as ScheduleCommandOptions, a8 as ScheduleCommandResult, a9 as ScheduleDependency, aa as ScheduleTask, ab as ScheduleTaskUpdate, T as Task, ac as TaskDependency, V as ValidationResult, ad 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, y as detectCycles, z as findParentId, A as getAllDependencyEdges, C as getAllDescendants, E as getBusinessDayOffset, ae 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, af as subtractBusinessDays, a5 as universalCascade, a6 as validateDependencies } from '../../index-Ci6WiKhW.mjs';
+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-D1s_8MxS.mjs';
 import 'react';

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

@@ -1,2 +1,2 @@
-export { D as DAY_MS, e as DependencyError, L as LinkType, a7 as ScheduleCommandOptions, a8 as ScheduleCommandResult, a9 as ScheduleDependency, aa as ScheduleTask, ab as ScheduleTaskUpdate, T as Task, ac as TaskDependency, V as ValidationResult, ad 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, y as detectCycles, z as findParentId, A as getAllDependencyEdges, C as getAllDescendants, E as getBusinessDayOffset, ae 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, af as subtractBusinessDays, a5 as universalCascade, a6 as validateDependencies } from '../../index-Ci6WiKhW.js';
+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-D1s_8MxS.js';
 import 'react';

package/dist/core/scheduling/index.js

@@ -33,6 +33,7 @@ __export(scheduling_exports, {
   computeLagFromDates: () => computeLagFromDates,
   computeParentDates: () => computeParentDates,
   computeParentProgress: () => computeParentProgress,
+  createCascadeContext: () => createCascadeContext,
   detectCycles: () => detectCycles,
   findParentId: () => findParentId,
   getAllDependencyEdges: () => getAllDependencyEdges,
@@ -276,126 +277,6 @@ function calculateSuccessorDate(predecessorStart, predecessorEnd, linkType, lag
   return shiftBusinessDayOffset(anchorDate, offset, weekendPredicate);
 }
 
-// src/core/scheduling/hierarchy.ts
-function getChildren(parentId, tasks) {
-  return tasks.filter((t) => t.parentId === parentId);
-}
-function isTaskParent(taskId, tasks) {
-  return tasks.some((t) => t.parentId === taskId);
-}
-function computeParentDates(parentId, tasks) {
-  const children = getChildren(parentId, tasks);
-  if (children.length === 0) {
-    const parent = tasks.find((t) => t.id === parentId);
-    const start = parent ? new Date(parent.startDate) : /* @__PURE__ */ new Date();
-    const end = parent ? new Date(parent.endDate) : /* @__PURE__ */ new Date();
-    return { startDate: start, endDate: end };
-  }
-  const startDates = children.map((c) => new Date(c.startDate));
-  const endDates = children.map((c) => new Date(c.endDate));
-  const minTime = Math.min(...startDates.map((d) => d.getTime()));
-  const maxTime = Math.max(...endDates.map((d) => d.getTime()));
-  return {
-    startDate: new Date(minTime),
-    endDate: new Date(maxTime)
-  };
-}
-function computeParentProgress(parentId, tasks) {
-  const children = getChildren(parentId, tasks);
-  if (children.length === 0) {
-    return 0;
-  }
-  const DAY_MS2 = 24 * 60 * 60 * 1e3;
-  let totalWeight = 0;
-  let weightedSum = 0;
-  for (const child of children) {
-    const start = new Date(child.startDate).getTime();
-    const end = new Date(child.endDate).getTime();
-    const duration = (end - start + DAY_MS2) / DAY_MS2;
-    const progress = child.progress ?? 0;
-    totalWeight += duration;
-    weightedSum += duration * progress;
-  }
-  if (totalWeight === 0) {
-    return 0;
-  }
-  return Math.round(weightedSum / totalWeight * 10) / 10;
-}
-function getAllDescendants(parentId, tasks) {
-  const descendants = [];
-  const visited = /* @__PURE__ */ new Set();
-  function collectChildren(taskId) {
-    if (visited.has(taskId)) return;
-    visited.add(taskId);
-    const children = getChildren(taskId, tasks);
-    for (const child of children) {
-      descendants.push(child);
-      collectChildren(child.id);
-    }
-  }
-  collectChildren(parentId);
-  return descendants;
-}
-function getAllDependencyEdges(tasks) {
-  const edges = [];
-  for (const task of tasks) {
-    if (task.dependencies) {
-      for (const dep of task.dependencies) {
-        edges.push({
-          predecessorId: dep.taskId,
-          successorId: task.id,
-          type: dep.type,
-          lag: dep.lag ?? 0
-        });
-      }
-    }
-  }
-  return edges;
-}
-function removeDependenciesBetweenTasks(taskId1, taskId2, tasks) {
-  return tasks.map((task) => {
-    if (task.id === taskId1 || task.id === taskId2) {
-      if (!task.dependencies) return task;
-      const otherTaskId = task.id === taskId1 ? taskId2 : taskId1;
-      const filteredDependencies = task.dependencies.filter((dep) => dep.taskId !== otherTaskId);
-      if (filteredDependencies.length === task.dependencies.length) {
-        return task;
-      }
-      return {
-        ...task,
-        dependencies: filteredDependencies.length > 0 ? filteredDependencies : void 0
-      };
-    }
-    return task;
-  });
-}
-function findParentId(taskId, tasks) {
-  const task = tasks.find((t) => t.id === taskId);
-  return task?.parentId;
-}
-function isAncestorTask(ancestorId, taskId, tasks) {
-  const taskById = new Map(tasks.map((task) => [task.id, task]));
-  const visited = /* @__PURE__ */ new Set();
-  let current = taskById.get(taskId);
-  while (current?.parentId) {
-    if (current.parentId === ancestorId) {
-      return true;
-    }
-    if (visited.has(current.parentId)) {
-      return false;
-    }
-    visited.add(current.parentId);
-    current = taskById.get(current.parentId);
-  }
-  return false;
-}
-function areTasksHierarchicallyRelated(taskId1, taskId2, tasks) {
-  if (taskId1 === taskId2) {
-    return true;
-  }
-  return isAncestorTask(taskId1, taskId2, tasks) || isAncestorTask(taskId2, taskId1, tasks);
-}
-
 // src/core/scheduling/commands.ts
 function buildTaskRangeFromStart(startDate, duration, businessDays = false, weekendPredicate, snapDirection = 1) {
   const normalizedStart = businessDays && weekendPredicate ? alignToWorkingDay(startDate, snapDirection, weekendPredicate) : normalizeUTCDate(startDate);
@@ -434,7 +315,7 @@ function moveTaskRange(originalStart, originalEnd, proposedStart, businessDays =
     snapDirection
   );
 }
-function clampTaskRangeForIncomingFS(task, proposedStart, proposedEnd, allTasks, businessDays = false, weekendPredicate) {
+function clampTaskRangeForIncomingFS(task, proposedStart, proposedEnd, allTasks, businessDays = false, weekendPredicate, taskById) {
   if (!task.dependencies?.length) {
     return { start: proposedStart, end: proposedEnd };
   }
@@ -443,7 +324,7 @@ function clampTaskRangeForIncomingFS(task, proposedStart, proposedEnd, allTasks,
     if (dep.type !== "FS") {
       continue;
     }
-    const predecessor = allTasks.find((candidate) => candidate.id === dep.taskId);
+    const predecessor = taskById?.get(dep.taskId) ?? allTasks.find((candidate) => candidate.id === dep.taskId);
     if (!predecessor) {
       continue;
     }
@@ -476,10 +357,10 @@ function clampTaskRangeForIncomingFS(task, proposedStart, proposedEnd, allTasks,
     weekendPredicate
   );
 }
-function recalculateIncomingLags(task, newStartDate, newEndDate, allTasks, businessDays = false, weekendPredicate) {
+function recalculateIncomingLags(task, newStartDate, newEndDate, allTasks, businessDays = false, weekendPredicate, taskById) {
   if (!task.dependencies) return [];
   return task.dependencies.map((dep) => {
-    const predecessor = allTasks.find((candidate) => candidate.id === dep.taskId);
+    const predecessor = taskById?.get(dep.taskId) ?? allTasks.find((candidate) => candidate.id === dep.taskId);
     if (!predecessor) {
       return { ...dep, lag: getDependencyLag(dep) };
     }
@@ -507,35 +388,45 @@ function parseCascadeDateInput(date) {
   }
   return normalizeUTCDate(/* @__PURE__ */ new Date(`${date.split("T")[0]}T00:00:00.000Z`));
 }
-function getSuccessorChain(draggedTaskId, allTasks, linkTypes = ["FS"]) {
-  const successorMap = /* @__PURE__ */ new Map();
-  for (const task of allTasks) {
-    successorMap.set(task.id, []);
-  }
+function createCascadeContext(allTasks) {
+  const childrenByParentId = /* @__PURE__ */ new Map();
+  const dependentsByPredecessorId = /* @__PURE__ */ new Map();
+  const taskById = /* @__PURE__ */ new Map();
   for (const task of allTasks) {
-    if (!task.dependencies) continue;
-    for (const dep of task.dependencies) {
-      if (linkTypes.includes(dep.type)) {
-        const list = successorMap.get(dep.taskId) ?? [];
-        list.push(task.id);
-        successorMap.set(dep.taskId, list);
-      }
+    taskById.set(task.id, task);
+    if (task.parentId) {
+      const children = childrenByParentId.get(task.parentId) ?? [];
+      children.push(task);
+      childrenByParentId.set(task.parentId, children);
     }
+    if (!task.dependencies) continue;
+    task.dependencies.forEach((dependency, dependencyIndex) => {
+      const dependents = dependentsByPredecessorId.get(dependency.taskId) ?? [];
+      dependents.push({ task, dependencyIndex });
+      dependentsByPredecessorId.set(dependency.taskId, dependents);
+    });
   }
-  const taskById = new Map(allTasks.map((t) => [t.id, t]));
+  return { childrenByParentId, dependentsByPredecessorId, taskById };
+}
+function getSuccessorChain(draggedTaskId, allTasks, linkTypes = ["FS"]) {
+  const { dependentsByPredecessorId, taskById } = createCascadeContext(allTasks);
   const visited = /* @__PURE__ */ new Set();
   const queue = [draggedTaskId];
   const chain = [];
   visited.add(draggedTaskId);
   while (queue.length > 0) {
     const current = queue.shift();
-    const successors = successorMap.get(current) ?? [];
-    for (const sid of successors) {
+    const successors = dependentsByPredecessorId.get(current) ?? [];
+    for (const { task } of successors) {
+      if (!linkTypes.includes(task.dependencies?.find((dependency) => dependency.taskId === current)?.type ?? "FS")) {
+        continue;
+      }
+      const sid = task.id;
       if (!visited.has(sid)) {
         visited.add(sid);
-        const t = taskById.get(sid);
-        if (t) {
-          chain.push(t);
+        const successorTask = taskById.get(sid);
+        if (successorTask) {
+          chain.push(successorTask);
           queue.push(sid);
         }
       }
@@ -544,7 +435,7 @@ function getSuccessorChain(draggedTaskId, allTasks, linkTypes = ["FS"]) {
   return chain;
 }
 function cascadeByLinks(movedTaskId, newStart, newEnd, allTasks, skipChildCascade = false) {
-  const taskById = new Map(allTasks.map((t) => [t.id, t]));
+  const { childrenByParentId, dependentsByPredecessorId, taskById } = createCascadeContext(allTasks);
   const updatedDates = /* @__PURE__ */ new Map();
   updatedDates.set(movedTaskId, { start: newStart, end: newEnd });
   const result = [];
@@ -554,7 +445,7 @@ function cascadeByLinks(movedTaskId, newStart, newEnd, allTasks, skipChildCascad
     const currentId = queue.shift();
     const { start: predStart, end: predEnd } = updatedDates.get(currentId);
     if (!skipChildCascade) {
-      const children = getChildren(currentId, allTasks);
+      const children = childrenByParentId.get(currentId) ?? [];
       for (const child of children) {
         if (visited.has(child.id) || child.locked) continue;
         const origStart = new Date(child.startDate);
@@ -577,64 +468,52 @@ function cascadeByLinks(movedTaskId, newStart, newEnd, allTasks, skipChildCascad
         queue.push(child.id);
       }
     }
-    for (const task of allTasks) {
+    const dependents = dependentsByPredecessorId.get(currentId) ?? [];
+    for (const { task, dependencyIndex } of dependents) {
       if (visited.has(task.id) || !task.dependencies || task.locked) continue;
-      for (const dep of task.dependencies) {
-        if (dep.taskId !== currentId) continue;
-        const orig = taskById.get(task.id);
-        const origStart = new Date(orig.startDate);
-        const origEnd = new Date(orig.endDate);
-        const duration = getTaskDuration(origStart, origEnd);
-        const currentTask = taskById.get(currentId);
-        const { predStart: normalizedPredStart, predEnd: normalizedPredEnd } = normalizePredecessorDates(
-          {
-            startDate: predStart,
-            endDate: predEnd,
-            type: currentTask.type
-          },
-          parseCascadeDateInput
-        );
-        const constraintDate = calculateSuccessorDate(
-          normalizedPredStart,
-          normalizedPredEnd,
-          dep.type,
-          getDependencyLag(dep)
-        );
-        let newSuccStart;
-        let newSuccEnd;
-        if (dep.type === "FS" || dep.type === "SS") {
-          ({ start: newSuccStart, end: newSuccEnd } = buildTaskRangeFromStart(constraintDate, duration));
-        } else {
-          ({ start: newSuccStart, end: newSuccEnd } = buildTaskRangeFromEnd(constraintDate, duration));
-        }
-        visited.add(task.id);
-        updatedDates.set(task.id, { start: newSuccStart, end: newSuccEnd });
-        result.push(normalizeTaskDependencyLags({
-          ...task,
-          startDate: newSuccStart.toISOString().split("T")[0],
-          endDate: newSuccEnd.toISOString().split("T")[0]
-        }));
-        queue.push(task.id);
-        break;
+      const dep = task.dependencies[dependencyIndex];
+      if (!dep) continue;
+      const orig = taskById.get(task.id);
+      const origStart = new Date(orig.startDate);
+      const origEnd = new Date(orig.endDate);
+      const duration = getTaskDuration(origStart, origEnd);
+      const currentTask = taskById.get(currentId);
+      const { predStart: normalizedPredStart, predEnd: normalizedPredEnd } = normalizePredecessorDates(
+        {
+          startDate: predStart,
+          endDate: predEnd,
+          type: currentTask.type
+        },
+        parseCascadeDateInput
+      );
+      const constraintDate = calculateSuccessorDate(
+        normalizedPredStart,
+        normalizedPredEnd,
+        dep.type,
+        getDependencyLag(dep)
+      );
+      let newSuccStart;
+      let newSuccEnd;
+      if (dep.type === "FS" || dep.type === "SS") {
+        ({ start: newSuccStart, end: newSuccEnd } = buildTaskRangeFromStart(constraintDate, duration));
+      } else {
+        ({ start: newSuccStart, end: newSuccEnd } = buildTaskRangeFromEnd(constraintDate, duration));
       }
+      visited.add(task.id);
+      updatedDates.set(task.id, { start: newSuccStart, end: newSuccEnd });
+      result.push(normalizeTaskDependencyLags({
+        ...task,
+        startDate: newSuccStart.toISOString().split("T")[0],
+        endDate: newSuccEnd.toISOString().split("T")[0]
+      }));
+      queue.push(task.id);
     }
   }
   return result;
 }
 function getTransitiveCascadeChain(changedTaskId, allTasks, firstLevelLinkTypes) {
-  const allTypesSuccessorMap = /* @__PURE__ */ new Map();
-  for (const task of allTasks) {
-    allTypesSuccessorMap.set(task.id, []);
-  }
-  for (const task of allTasks) {
-    if (!task.dependencies) continue;
-    for (const dep of task.dependencies) {
-      const list = allTypesSuccessorMap.get(dep.taskId) ?? [];
-      list.push(task);
-      allTypesSuccessorMap.set(dep.taskId, list);
-    }
-  }
-  const directChildren = getChildren(changedTaskId, allTasks);
+  const { childrenByParentId, dependentsByPredecessorId } = createCascadeContext(allTasks);
+  const directChildren = childrenByParentId.get(changedTaskId) ?? [];
   const directSuccessors = getSuccessorChain(changedTaskId, allTasks, firstLevelLinkTypes);
   const initialChain = [...directChildren, ...directSuccessors].filter(
     (task, index, arr) => arr.findIndex((candidate) => candidate.id === task.id) === index
@@ -644,7 +523,7 @@ function getTransitiveCascadeChain(changedTaskId, allTasks, firstLevelLinkTypes)
   const queue = [...initialChain];
   while (queue.length > 0) {
     const current = queue.shift();
-    const children = getChildren(current.id, allTasks);
+    const children = childrenByParentId.get(current.id) ?? [];
     for (const child of children) {
       if (!visited.has(child.id)) {
         visited.add(child.id);
@@ -652,8 +531,8 @@ function getTransitiveCascadeChain(changedTaskId, allTasks, firstLevelLinkTypes)
         queue.push(child);
       }
     }
-    const successors = allTypesSuccessorMap.get(current.id) ?? [];
-    for (const successor of successors) {
+    const successors = dependentsByPredecessorId.get(current.id) ?? [];
+    for (const { task: successor } of successors) {
       if (!visited.has(successor.id)) {
         visited.add(successor.id);
         chain.push(successor);
@@ -663,16 +542,20 @@ function getTransitiveCascadeChain(changedTaskId, allTasks, firstLevelLinkTypes)
   }
   return chain;
 }
-function universalCascade(movedTask, newStart, newEnd, allTasks, businessDays = false, weekendPredicate) {
-  const taskById = new Map(allTasks.map((t) => [t.id, t]));
-  const updatedDates = /* @__PURE__ */ new Map();
-  updatedDates.set(movedTask.id, { start: newStart, end: newEnd });
-  const resultMap = /* @__PURE__ */ new Map();
-  resultMap.set(movedTask.id, normalizeTaskDependencyLags({
+function universalCascade(movedTask, newStart, newEnd, allTasks, businessDays = false, weekendPredicate, context = createCascadeContext(allTasks)) {
+  const { childrenByParentId, dependentsByPredecessorId, taskById } = context;
+  const normalizedMovedTask = normalizeTaskDependencyLags({
     ...movedTask,
     startDate: newStart.toISOString().split("T")[0],
     endDate: newEnd.toISOString().split("T")[0]
-  }));
+  });
+  if (!movedTask.parentId && !childrenByParentId.has(movedTask.id) && !dependentsByPredecessorId.has(movedTask.id)) {
+    return [normalizedMovedTask];
+  }
+  const updatedDates = /* @__PURE__ */ new Map();
+  updatedDates.set(movedTask.id, { start: newStart, end: newEnd });
+  const resultMap = /* @__PURE__ */ new Map();
+  resultMap.set(movedTask.id, normalizedMovedTask);
   const queue = [[movedTask.id, "direct"]];
   const childShifted = /* @__PURE__ */ new Set();
   let iterations = 0;
@@ -683,7 +566,7 @@ function universalCascade(movedTask, newStart, newEnd, allTasks, businessDays =
     const { start: currStart, end: currEnd } = updatedDates.get(currentId);
     const currentOriginal = taskById.get(currentId);
     if (arrivalMode !== "parent-recalc") {
-      const children = getChildren(currentId, allTasks);
+      const children = childrenByParentId.get(currentId) ?? [];
       for (const child of children) {
         if (childShifted.has(child.id) || child.locked) continue;
         const parentOrigStart = new Date(currentOriginal.startDate);
@@ -729,7 +612,7 @@ function universalCascade(movedTask, newStart, newEnd, allTasks, businessDays =
     if (parentId) {
       const parent = taskById.get(parentId);
       if (parent && !parent.locked) {
-        const siblings = getChildren(parentId, allTasks);
+        const siblings = childrenByParentId.get(parentId) ?? [];
         const siblingPositions = siblings.map((sib) => {
           if (updatedDates.has(sib.id)) return updatedDates.get(sib.id);
           return { start: new Date(sib.startDate), end: new Date(sib.endDate) };
@@ -748,9 +631,10 @@ function universalCascade(movedTask, newStart, newEnd, allTasks, businessDays =
         }
       }
     }
-    for (const task of allTasks) {
+    const dependents = dependentsByPredecessorId.get(currentId) ?? [];
+    for (const { task, dependencyIndex } of dependents) {
       if (task.locked || !task.dependencies) continue;
-      const dep = task.dependencies.find((d) => d.taskId === currentId);
+      const dep = task.dependencies[dependencyIndex];
       if (!dep) continue;
       const origStart = new Date(task.startDate);
       const origEnd = new Date(task.endDate);
@@ -804,6 +688,126 @@ function universalCascade(movedTask, newStart, newEnd, allTasks, businessDays =
   return Array.from(resultMap.values());
 }
 
+// src/core/scheduling/hierarchy.ts
+function getChildren(parentId, tasks) {
+  return tasks.filter((t) => t.parentId === parentId);
+}
+function isTaskParent(taskId, tasks) {
+  return tasks.some((t) => t.parentId === taskId);
+}
+function computeParentDates(parentId, tasks) {
+  const children = getChildren(parentId, tasks);
+  if (children.length === 0) {
+    const parent = tasks.find((t) => t.id === parentId);
+    const start = parent ? new Date(parent.startDate) : /* @__PURE__ */ new Date();
+    const end = parent ? new Date(parent.endDate) : /* @__PURE__ */ new Date();
+    return { startDate: start, endDate: end };
+  }
+  const startDates = children.map((c) => new Date(c.startDate));
+  const endDates = children.map((c) => new Date(c.endDate));
+  const minTime = Math.min(...startDates.map((d) => d.getTime()));
+  const maxTime = Math.max(...endDates.map((d) => d.getTime()));
+  return {
+    startDate: new Date(minTime),
+    endDate: new Date(maxTime)
+  };
+}
+function computeParentProgress(parentId, tasks) {
+  const children = getChildren(parentId, tasks);
+  if (children.length === 0) {
+    return 0;
+  }
+  const DAY_MS2 = 24 * 60 * 60 * 1e3;
+  let totalWeight = 0;
+  let weightedSum = 0;
+  for (const child of children) {
+    const start = new Date(child.startDate).getTime();
+    const end = new Date(child.endDate).getTime();
+    const duration = (end - start + DAY_MS2) / DAY_MS2;
+    const progress = child.progress ?? 0;
+    totalWeight += duration;
+    weightedSum += duration * progress;
+  }
+  if (totalWeight === 0) {
+    return 0;
+  }
+  return Math.round(weightedSum / totalWeight * 10) / 10;
+}
+function getAllDescendants(parentId, tasks) {
+  const descendants = [];
+  const visited = /* @__PURE__ */ new Set();
+  function collectChildren(taskId) {
+    if (visited.has(taskId)) return;
+    visited.add(taskId);
+    const children = getChildren(taskId, tasks);
+    for (const child of children) {
+      descendants.push(child);
+      collectChildren(child.id);
+    }
+  }
+  collectChildren(parentId);
+  return descendants;
+}
+function getAllDependencyEdges(tasks) {
+  const edges = [];
+  for (const task of tasks) {
+    if (task.dependencies) {
+      for (const dep of task.dependencies) {
+        edges.push({
+          predecessorId: dep.taskId,
+          successorId: task.id,
+          type: dep.type,
+          lag: dep.lag ?? 0
+        });
+      }
+    }
+  }
+  return edges;
+}
+function removeDependenciesBetweenTasks(taskId1, taskId2, tasks) {
+  return tasks.map((task) => {
+    if (task.id === taskId1 || task.id === taskId2) {
+      if (!task.dependencies) return task;
+      const otherTaskId = task.id === taskId1 ? taskId2 : taskId1;
+      const filteredDependencies = task.dependencies.filter((dep) => dep.taskId !== otherTaskId);
+      if (filteredDependencies.length === task.dependencies.length) {
+        return task;
+      }
+      return {
+        ...task,
+        dependencies: filteredDependencies.length > 0 ? filteredDependencies : void 0
+      };
+    }
+    return task;
+  });
+}
+function findParentId(taskId, tasks) {
+  const task = tasks.find((t) => t.id === taskId);
+  return task?.parentId;
+}
+function isAncestorTask(ancestorId, taskId, tasks) {
+  const taskById = new Map(tasks.map((task) => [task.id, task]));
+  const visited = /* @__PURE__ */ new Set();
+  let current = taskById.get(taskId);
+  while (current?.parentId) {
+    if (current.parentId === ancestorId) {
+      return true;
+    }
+    if (visited.has(current.parentId)) {
+      return false;
+    }
+    visited.add(current.parentId);
+    current = taskById.get(current.parentId);
+  }
+  return false;
+}
+function areTasksHierarchicallyRelated(taskId1, taskId2, tasks) {
+  if (taskId1 === taskId2) {
+    return true;
+  }
+  return isAncestorTask(taskId1, taskId2, tasks) || isAncestorTask(taskId2, taskId1, tasks);
+}
+
 // src/core/scheduling/execute.ts
 function toIsoDate(date) {
   return date.toISOString().split("T")[0];
@@ -1259,6 +1263,7 @@ function validateDependencies(tasks) {
   computeLagFromDates,
   computeParentDates,
   computeParentProgress,
+  createCascadeContext,
   detectCycles,
   findParentId,
   getAllDependencyEdges,