gantt-lib 0.60.2 → 0.62.0

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import React$1, { ReactNode } from 'react';
-import { T as Task$1, V as ValidationResult } from './index-CliEEiHA.mjs';
-export { D as DAY_MS, a as DependencyError, G as GanttDateRange, b as GridConfig, c as GridLine, L as LinkType, M as MonthSpan, d as TaskBarGeometry, W as WeekendBlock, e as alignToWorkingDay, f as areTasksHierarchicallyRelated, g as buildAdjacencyList, h as buildTaskRangeFromEnd, i as buildTaskRangeFromStart, j as calculateSuccessorDate, k as cascadeByLinks, l as clampTaskRangeForIncomingFS, m as computeLagFromDates, n as computeParentDates, o as computeParentProgress, p as detectCycles, q as findParentId, r as getAllDependencyEdges, s as getAllDescendants, t as getBusinessDayOffset, u as getChildren, v as getDependencyLag, w as getSuccessorChain, x as getTaskDuration, y as getTransitiveCascadeChain, z as isAncestorTask, A as isTaskParent, B as moveTaskRange, C as normalizeDependencyLag, E as normalizeUTCDate, F as parseDateOnly, H as recalculateIncomingLags, I as reflowTasksOnModeSwitch, J as removeDependenciesBetweenTasks, K as shiftBusinessDayOffset, N as universalCascade, O as validateDependencies } from './index-CliEEiHA.mjs';
+import { T as Task$1, V as ValidationResult } from './index-DMA7NbWe.mjs';
+export { D as DAY_MS, a as DependencyError, G as GanttDateRange, b as GridConfig, c as GridLine, L as LinkType, M as MonthSpan, d as TaskBarGeometry, W as WeekendBlock, e as alignToWorkingDay, f as areTasksHierarchicallyRelated, g as buildAdjacencyList, h as buildTaskRangeFromEnd, i as buildTaskRangeFromStart, j as calculateSuccessorDate, k as cascadeByLinks, l as clampTaskRangeForIncomingFS, m as computeLagFromDates, n as computeParentDates, o as computeParentProgress, p as detectCycles, q as findParentId, r as getAllDependencyEdges, s as getAllDescendants, t as getBusinessDayOffset, u as getChildren, v as getDependencyLag, w as getSuccessorChain, x as getTaskDuration, y as getTransitiveCascadeChain, z as isAncestorTask, A as isTaskParent, B as moveTaskRange, C as moveTaskWithCascade, E as normalizeDependencyLag, F as normalizeUTCDate, H as parseDateOnly, I as recalculateIncomingLags, J as recalculateProjectSchedule, K as recalculateTaskFromDependencies, N as reflowTasksOnModeSwitch, O as removeDependenciesBetweenTasks, P as resizeTaskWithCascade, Q as shiftBusinessDayOffset, R as universalCascade, S as validateDependencies } from './index-DMA7NbWe.mjs';
 import * as RadixPopover from '@radix-ui/react-popover';
 
 /**
@@ -863,6 +863,40 @@ interface UseTaskDragReturn {
  */
 declare const useTaskDrag: (options: UseTaskDragOptions) => UseTaskDragReturn;
 
+/**
+ * UI adapter: converts pixel coordinates to date ranges for drag interactions.
+ * @module adapters/scheduling
+ *
+ * These functions bridge the chart's pixel-space (left, width, dayWidth)
+ * with the scheduling domain's date-space. They depend on core scheduling
+ * primitives but are NOT part of the domain core themselves.
+ */
+
+/**
+ * Convert pixel coordinates to a date range, applying business-day alignment
+ * when businessDays mode is active. This is the pure scheduling core of
+ * drag-to-date conversion.
+ *
+ * Extracted from useTaskDrag.ts resolveDraggedRange.
+ */
+declare function resolveDateRangeFromPixels(mode: 'move' | 'resize-left' | 'resize-right', left: number, width: number, monthStart: Date, dayWidth: number, task: Task$1, businessDays?: boolean, weekendPredicate?: (date: Date) => boolean): {
+    start: Date;
+    end: Date;
+};
+/**
+ * Clamp a proposed date range based on incoming FS dependencies.
+ * For resize-right mode, returns range unchanged (only start is clamped).
+ *
+ * Extracted from useTaskDrag.ts clampDraggedRangeForIncomingFS.
+ */
+declare function clampDateRangeForIncomingFS(task: Task$1, range: {
+    start: Date;
+    end: Date;
+}, allTasks: Task$1[], mode: 'move' | 'resize-left' | 'resize-right', businessDays?: boolean, weekendPredicate?: (date: Date) => boolean): {
+    start: Date;
+    end: Date;
+};
+
 /**
  * Checks whether a task is behind the expected progress for the current date.
  * Uses the same progress-based rule as expired task highlighting in TaskRow.
@@ -1051,4 +1085,4 @@ interface VisibleReorderPosition {
  */
 declare function getVisibleReorderPosition(orderedTasks: TaskLike[], visibleTasks: TaskLike[], movedTaskId: string, originVisibleIndex: number, dropVisibleIndex: number): VisibleReorderPosition | null;
 
-export { type BuiltInTaskListColumnId, Button, type ButtonProps, Calendar, type CalendarProps, type CustomDayConfig, type CustomDayPredicateConfig, DatePicker, type DatePickerProps, DragGuideLines, GanttChart, type GanttChartHandle, type GanttChartProps, GridBackground, Input, type InputProps, type MonthBlock, Popover, PopoverContent, type PopoverContentProps, type PopoverProps, PopoverTrigger, type Task, type TaskDependency, TaskList, type TaskListColumn, type TaskListColumnContext, type TaskListProps, type TaskPredicate, TaskRow, TimeScaleHeader, TodayIndicator, ValidationResult, type VisibleReorderPosition, type WeekBlock, type WeekSpan, type YearSpan, addBusinessDays, and, calculateBezierPath, calculateDependencyPath, calculateGridLines, calculateGridWidth, calculateMonthGridLines, calculateOrthogonalPath, calculateTaskBar, calculateWeekGridLines, calculateWeekendBlocks, createCustomDayPredicate, createDateKey, detectEdgeZone, expired, flattenHierarchy, formatDateLabel, formatDateRangeLabel, getBusinessDaysCount, getCursorForPosition, getDayOffset, getMonthBlocks, getMonthDays, getMonthSpans, getMultiMonthDays, getVisibleReorderPosition, getWeekBlocks, getWeekSpans, getYearSpans, inDateRange, isTaskExpired, isToday, isWeekend, nameContains, normalizeHierarchyTasks, normalizeTaskDates, not, or, parseUTCDate, pixelsToDate, progressInRange, subtractBusinessDays, useTaskDrag, withoutDeps };
+export { type BuiltInTaskListColumnId, Button, type ButtonProps, Calendar, type CalendarProps, type CustomDayConfig, type CustomDayPredicateConfig, DatePicker, type DatePickerProps, DragGuideLines, GanttChart, type GanttChartHandle, type GanttChartProps, GridBackground, Input, type InputProps, type MonthBlock, Popover, PopoverContent, type PopoverContentProps, type PopoverProps, PopoverTrigger, type Task, type TaskDependency, TaskList, type TaskListColumn, type TaskListColumnContext, type TaskListProps, type TaskPredicate, TaskRow, TimeScaleHeader, TodayIndicator, ValidationResult, type VisibleReorderPosition, type WeekBlock, type WeekSpan, type YearSpan, addBusinessDays, and, calculateBezierPath, calculateDependencyPath, calculateGridLines, calculateGridWidth, calculateMonthGridLines, calculateOrthogonalPath, calculateTaskBar, calculateWeekGridLines, calculateWeekendBlocks, clampDateRangeForIncomingFS, createCustomDayPredicate, createDateKey, detectEdgeZone, expired, flattenHierarchy, formatDateLabel, formatDateRangeLabel, getBusinessDaysCount, getCursorForPosition, getDayOffset, getMonthBlocks, getMonthDays, getMonthSpans, getMultiMonthDays, getVisibleReorderPosition, getWeekBlocks, getWeekSpans, getYearSpans, inDateRange, isTaskExpired, isToday, isWeekend, nameContains, normalizeHierarchyTasks, normalizeTaskDates, not, or, parseUTCDate, pixelsToDate, progressInRange, resolveDateRangeFromPixels, subtractBusinessDays, useTaskDrag, withoutDeps };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import React$1, { ReactNode } from 'react';
-import { T as Task$1, V as ValidationResult } from './index-CliEEiHA.js';
-export { D as DAY_MS, a as DependencyError, G as GanttDateRange, b as GridConfig, c as GridLine, L as LinkType, M as MonthSpan, d as TaskBarGeometry, W as WeekendBlock, e as alignToWorkingDay, f as areTasksHierarchicallyRelated, g as buildAdjacencyList, h as buildTaskRangeFromEnd, i as buildTaskRangeFromStart, j as calculateSuccessorDate, k as cascadeByLinks, l as clampTaskRangeForIncomingFS, m as computeLagFromDates, n as computeParentDates, o as computeParentProgress, p as detectCycles, q as findParentId, r as getAllDependencyEdges, s as getAllDescendants, t as getBusinessDayOffset, u as getChildren, v as getDependencyLag, w as getSuccessorChain, x as getTaskDuration, y as getTransitiveCascadeChain, z as isAncestorTask, A as isTaskParent, B as moveTaskRange, C as normalizeDependencyLag, E as normalizeUTCDate, F as parseDateOnly, H as recalculateIncomingLags, I as reflowTasksOnModeSwitch, J as removeDependenciesBetweenTasks, K as shiftBusinessDayOffset, N as universalCascade, O as validateDependencies } from './index-CliEEiHA.js';
+import { T as Task$1, V as ValidationResult } from './index-DMA7NbWe.js';
+export { D as DAY_MS, a as DependencyError, G as GanttDateRange, b as GridConfig, c as GridLine, L as LinkType, M as MonthSpan, d as TaskBarGeometry, W as WeekendBlock, e as alignToWorkingDay, f as areTasksHierarchicallyRelated, g as buildAdjacencyList, h as buildTaskRangeFromEnd, i as buildTaskRangeFromStart, j as calculateSuccessorDate, k as cascadeByLinks, l as clampTaskRangeForIncomingFS, m as computeLagFromDates, n as computeParentDates, o as computeParentProgress, p as detectCycles, q as findParentId, r as getAllDependencyEdges, s as getAllDescendants, t as getBusinessDayOffset, u as getChildren, v as getDependencyLag, w as getSuccessorChain, x as getTaskDuration, y as getTransitiveCascadeChain, z as isAncestorTask, A as isTaskParent, B as moveTaskRange, C as moveTaskWithCascade, E as normalizeDependencyLag, F as normalizeUTCDate, H as parseDateOnly, I as recalculateIncomingLags, J as recalculateProjectSchedule, K as recalculateTaskFromDependencies, N as reflowTasksOnModeSwitch, O as removeDependenciesBetweenTasks, P as resizeTaskWithCascade, Q as shiftBusinessDayOffset, R as universalCascade, S as validateDependencies } from './index-DMA7NbWe.js';
 import * as RadixPopover from '@radix-ui/react-popover';
 
 /**
@@ -863,6 +863,40 @@ interface UseTaskDragReturn {
  */
 declare const useTaskDrag: (options: UseTaskDragOptions) => UseTaskDragReturn;
 
+/**
+ * UI adapter: converts pixel coordinates to date ranges for drag interactions.
+ * @module adapters/scheduling
+ *
+ * These functions bridge the chart's pixel-space (left, width, dayWidth)
+ * with the scheduling domain's date-space. They depend on core scheduling
+ * primitives but are NOT part of the domain core themselves.
+ */
+
+/**
+ * Convert pixel coordinates to a date range, applying business-day alignment
+ * when businessDays mode is active. This is the pure scheduling core of
+ * drag-to-date conversion.
+ *
+ * Extracted from useTaskDrag.ts resolveDraggedRange.
+ */
+declare function resolveDateRangeFromPixels(mode: 'move' | 'resize-left' | 'resize-right', left: number, width: number, monthStart: Date, dayWidth: number, task: Task$1, businessDays?: boolean, weekendPredicate?: (date: Date) => boolean): {
+    start: Date;
+    end: Date;
+};
+/**
+ * Clamp a proposed date range based on incoming FS dependencies.
+ * For resize-right mode, returns range unchanged (only start is clamped).
+ *
+ * Extracted from useTaskDrag.ts clampDraggedRangeForIncomingFS.
+ */
+declare function clampDateRangeForIncomingFS(task: Task$1, range: {
+    start: Date;
+    end: Date;
+}, allTasks: Task$1[], mode: 'move' | 'resize-left' | 'resize-right', businessDays?: boolean, weekendPredicate?: (date: Date) => boolean): {
+    start: Date;
+    end: Date;
+};
+
 /**
  * Checks whether a task is behind the expected progress for the current date.
  * Uses the same progress-based rule as expired task highlighting in TaskRow.
@@ -1051,4 +1085,4 @@ interface VisibleReorderPosition {
  */
 declare function getVisibleReorderPosition(orderedTasks: TaskLike[], visibleTasks: TaskLike[], movedTaskId: string, originVisibleIndex: number, dropVisibleIndex: number): VisibleReorderPosition | null;
 
-export { type BuiltInTaskListColumnId, Button, type ButtonProps, Calendar, type CalendarProps, type CustomDayConfig, type CustomDayPredicateConfig, DatePicker, type DatePickerProps, DragGuideLines, GanttChart, type GanttChartHandle, type GanttChartProps, GridBackground, Input, type InputProps, type MonthBlock, Popover, PopoverContent, type PopoverContentProps, type PopoverProps, PopoverTrigger, type Task, type TaskDependency, TaskList, type TaskListColumn, type TaskListColumnContext, type TaskListProps, type TaskPredicate, TaskRow, TimeScaleHeader, TodayIndicator, ValidationResult, type VisibleReorderPosition, type WeekBlock, type WeekSpan, type YearSpan, addBusinessDays, and, calculateBezierPath, calculateDependencyPath, calculateGridLines, calculateGridWidth, calculateMonthGridLines, calculateOrthogonalPath, calculateTaskBar, calculateWeekGridLines, calculateWeekendBlocks, createCustomDayPredicate, createDateKey, detectEdgeZone, expired, flattenHierarchy, formatDateLabel, formatDateRangeLabel, getBusinessDaysCount, getCursorForPosition, getDayOffset, getMonthBlocks, getMonthDays, getMonthSpans, getMultiMonthDays, getVisibleReorderPosition, getWeekBlocks, getWeekSpans, getYearSpans, inDateRange, isTaskExpired, isToday, isWeekend, nameContains, normalizeHierarchyTasks, normalizeTaskDates, not, or, parseUTCDate, pixelsToDate, progressInRange, subtractBusinessDays, useTaskDrag, withoutDeps };
+export { type BuiltInTaskListColumnId, Button, type ButtonProps, Calendar, type CalendarProps, type CustomDayConfig, type CustomDayPredicateConfig, DatePicker, type DatePickerProps, DragGuideLines, GanttChart, type GanttChartHandle, type GanttChartProps, GridBackground, Input, type InputProps, type MonthBlock, Popover, PopoverContent, type PopoverContentProps, type PopoverProps, PopoverTrigger, type Task, type TaskDependency, TaskList, type TaskListColumn, type TaskListColumnContext, type TaskListProps, type TaskPredicate, TaskRow, TimeScaleHeader, TodayIndicator, ValidationResult, type VisibleReorderPosition, type WeekBlock, type WeekSpan, type YearSpan, addBusinessDays, and, calculateBezierPath, calculateDependencyPath, calculateGridLines, calculateGridWidth, calculateMonthGridLines, calculateOrthogonalPath, calculateTaskBar, calculateWeekGridLines, calculateWeekendBlocks, clampDateRangeForIncomingFS, createCustomDayPredicate, createDateKey, detectEdgeZone, expired, flattenHierarchy, formatDateLabel, formatDateRangeLabel, getBusinessDaysCount, getCursorForPosition, getDayOffset, getMonthBlocks, getMonthDays, getMonthSpans, getMultiMonthDays, getVisibleReorderPosition, getWeekBlocks, getWeekSpans, getYearSpans, inDateRange, isTaskExpired, isToday, isWeekend, nameContains, normalizeHierarchyTasks, normalizeTaskDates, not, or, parseUTCDate, pixelsToDate, progressInRange, resolveDateRangeFromPixels, subtractBusinessDays, useTaskDrag, withoutDeps };

package/dist/index.js

@@ -537,6 +537,7 @@ __export(index_exports, {
   calculateWeekGridLines: () => calculateWeekGridLines,
   calculateWeekendBlocks: () => calculateWeekendBlocks,
   cascadeByLinks: () => cascadeByLinks,
+  clampDateRangeForIncomingFS: () => clampDateRangeForIncomingFS,
   clampTaskRangeForIncomingFS: () => clampTaskRangeForIncomingFS,
   computeLagFromDates: () => computeLagFromDates,
   computeParentDates: () => computeParentDates,
@@ -576,6 +577,7 @@ __export(index_exports, {
   isToday: () => isToday,
   isWeekend: () => isWeekend,
   moveTaskRange: () => moveTaskRange,
+  moveTaskWithCascade: () => moveTaskWithCascade,
   nameContains: () => nameContains,
   normalizeDependencyLag: () => normalizeDependencyLag,
   normalizeHierarchyTasks: () => normalizeHierarchyTasks,
@@ -588,8 +590,12 @@ __export(index_exports, {
   pixelsToDate: () => pixelsToDate,
   progressInRange: () => progressInRange,
   recalculateIncomingLags: () => recalculateIncomingLags,
+  recalculateProjectSchedule: () => recalculateProjectSchedule,
+  recalculateTaskFromDependencies: () => recalculateTaskFromDependencies,
   reflowTasksOnModeSwitch: () => reflowTasksOnModeSwitch,
   removeDependenciesBetweenTasks: () => removeDependenciesBetweenTasks,
+  resizeTaskWithCascade: () => resizeTaskWithCascade,
+  resolveDateRangeFromPixels: () => resolveDateRangeFromPixels,
   shiftBusinessDayOffset: () => shiftBusinessDayOffset,
   subtractBusinessDays: () => subtractBusinessDays2,
   universalCascade: () => universalCascade,
@@ -934,62 +940,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"]) {
@@ -1306,6 +1256,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();
@@ -1886,6 +2143,67 @@ var isTaskExpired = (task, referenceDate = /* @__PURE__ */ new Date()) => {
 
 // src/hooks/useTaskDrag.ts
 var import_react2 = require("react");
+
+// 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/hooks/useTaskDrag.ts
 var globalActiveDrag = null;
 var globalRafId = null;
 function getDayOffsetFromMonthStart(date, monthStart) {
@@ -6803,8 +7121,11 @@ function GanttChartInner(props, ref) {
       });
     }
     const normalized = normalizeHierarchyTasks(updated);
+    if (onReorder) {
+      onReorder(normalized, movedTaskId, inferredParentId);
+      return;
+    }
     onTasksChange?.(normalized);
-    onReorder?.(normalized, movedTaskId, inferredParentId);
   }, [onTasksChange, onReorder]);
   const dependencyOverrides = (0, import_react13.useMemo)(() => {
     const map = new Map(cascadeOverrides);
@@ -7219,6 +7540,7 @@ var nameContains = (substring, caseSensitive = false) => (task) => {
   calculateWeekGridLines,
   calculateWeekendBlocks,
   cascadeByLinks,
+  clampDateRangeForIncomingFS,
   clampTaskRangeForIncomingFS,
   computeLagFromDates,
   computeParentDates,
@@ -7258,6 +7580,7 @@ var nameContains = (substring, caseSensitive = false) => (task) => {
   isToday,
   isWeekend,
   moveTaskRange,
+  moveTaskWithCascade,
   nameContains,
   normalizeDependencyLag,
   normalizeHierarchyTasks,
@@ -7270,8 +7593,12 @@ var nameContains = (substring, caseSensitive = false) => (task) => {
   pixelsToDate,
   progressInRange,
   recalculateIncomingLags,
+  recalculateProjectSchedule,
+  recalculateTaskFromDependencies,
   reflowTasksOnModeSwitch,
   removeDependenciesBetweenTasks,
+  resizeTaskWithCascade,
+  resolveDateRangeFromPixels,
   shiftBusinessDayOffset,
   subtractBusinessDays,
   universalCascade,