gantt-lib 0.60.0 → 0.60.2

package/dist/core/scheduling/index.mjs

@@ -0,0 +1,935 @@
+// src/core/scheduling/dateMath.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+function normalizeUTCDate(date) {
+  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+}
+function parseDateOnly(date) {
+  const parsed = typeof date === "string" ? /* @__PURE__ */ new Date(`${date.split("T")[0]}T00:00:00.000Z`) : normalizeUTCDate(date);
+  return normalizeUTCDate(parsed);
+}
+function getBusinessDayOffset(fromDate, toDate, weekendPredicate) {
+  const from = normalizeUTCDate(fromDate);
+  const to = normalizeUTCDate(toDate);
+  if (from.getTime() === to.getTime()) {
+    return 0;
+  }
+  const step = to.getTime() > from.getTime() ? 1 : -1;
+  const current = new Date(from);
+  let offset = 0;
+  while (current.getTime() !== to.getTime()) {
+    current.setUTCDate(current.getUTCDate() + step);
+    if (!weekendPredicate(current)) {
+      offset += step;
+    }
+  }
+  return offset;
+}
+function shiftBusinessDayOffset(date, offset, weekendPredicate) {
+  const current = normalizeUTCDate(date);
+  if (offset === 0) {
+    return current;
+  }
+  const step = offset > 0 ? 1 : -1;
+  let remaining = Math.abs(offset);
+  while (remaining > 0) {
+    current.setUTCDate(current.getUTCDate() + step);
+    if (!weekendPredicate(current)) {
+      remaining--;
+    }
+  }
+  return current;
+}
+function getBusinessDaysCount(startDate, endDate, weekendPredicate) {
+  const start = typeof startDate === "string" ? /* @__PURE__ */ new Date(`${startDate.split("T")[0]}T00:00:00.000Z`) : normalizeUTCDate(startDate);
+  const end = typeof endDate === "string" ? /* @__PURE__ */ new Date(`${endDate.split("T")[0]}T00:00:00.000Z`) : normalizeUTCDate(endDate);
+  let count = 0;
+  const current = new Date(start);
+  while (current.getTime() <= end.getTime()) {
+    if (!weekendPredicate(current)) {
+      count++;
+    }
+    current.setUTCDate(current.getUTCDate() + 1);
+  }
+  return Math.max(1, count);
+}
+function addBusinessDays(startDate, businessDays, weekendPredicate) {
+  const start = typeof startDate === "string" ? /* @__PURE__ */ new Date(`${startDate.split("T")[0]}T00:00:00.000Z`) : normalizeUTCDate(startDate);
+  const current = new Date(start);
+  let targetDays = Math.max(1, businessDays);
+  let businessDaysCounted = 0;
+  while (businessDaysCounted < targetDays) {
+    if (!weekendPredicate(current)) {
+      businessDaysCounted++;
+    }
+    if (businessDaysCounted < targetDays) {
+      current.setUTCDate(current.getUTCDate() + 1);
+    }
+  }
+  return current;
+}
+function subtractBusinessDays(endDate, businessDays, weekendPredicate) {
+  const end = typeof endDate === "string" ? /* @__PURE__ */ new Date(`${endDate.split("T")[0]}T00:00:00.000Z`) : normalizeUTCDate(endDate);
+  const current = new Date(end);
+  let targetDays = Math.max(1, businessDays);
+  let businessDaysCounted = 0;
+  while (businessDaysCounted < targetDays) {
+    if (!weekendPredicate(current)) {
+      businessDaysCounted++;
+    }
+    if (businessDaysCounted < targetDays) {
+      current.setUTCDate(current.getUTCDate() - 1);
+    }
+  }
+  return current;
+}
+function alignToWorkingDay(date, direction, weekendPredicate) {
+  const current = normalizeUTCDate(date);
+  while (weekendPredicate(current)) {
+    current.setUTCDate(current.getUTCDate() + direction);
+  }
+  return current;
+}
+function getTaskDuration(startDate, endDate, businessDays = false, weekendPredicate) {
+  const start = parseDateOnly(startDate);
+  const end = parseDateOnly(endDate);
+  if (businessDays && weekendPredicate) {
+    return getBusinessDaysCount(start, end, weekendPredicate);
+  }
+  return Math.max(1, Math.round((end.getTime() - start.getTime()) / DAY_MS) + 1);
+}
+
+// src/core/scheduling/dependencies.ts
+function getDependencyLag(dep) {
+  return Number.isFinite(dep.lag) ? dep.lag : 0;
+}
+function normalizeDependencyLag(linkType, lag, predecessorStart, predecessorEnd, businessDays = false, weekendPredicate) {
+  if (linkType !== "FS") {
+    return lag;
+  }
+  const predecessorDuration = getTaskDuration(
+    predecessorStart,
+    predecessorEnd,
+    businessDays,
+    weekendPredicate
+  );
+  return Math.max(-predecessorDuration, lag);
+}
+function computeLagFromDates(linkType, predStart, predEnd, succStart, succEnd, businessDays = false, weekendPredicate) {
+  const pS = Date.UTC(predStart.getUTCFullYear(), predStart.getUTCMonth(), predStart.getUTCDate());
+  const pE = Date.UTC(predEnd.getUTCFullYear(), predEnd.getUTCMonth(), predEnd.getUTCDate());
+  const sS = Date.UTC(succStart.getUTCFullYear(), succStart.getUTCMonth(), succStart.getUTCDate());
+  const sE = Date.UTC(succEnd.getUTCFullYear(), succEnd.getUTCMonth(), succEnd.getUTCDate());
+  if (!businessDays || !weekendPredicate) {
+    switch (linkType) {
+      case "FS":
+        return normalizeDependencyLag(
+          linkType,
+          Math.round((sS - pE) / DAY_MS) - 1,
+          predStart,
+          predEnd,
+          businessDays,
+          weekendPredicate
+        );
+      case "SS":
+        return Math.round((sS - pS) / DAY_MS);
+      case "FF":
+        return Math.round((sE - pE) / DAY_MS);
+      case "SF":
+        return Math.round((sE - pS) / DAY_MS) + 1;
+    }
+  }
+  const anchorDate = linkType === "SS" || linkType === "SF" ? predStart : predEnd;
+  const targetDate = linkType === "FS" || linkType === "SS" ? succStart : succEnd;
+  const businessOffset = getBusinessDayOffset(anchorDate, targetDate, weekendPredicate);
+  switch (linkType) {
+    case "FS":
+      return normalizeDependencyLag(
+        linkType,
+        businessOffset - 1,
+        predStart,
+        predEnd,
+        businessDays,
+        weekendPredicate
+      );
+    case "SS":
+      return businessOffset;
+    case "FF":
+      return businessOffset;
+    case "SF":
+      return businessOffset + 1;
+  }
+}
+function calculateSuccessorDate(predecessorStart, predecessorEnd, linkType, lag = 0, businessDays = false, weekendPredicate) {
+  const normalizedLag = normalizeDependencyLag(
+    linkType,
+    lag,
+    predecessorStart,
+    predecessorEnd,
+    businessDays,
+    weekendPredicate
+  );
+  if (!businessDays || !weekendPredicate) {
+    switch (linkType) {
+      case "FS":
+        return new Date(predecessorEnd.getTime() + (normalizedLag + 1) * DAY_MS);
+      case "SS":
+        return new Date(predecessorStart.getTime() + normalizedLag * DAY_MS);
+      case "FF":
+        return new Date(predecessorEnd.getTime() + normalizedLag * DAY_MS);
+      case "SF":
+        return new Date(predecessorStart.getTime() + (normalizedLag - 1) * DAY_MS);
+    }
+  }
+  const anchorDate = linkType === "FS" || linkType === "FF" ? predecessorEnd : predecessorStart;
+  let offset;
+  switch (linkType) {
+    case "FS":
+      offset = normalizedLag + 1;
+      break;
+    case "SS":
+      offset = normalizedLag;
+      break;
+    case "FF":
+      offset = normalizedLag;
+      break;
+    case "SF":
+      offset = normalizedLag - 1;
+      break;
+  }
+  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);
+  if (businessDays && weekendPredicate) {
+    return {
+      start: normalizedStart,
+      end: parseDateOnly(addBusinessDays(normalizedStart, duration, weekendPredicate))
+    };
+  }
+  const DAY_MS2 = 24 * 60 * 60 * 1e3;
+  return {
+    start: normalizedStart,
+    end: new Date(normalizedStart.getTime() + (Math.max(1, duration) - 1) * DAY_MS2)
+  };
+}
+function buildTaskRangeFromEnd(endDate, duration, businessDays = false, weekendPredicate, snapDirection = -1) {
+  const normalizedEnd = businessDays && weekendPredicate ? alignToWorkingDay(endDate, snapDirection, weekendPredicate) : normalizeUTCDate(endDate);
+  if (businessDays && weekendPredicate) {
+    return {
+      start: parseDateOnly(subtractBusinessDays(normalizedEnd, duration, weekendPredicate)),
+      end: normalizedEnd
+    };
+  }
+  const DAY_MS2 = 24 * 60 * 60 * 1e3;
+  return {
+    start: new Date(normalizedEnd.getTime() - (Math.max(1, duration) - 1) * DAY_MS2),
+    end: normalizedEnd
+  };
+}
+function moveTaskRange(originalStart, originalEnd, proposedStart, businessDays = false, weekendPredicate, snapDirection = 1) {
+  return buildTaskRangeFromStart(
+    proposedStart,
+    getTaskDuration(originalStart, originalEnd, businessDays, weekendPredicate),
+    businessDays,
+    weekendPredicate,
+    snapDirection
+  );
+}
+function clampTaskRangeForIncomingFS(task, proposedStart, proposedEnd, allTasks, businessDays = false, weekendPredicate) {
+  if (!task.dependencies?.length) {
+    return { start: proposedStart, end: proposedEnd };
+  }
+  let minAllowedStart = null;
+  for (const dep of task.dependencies) {
+    if (dep.type !== "FS") {
+      continue;
+    }
+    const predecessor = allTasks.find((candidate) => candidate.id === dep.taskId);
+    if (!predecessor) {
+      continue;
+    }
+    const predecessorStart = parseDateOnly(predecessor.startDate);
+    const predecessorEnd = parseDateOnly(predecessor.endDate);
+    const predecessorDuration = getTaskDuration(
+      predecessorStart,
+      predecessorEnd,
+      businessDays,
+      weekendPredicate
+    );
+    const candidateMinStart = calculateSuccessorDate(
+      predecessorStart,
+      predecessorEnd,
+      "FS",
+      -predecessorDuration,
+      businessDays,
+      weekendPredicate
+    );
+    if (!minAllowedStart || candidateMinStart.getTime() > minAllowedStart.getTime()) {
+      minAllowedStart = candidateMinStart;
+    }
+  }
+  if (!minAllowedStart || proposedStart.getTime() >= minAllowedStart.getTime()) {
+    return { start: proposedStart, end: proposedEnd };
+  }
+  return buildTaskRangeFromStart(
+    minAllowedStart,
+    getTaskDuration(proposedStart, proposedEnd, businessDays, weekendPredicate),
+    businessDays,
+    weekendPredicate
+  );
+}
+function recalculateIncomingLags(task, newStartDate, newEndDate, allTasks, businessDays = false, weekendPredicate) {
+  if (!task.dependencies) return [];
+  return task.dependencies.map((dep) => {
+    const predecessor = allTasks.find((candidate) => candidate.id === dep.taskId);
+    if (!predecessor) {
+      return { ...dep, lag: getDependencyLag(dep) };
+    }
+    const predecessorStart = new Date(predecessor.startDate);
+    const predecessorEnd = new Date(predecessor.endDate);
+    const nextLag = computeLagFromDates(
+      dep.type,
+      predecessorStart,
+      predecessorEnd,
+      newStartDate,
+      newEndDate,
+      businessDays,
+      weekendPredicate
+    );
+    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"]) {
+  const successorMap = /* @__PURE__ */ new Map();
+  for (const task of allTasks) {
+    successorMap.set(task.id, []);
+  }
+  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);
+      }
+    }
+  }
+  const taskById = new Map(allTasks.map((t) => [t.id, t]));
+  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) {
+      if (!visited.has(sid)) {
+        visited.add(sid);
+        const t = taskById.get(sid);
+        if (t) {
+          chain.push(t);
+          queue.push(sid);
+        }
+      }
+    }
+  }
+  return chain;
+}
+function cascadeByLinks(movedTaskId, newStart, newEnd, allTasks, skipChildCascade = false) {
+  const taskById = new Map(allTasks.map((t) => [t.id, t]));
+  const updatedDates = /* @__PURE__ */ new Map();
+  updatedDates.set(movedTaskId, { start: newStart, end: newEnd });
+  const result = [];
+  const queue = [movedTaskId];
+  const visited = /* @__PURE__ */ new Set([movedTaskId]);
+  while (queue.length > 0) {
+    const currentId = queue.shift();
+    const { start: predStart, end: predEnd } = updatedDates.get(currentId);
+    if (!skipChildCascade) {
+      const children = getChildren(currentId, allTasks);
+      for (const child of children) {
+        if (visited.has(child.id) || child.locked) continue;
+        const origStart = new Date(child.startDate);
+        const origEnd = new Date(child.endDate);
+        const durationMs = origEnd.getTime() - origStart.getTime();
+        const parentOrig = taskById.get(currentId);
+        const parentOrigStart = new Date(parentOrig.startDate);
+        const parentOrigEnd = new Date(parentOrig.endDate);
+        const parentStartDelta = predStart.getTime() - parentOrigStart.getTime();
+        const parentEndDelta = predEnd.getTime() - parentOrigEnd.getTime();
+        const newChildStart = new Date(origStart.getTime() + parentStartDelta);
+        const newChildEnd = new Date(origEnd.getTime() + parentEndDelta);
+        visited.add(child.id);
+        updatedDates.set(child.id, { start: newChildStart, end: newChildEnd });
+        result.push({
+          ...child,
+          startDate: newChildStart.toISOString().split("T")[0],
+          endDate: newChildEnd.toISOString().split("T")[0]
+        });
+        queue.push(child.id);
+      }
+    }
+    for (const task of allTasks) {
+      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 constraintDate = calculateSuccessorDate(predStart, predEnd, 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({
+          ...task,
+          startDate: newSuccStart.toISOString().split("T")[0],
+          endDate: newSuccEnd.toISOString().split("T")[0]
+        });
+        queue.push(task.id);
+        break;
+      }
+    }
+  }
+  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 directSuccessors = getSuccessorChain(changedTaskId, allTasks, firstLevelLinkTypes);
+  const initialChain = [...directChildren, ...directSuccessors].filter(
+    (task, index, arr) => arr.findIndex((candidate) => candidate.id === task.id) === index
+  );
+  const chain = [...initialChain];
+  const visited = /* @__PURE__ */ new Set([changedTaskId, ...initialChain.map((t) => t.id)]);
+  const queue = [...initialChain];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const children = getChildren(current.id, allTasks);
+    for (const child of children) {
+      if (!visited.has(child.id)) {
+        visited.add(child.id);
+        chain.push(child);
+        queue.push(child);
+      }
+    }
+    const successors = allTypesSuccessorMap.get(current.id) ?? [];
+    for (const successor of successors) {
+      if (!visited.has(successor.id)) {
+        visited.add(successor.id);
+        chain.push(successor);
+        queue.push(successor);
+      }
+    }
+  }
+  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, {
+    ...movedTask,
+    startDate: newStart.toISOString().split("T")[0],
+    endDate: newEnd.toISOString().split("T")[0]
+  });
+  const queue = [[movedTask.id, "direct"]];
+  const childShifted = /* @__PURE__ */ new Set();
+  let iterations = 0;
+  const MAX_ITERATIONS = allTasks.length * 3;
+  while (queue.length > 0 && iterations < MAX_ITERATIONS) {
+    iterations++;
+    const [currentId, arrivalMode] = queue.shift();
+    const { start: currStart, end: currEnd } = updatedDates.get(currentId);
+    const currentOriginal = taskById.get(currentId);
+    if (arrivalMode !== "parent-recalc") {
+      const children = getChildren(currentId, allTasks);
+      for (const child of children) {
+        if (childShifted.has(child.id) || child.locked) continue;
+        const parentOrigStart = new Date(currentOriginal.startDate);
+        const parentOrigEnd = new Date(currentOriginal.endDate);
+        const childOrigStart = new Date(child.startDate);
+        const childOrigEnd = new Date(child.endDate);
+        const startDeltaMs = currStart.getTime() - parentOrigStart.getTime();
+        const endDeltaMs = currEnd.getTime() - parentOrigEnd.getTime();
+        let childNewStart;
+        let childNewEnd;
+        if (businessDays && weekendPredicate) {
+          const proposedStart = new Date(childOrigStart.getTime() + startDeltaMs);
+          const snapDirection = currStart.getTime() >= parentOrigStart.getTime() ? 1 : -1;
+          const movedRange = moveTaskRange(
+            child.startDate,
+            child.endDate,
+            proposedStart,
+            true,
+            weekendPredicate,
+            snapDirection
+          );
+          childNewStart = movedRange.start;
+          childNewEnd = movedRange.end;
+        } else {
+          childNewStart = new Date(childOrigStart.getTime() + startDeltaMs);
+          childNewEnd = new Date(childOrigEnd.getTime() + endDeltaMs);
+        }
+        const prev = updatedDates.get(child.id);
+        if (prev && prev.start.getTime() === childNewStart.getTime() && prev.end.getTime() === childNewEnd.getTime()) {
+          continue;
+        }
+        updatedDates.set(child.id, { start: childNewStart, end: childNewEnd });
+        childShifted.add(child.id);
+        queue.push([child.id, "child-delta"]);
+        resultMap.set(child.id, {
+          ...child,
+          startDate: childNewStart.toISOString().split("T")[0],
+          endDate: childNewEnd.toISOString().split("T")[0]
+        });
+      }
+    }
+    const parentId = currentOriginal.parentId;
+    if (parentId) {
+      const parent = taskById.get(parentId);
+      if (parent && !parent.locked) {
+        const siblings = getChildren(parentId, allTasks);
+        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) };
+        });
+        const minStart = new Date(Math.min(...siblingPositions.map((p) => p.start.getTime())));
+        const maxEnd = new Date(Math.max(...siblingPositions.map((p) => p.end.getTime())));
+        const prev = updatedDates.get(parentId);
+        if (!prev || prev.start.getTime() !== minStart.getTime() || prev.end.getTime() !== maxEnd.getTime()) {
+          updatedDates.set(parentId, { start: minStart, end: maxEnd });
+          queue.push([parentId, "parent-recalc"]);
+          resultMap.set(parentId, {
+            ...parent,
+            startDate: minStart.toISOString().split("T")[0],
+            endDate: maxEnd.toISOString().split("T")[0]
+          });
+        }
+      }
+    }
+    for (const task of allTasks) {
+      if (task.locked || !task.dependencies) continue;
+      const dep = task.dependencies.find((d) => d.taskId === currentId);
+      if (!dep) continue;
+      const origStart = new Date(task.startDate);
+      const origEnd = new Date(task.endDate);
+      const constraintDate = calculateSuccessorDate(
+        currStart,
+        currEnd,
+        dep.type,
+        getDependencyLag(dep),
+        businessDays,
+        weekendPredicate
+      );
+      let succNewStart;
+      let succNewEnd;
+      const duration = getTaskDuration(origStart, origEnd, businessDays, weekendPredicate);
+      if (dep.type === "FS" || dep.type === "SS") {
+        ({ start: succNewStart, end: succNewEnd } = buildTaskRangeFromStart(
+          constraintDate,
+          duration,
+          businessDays,
+          weekendPredicate
+        ));
+      } else {
+        ({ start: succNewStart, end: succNewEnd } = buildTaskRangeFromEnd(
+          constraintDate,
+          duration,
+          businessDays,
+          weekendPredicate
+        ));
+      }
+      const prev = updatedDates.get(task.id);
+      if (prev && prev.start.getTime() === succNewStart.getTime() && prev.end.getTime() === succNewEnd.getTime()) {
+        continue;
+      }
+      updatedDates.set(task.id, { start: succNewStart, end: succNewEnd });
+      queue.push([task.id, "dependency"]);
+      resultMap.set(task.id, {
+        ...task,
+        startDate: succNewStart.toISOString().split("T")[0],
+        endDate: succNewEnd.toISOString().split("T")[0]
+      });
+    }
+  }
+  return Array.from(resultMap.values());
+}
+function reflowTasksOnModeSwitch(sourceTasks, toBusinessDays, weekendPredicate) {
+  const fromBusinessDays = !toBusinessDays;
+  let tasks = sourceTasks.map((t) => ({ ...t }));
+  const toISO = (d) => d.toISOString().split("T")[0];
+  for (const task of tasks) {
+    if (isTaskParent(task.id, tasks)) continue;
+    const start = normalizeUTCDate(/* @__PURE__ */ new Date(`${task.startDate}T00:00:00.000Z`));
+    const duration = getTaskDuration(task.startDate, task.endDate, fromBusinessDays, weekendPredicate);
+    let range;
+    if (toBusinessDays) {
+      const alignedStart = alignToWorkingDay(start, 1, weekendPredicate);
+      range = buildTaskRangeFromStart(alignedStart, duration, true, weekendPredicate);
+    } else {
+      range = buildTaskRangeFromStart(start, duration, false);
+    }
+    task.startDate = toISO(range.start);
+    task.endDate = toISO(range.end);
+  }
+  for (const task of tasks) {
+    if (!isTaskParent(task.id, tasks)) continue;
+    const { startDate, endDate } = computeParentDates(task.id, tasks);
+    task.startDate = toISO(startDate);
+    task.endDate = toISO(endDate);
+  }
+  if (toBusinessDays) {
+    const rootSeeds = tasks.filter(
+      (t) => !t.parentId && (!t.dependencies || t.dependencies.length === 0)
+    );
+    for (const seed of rootSeeds) {
+      const current = tasks.find((t) => t.id === seed.id);
+      const start = /* @__PURE__ */ new Date(`${current.startDate}T00:00:00.000Z`);
+      const end = /* @__PURE__ */ new Date(`${current.endDate}T00:00:00.000Z`);
+      const cascaded = universalCascade(current, start, end, tasks, toBusinessDays, weekendPredicate);
+      const updates = new Map(cascaded.map((t) => [t.id, t]));
+      tasks = tasks.map((t) => updates.get(t.id) ?? t);
+    }
+  }
+  return tasks;
+}
+
+// src/core/scheduling/validation.ts
+function buildAdjacencyList(tasks) {
+  const graph = /* @__PURE__ */ new Map();
+  for (const task of tasks) {
+    const successors = [];
+    for (const otherTask of tasks) {
+      if (otherTask.dependencies) {
+        for (const dep of otherTask.dependencies) {
+          if (dep.taskId === task.id) {
+            successors.push(otherTask.id);
+            break;
+          }
+        }
+      }
+    }
+    graph.set(task.id, successors);
+  }
+  return graph;
+}
+function detectCycles(tasks) {
+  const graph = buildAdjacencyList(tasks);
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const path = [];
+  function dfs(taskId) {
+    if (visiting.has(taskId)) {
+      return true;
+    }
+    if (visited.has(taskId)) {
+      return false;
+    }
+    visiting.add(taskId);
+    path.push(taskId);
+    const successors = graph.get(taskId) || [];
+    for (const successor of successors) {
+      if (dfs(successor)) {
+        return true;
+      }
+    }
+    visiting.delete(taskId);
+    path.pop();
+    visited.add(taskId);
+    return false;
+  }
+  for (const task of tasks) {
+    if (dfs(task.id)) {
+      return { hasCycle: true, cyclePath: [...path] };
+    }
+  }
+  return { hasCycle: false };
+}
+function validateDependencies(tasks) {
+  const errors = [];
+  const taskIds = new Set(tasks.map((t) => t.id));
+  for (const task of tasks) {
+    if (task.dependencies) {
+      for (const dep of task.dependencies) {
+        if (!taskIds.has(dep.taskId)) {
+          errors.push({
+            type: "missing-task",
+            taskId: task.id,
+            message: `Dependency references non-existent task: ${dep.taskId}`,
+            relatedTaskIds: [dep.taskId]
+          });
+        }
+      }
+    }
+  }
+  for (const task of tasks) {
+    if (!task.dependencies) continue;
+    for (const dep of task.dependencies) {
+      if (!taskIds.has(dep.taskId)) {
+        continue;
+      }
+      if (areTasksHierarchicallyRelated(task.id, dep.taskId, tasks)) {
+        errors.push({
+          type: "constraint",
+          taskId: task.id,
+          message: `Dependencies between parent and child tasks are not allowed: ${dep.taskId} -> ${task.id}`,
+          relatedTaskIds: [dep.taskId, task.id]
+        });
+      }
+    }
+  }
+  const cycleResult = detectCycles(tasks);
+  if (cycleResult.hasCycle && cycleResult.cyclePath) {
+    errors.push({
+      type: "cycle",
+      taskId: cycleResult.cyclePath[0],
+      message: "Circular dependency detected",
+      relatedTaskIds: cycleResult.cyclePath
+    });
+  }
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+export {
+  DAY_MS,
+  addBusinessDays,
+  alignToWorkingDay,
+  areTasksHierarchicallyRelated,
+  buildAdjacencyList,
+  buildTaskRangeFromEnd,
+  buildTaskRangeFromStart,
+  calculateSuccessorDate,
+  cascadeByLinks,
+  clampDateRangeForIncomingFS,
+  clampTaskRangeForIncomingFS,
+  computeLagFromDates,
+  computeParentDates,
+  computeParentProgress,
+  detectCycles,
+  findParentId,
+  getAllDependencyEdges,
+  getAllDescendants,
+  getBusinessDayOffset,
+  getBusinessDaysCount,
+  getChildren,
+  getDependencyLag,
+  getSuccessorChain,
+  getTaskDuration,
+  getTransitiveCascadeChain,
+  isAncestorTask,
+  isTaskParent,
+  moveTaskRange,
+  normalizeDependencyLag,
+  normalizeUTCDate,
+  parseDateOnly,
+  recalculateIncomingLags,
+  reflowTasksOnModeSwitch,
+  removeDependenciesBetweenTasks,
+  resolveDateRangeFromPixels,
+  shiftBusinessDayOffset,
+  subtractBusinessDays,
+  universalCascade,
+  validateDependencies
+};
+//# sourceMappingURL=index.mjs.map