gantt-lib 0.60.2 → 0.61.0

package/dist/index.mjs

@@ -825,62 +825,6 @@ function recalculateIncomingLags(task, newStartDate, newEndDate, allTasks, busin
     return { ...dep, lag: nextLag };
   });
 }
-function resolveDateRangeFromPixels(mode, left, width, monthStart, dayWidth, task, businessDays, weekendPredicate) {
-  const dayOffset = Math.round(left / dayWidth);
-  const rawStartDate = new Date(Date.UTC(
-    monthStart.getUTCFullYear(),
-    monthStart.getUTCMonth(),
-    monthStart.getUTCDate() + dayOffset
-  ));
-  const rawEndOffset = dayOffset + Math.round(width / dayWidth) - 1;
-  const rawEndDate = new Date(Date.UTC(
-    monthStart.getUTCFullYear(),
-    monthStart.getUTCMonth(),
-    monthStart.getUTCDate() + rawEndOffset
-  ));
-  if (!(businessDays && weekendPredicate)) {
-    return { start: rawStartDate, end: rawEndDate };
-  }
-  if (mode === "move") {
-    const originalStart2 = new Date(task.startDate);
-    const snapDirection2 = rawStartDate.getTime() >= originalStart2.getTime() ? 1 : -1;
-    return moveTaskRange(
-      task.startDate,
-      task.endDate,
-      rawStartDate,
-      true,
-      weekendPredicate,
-      snapDirection2
-    );
-  }
-  if (mode === "resize-right") {
-    const fixedStart = new Date(task.startDate);
-    const originalEnd = new Date(task.endDate);
-    const snapDirection2 = rawEndDate.getTime() >= originalEnd.getTime() ? 1 : -1;
-    const alignedEnd = alignToWorkingDay(rawEndDate, snapDirection2, weekendPredicate);
-    const duration2 = Math.max(1, getBusinessDaysCount(fixedStart, alignedEnd, weekendPredicate));
-    return buildTaskRangeFromStart(fixedStart, duration2, true, weekendPredicate);
-  }
-  const fixedEnd = new Date(task.endDate);
-  const originalStart = new Date(task.startDate);
-  const snapDirection = rawStartDate.getTime() >= originalStart.getTime() ? 1 : -1;
-  const alignedStart = alignToWorkingDay(rawStartDate, snapDirection, weekendPredicate);
-  const duration = Math.max(1, getBusinessDaysCount(alignedStart, fixedEnd, weekendPredicate));
-  return buildTaskRangeFromEnd(fixedEnd, duration, true, weekendPredicate);
-}
-function clampDateRangeForIncomingFS(task, range, allTasks, mode, businessDays, weekendPredicate) {
-  if (mode === "resize-right") {
-    return range;
-  }
-  return clampTaskRangeForIncomingFS(
-    task,
-    range.start,
-    range.end,
-    allTasks,
-    businessDays,
-    weekendPredicate
-  );
-}
 
 // src/core/scheduling/cascade.ts
 function getSuccessorChain(draggedTaskId, allTasks, linkTypes = ["FS"]) {
@@ -1197,6 +1141,313 @@ function reflowTasksOnModeSwitch(sourceTasks, toBusinessDays, weekendPredicate)
   return tasks;
 }
 
+// src/core/scheduling/execute.ts
+init_dateMath();
+function toIsoDate(date) {
+  return date.toISOString().split("T")[0];
+}
+function createChangedResult(snapshot, nextTasks) {
+  const originalById = new Map(snapshot.map((task) => [task.id, task]));
+  const changedTasks = nextTasks.filter((task) => JSON.stringify(originalById.get(task.id)) !== JSON.stringify(task));
+  return {
+    changedTasks,
+    changedIds: changedTasks.map((task) => task.id)
+  };
+}
+function moveTaskWithCascade(taskId, newStart, snapshot, options) {
+  const task = snapshot.find((t) => t.id === taskId);
+  if (!task) {
+    return { changedTasks: [], changedIds: [] };
+  }
+  const businessDays = options?.businessDays ?? false;
+  const weekendPredicate = options?.weekendPredicate;
+  const newRange = moveTaskRange(
+    task.startDate,
+    task.endDate,
+    newStart,
+    businessDays,
+    weekendPredicate
+  );
+  const updatedDependencies = recalculateIncomingLags(
+    task,
+    newRange.start,
+    newRange.end,
+    snapshot,
+    businessDays,
+    weekendPredicate
+  );
+  const movedTask = {
+    ...task,
+    startDate: newRange.start.toISOString().split("T")[0],
+    endDate: newRange.end.toISOString().split("T")[0],
+    dependencies: updatedDependencies
+  };
+  if (options?.skipCascade) {
+    return {
+      changedTasks: [movedTask],
+      changedIds: [movedTask.id]
+    };
+  }
+  const cascadeResult = universalCascade(
+    movedTask,
+    newRange.start,
+    newRange.end,
+    snapshot,
+    businessDays,
+    weekendPredicate
+  );
+  const resultMap = /* @__PURE__ */ new Map();
+  resultMap.set(movedTask.id, movedTask);
+  for (const t of cascadeResult) {
+    resultMap.set(t.id, t);
+  }
+  const changedTasks = Array.from(resultMap.values());
+  return {
+    changedTasks,
+    changedIds: changedTasks.map((t) => t.id)
+  };
+}
+function resizeTaskWithCascade(taskId, anchor, newDate, snapshot, options) {
+  const task = snapshot.find((t) => t.id === taskId);
+  if (!task) {
+    return { changedTasks: [], changedIds: [] };
+  }
+  const businessDays = options?.businessDays ?? false;
+  const weekendPredicate = options?.weekendPredicate;
+  const originalStart = parseDateOnly(task.startDate);
+  const originalEnd = parseDateOnly(task.endDate);
+  let newRange;
+  if (anchor === "end") {
+    newRange = { start: originalStart, end: newDate };
+  } else {
+    newRange = { start: newDate, end: originalEnd };
+  }
+  const updatedDependencies = recalculateIncomingLags(
+    task,
+    newRange.start,
+    newRange.end,
+    snapshot,
+    businessDays,
+    weekendPredicate
+  );
+  const resizedTask = {
+    ...task,
+    startDate: newRange.start.toISOString().split("T")[0],
+    endDate: newRange.end.toISOString().split("T")[0],
+    dependencies: updatedDependencies
+  };
+  if (options?.skipCascade) {
+    return {
+      changedTasks: [resizedTask],
+      changedIds: [resizedTask.id]
+    };
+  }
+  const cascadeResult = universalCascade(
+    resizedTask,
+    newRange.start,
+    newRange.end,
+    snapshot,
+    businessDays,
+    weekendPredicate
+  );
+  const resultMap = /* @__PURE__ */ new Map();
+  resultMap.set(resizedTask.id, resizedTask);
+  for (const t of cascadeResult) {
+    resultMap.set(t.id, t);
+  }
+  const changedTasks = Array.from(resultMap.values());
+  return {
+    changedTasks,
+    changedIds: changedTasks.map((t) => t.id)
+  };
+}
+function recalculateTaskFromDependencies(taskId, snapshot, options) {
+  const task = snapshot.find((t) => t.id === taskId);
+  if (!task) {
+    return { changedTasks: [], changedIds: [] };
+  }
+  const businessDays = options?.businessDays ?? false;
+  const weekendPredicate = options?.weekendPredicate;
+  if (!task.dependencies || task.dependencies.length === 0) {
+    return {
+      changedTasks: [task],
+      changedIds: [task.id]
+    };
+  }
+  let constrainedStart = null;
+  let constrainedEnd = null;
+  for (const dep of task.dependencies) {
+    const predecessor = snapshot.find((t) => t.id === dep.taskId);
+    if (!predecessor) continue;
+    const predStart = parseDateOnly(predecessor.startDate);
+    const predEnd = parseDateOnly(predecessor.endDate);
+    const constraintDate = calculateSuccessorDate(
+      predStart,
+      predEnd,
+      dep.type,
+      getDependencyLag(dep),
+      businessDays,
+      weekendPredicate
+    );
+    const duration = getTaskDuration(
+      parseDateOnly(task.startDate),
+      parseDateOnly(task.endDate),
+      businessDays,
+      weekendPredicate
+    );
+    let range;
+    if (dep.type === "FS" || dep.type === "SS") {
+      range = buildTaskRangeFromStart(constraintDate, duration, businessDays, weekendPredicate);
+    } else {
+      range = buildTaskRangeFromEnd(constraintDate, duration, businessDays, weekendPredicate);
+    }
+    if (!constrainedStart || range.start.getTime() > constrainedStart.getTime()) {
+      constrainedStart = range.start;
+      constrainedEnd = range.end;
+    }
+  }
+  if (!constrainedStart || !constrainedEnd) {
+    return {
+      changedTasks: [task],
+      changedIds: [task.id]
+    };
+  }
+  const updatedDependencies = recalculateIncomingLags(
+    task,
+    constrainedStart,
+    constrainedEnd,
+    snapshot,
+    businessDays,
+    weekendPredicate
+  );
+  const recalculatedTask = {
+    ...task,
+    startDate: constrainedStart.toISOString().split("T")[0],
+    endDate: constrainedEnd.toISOString().split("T")[0],
+    dependencies: updatedDependencies
+  };
+  if (options?.skipCascade) {
+    return {
+      changedTasks: [recalculatedTask],
+      changedIds: [recalculatedTask.id]
+    };
+  }
+  const cascadeResult = universalCascade(
+    recalculatedTask,
+    constrainedStart,
+    constrainedEnd,
+    snapshot,
+    businessDays,
+    weekendPredicate
+  );
+  const resultMap = /* @__PURE__ */ new Map();
+  resultMap.set(recalculatedTask.id, recalculatedTask);
+  for (const t of cascadeResult) {
+    resultMap.set(t.id, t);
+  }
+  const changedTasks = Array.from(resultMap.values());
+  return {
+    changedTasks,
+    changedIds: changedTasks.map((t) => t.id)
+  };
+}
+function recalculateProjectSchedule(snapshot, options) {
+  const businessDays = options?.businessDays ?? false;
+  const weekendPredicate = options?.weekendPredicate;
+  const workingMap = new Map(snapshot.map((task) => [task.id, { ...task }]));
+  const indegree = /* @__PURE__ */ new Map();
+  const successorIdsByTask = /* @__PURE__ */ new Map();
+  for (const task of snapshot) {
+    indegree.set(task.id, 0);
+    successorIdsByTask.set(task.id, []);
+  }
+  for (const task of snapshot) {
+    for (const dep of task.dependencies ?? []) {
+      if (!workingMap.has(dep.taskId)) {
+        continue;
+      }
+      indegree.set(task.id, (indegree.get(task.id) ?? 0) + 1);
+      successorIdsByTask.get(dep.taskId)?.push(task.id);
+    }
+  }
+  const queue = snapshot.filter((task) => (indegree.get(task.id) ?? 0) === 0).map((task) => task.id);
+  while (queue.length > 0) {
+    const currentId = queue.shift();
+    for (const successorId of successorIdsByTask.get(currentId) ?? []) {
+      const nextIndegree = (indegree.get(successorId) ?? 0) - 1;
+      indegree.set(successorId, nextIndegree);
+      if (nextIndegree !== 0) {
+        continue;
+      }
+      const currentTask = workingMap.get(successorId);
+      if (!currentTask || currentTask.locked || !currentTask.dependencies?.length) {
+        queue.push(successorId);
+        continue;
+      }
+      const duration = getTaskDuration(
+        parseDateOnly(currentTask.startDate),
+        parseDateOnly(currentTask.endDate),
+        businessDays,
+        weekendPredicate
+      );
+      let constrainedRange = null;
+      for (const dep of currentTask.dependencies) {
+        const predecessor = workingMap.get(dep.taskId);
+        if (!predecessor) {
+          continue;
+        }
+        const predecessorStart = parseDateOnly(predecessor.startDate);
+        const predecessorEnd = parseDateOnly(predecessor.endDate);
+        const constraintDate = calculateSuccessorDate(
+          predecessorStart,
+          predecessorEnd,
+          dep.type,
+          getDependencyLag(dep),
+          businessDays,
+          weekendPredicate
+        );
+        const candidateRange = dep.type === "FS" || dep.type === "SS" ? buildTaskRangeFromStart(constraintDate, duration, businessDays, weekendPredicate) : buildTaskRangeFromEnd(constraintDate, duration, businessDays, weekendPredicate);
+        if (!constrainedRange || candidateRange.start.getTime() > constrainedRange.start.getTime() || candidateRange.start.getTime() === constrainedRange.start.getTime() && candidateRange.end.getTime() > constrainedRange.end.getTime()) {
+          constrainedRange = candidateRange;
+        }
+      }
+      if (!constrainedRange) {
+        queue.push(successorId);
+        continue;
+      }
+      workingMap.set(successorId, {
+        ...currentTask,
+        startDate: toIsoDate(constrainedRange.start),
+        endDate: toIsoDate(constrainedRange.end)
+      });
+      queue.push(successorId);
+    }
+  }
+  const parentsByDepth = snapshot.filter((task) => isTaskParent(task.id, snapshot)).map((task) => {
+    let depth = 0;
+    let current = task.parentId ? workingMap.get(task.parentId) : void 0;
+    while (current) {
+      depth++;
+      current = current.parentId ? workingMap.get(current.parentId) : void 0;
+    }
+    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());
+    workingMap.set(taskId, {
+      ...parent,
+      startDate: toIsoDate(startDate),
+      endDate: toIsoDate(endDate)
+    });
+  }
+  return createChangedResult(snapshot, Array.from(workingMap.values()));
+}
+
 // src/core/scheduling/validation.ts
 function buildAdjacencyList(tasks) {
   const graph = /* @__PURE__ */ new Map();
@@ -1296,6 +1547,65 @@ function validateDependencies(tasks) {
   };
 }
 
+// src/adapters/scheduling/drag.ts
+init_dateMath();
+function resolveDateRangeFromPixels(mode, left, width, monthStart, dayWidth, task, businessDays, weekendPredicate) {
+  const dayOffset = Math.round(left / dayWidth);
+  const rawStartDate = new Date(Date.UTC(
+    monthStart.getUTCFullYear(),
+    monthStart.getUTCMonth(),
+    monthStart.getUTCDate() + dayOffset
+  ));
+  const rawEndOffset = dayOffset + Math.round(width / dayWidth) - 1;
+  const rawEndDate = new Date(Date.UTC(
+    monthStart.getUTCFullYear(),
+    monthStart.getUTCMonth(),
+    monthStart.getUTCDate() + rawEndOffset
+  ));
+  if (!(businessDays && weekendPredicate)) {
+    return { start: rawStartDate, end: rawEndDate };
+  }
+  if (mode === "move") {
+    const originalStart2 = new Date(task.startDate);
+    const snapDirection2 = rawStartDate.getTime() >= originalStart2.getTime() ? 1 : -1;
+    return moveTaskRange(
+      task.startDate,
+      task.endDate,
+      rawStartDate,
+      true,
+      weekendPredicate,
+      snapDirection2
+    );
+  }
+  if (mode === "resize-right") {
+    const fixedStart = new Date(task.startDate);
+    const originalEnd = new Date(task.endDate);
+    const snapDirection2 = rawEndDate.getTime() >= originalEnd.getTime() ? 1 : -1;
+    const alignedEnd = alignToWorkingDay(rawEndDate, snapDirection2, weekendPredicate);
+    const duration2 = Math.max(1, getBusinessDaysCount(fixedStart, alignedEnd, weekendPredicate));
+    return buildTaskRangeFromStart(fixedStart, duration2, true, weekendPredicate);
+  }
+  const fixedEnd = new Date(task.endDate);
+  const originalStart = new Date(task.startDate);
+  const snapDirection = rawStartDate.getTime() >= originalStart.getTime() ? 1 : -1;
+  const alignedStart = alignToWorkingDay(rawStartDate, snapDirection, weekendPredicate);
+  const duration = Math.max(1, getBusinessDaysCount(alignedStart, fixedEnd, weekendPredicate));
+  return buildTaskRangeFromEnd(fixedEnd, duration, true, weekendPredicate);
+}
+function clampDateRangeForIncomingFS(task, range, allTasks, mode, businessDays, weekendPredicate) {
+  if (mode === "resize-right") {
+    return range;
+  }
+  return clampTaskRangeForIncomingFS(
+    task,
+    range.start,
+    range.end,
+    allTasks,
+    businessDays,
+    weekendPredicate
+  );
+}
+
 // src/utils/hierarchyOrder.ts
 init_dateUtils();
 function flattenHierarchy(tasks) {
@@ -7133,6 +7443,7 @@ export {
   calculateWeekGridLines,
   calculateWeekendBlocks,
   cascadeByLinks,
+  clampDateRangeForIncomingFS,
   clampTaskRangeForIncomingFS,
   computeLagFromDates,
   computeParentDates,
@@ -7172,6 +7483,7 @@ export {
   isToday,
   isWeekend,
   moveTaskRange,
+  moveTaskWithCascade,
   nameContains,
   normalizeDependencyLag,
   normalizeHierarchyTasks,
@@ -7184,8 +7496,12 @@ export {
   pixelsToDate,
   progressInRange,
   recalculateIncomingLags,
+  recalculateProjectSchedule,
+  recalculateTaskFromDependencies,
   reflowTasksOnModeSwitch,
   removeDependenciesBetweenTasks,
+  resizeTaskWithCascade,
+  resolveDateRangeFromPixels,
   shiftBusinessDayOffset,
   subtractBusinessDays2 as subtractBusinessDays,
   universalCascade,