gantt-lib 0.60.2 → 0.61.0

package/dist/{index-CliEEiHA.d.ts → index-BlUshzVg.d.ts}

@@ -140,6 +140,53 @@ interface WeekendBlock {
     width: number;
 }
 
+/**
+ * Core scheduling type re-exports.
+ * This file is the type gateway into the core scheduling module.
+ * Zero React/DOM/date-fns imports.
+ */
+
+/** Minimal task shape for scheduling operations */
+interface ScheduleTask {
+    id: string;
+    startDate: string | Date;
+    endDate: string | Date;
+    dependencies?: TaskDependency[];
+    parentId?: string;
+    locked?: boolean;
+    progress?: number;
+}
+/** Dependency for scheduling operations */
+interface ScheduleDependency {
+    type: LinkType;
+    taskId: string;
+    lag?: number;
+}
+/** Update for a single task (id + changed fields) */
+interface ScheduleTaskUpdate {
+    id: string;
+    startDate?: string;
+    endDate?: string;
+    dependencies?: TaskDependency[];
+    progress?: number;
+}
+/** Result of executing a scheduling command */
+interface ScheduleCommandResult {
+    /** All tasks that changed as a result of the command (including the source task) */
+    changedTasks: Task[];
+    /** IDs of changed tasks */
+    changedIds: string[];
+}
+/** Options for scheduling commands */
+interface ScheduleCommandOptions {
+    /** Account for business days during cascade */
+    businessDays?: boolean;
+    /** Weekend predicate function */
+    weekendPredicate?: (date: Date) => boolean;
+    /** Skip cascade, only recalculate the task itself */
+    skipCascade?: boolean;
+}
+
 /**
  * Pure date math utilities for the core scheduling module.
  * Zero React/DOM/date-fns dependencies.
@@ -296,30 +343,35 @@ declare function clampTaskRangeForIncomingFS(task: Pick<Task, 'dependencies'>, p
  * Recalculate incoming dependency lags after a task's dates change.
  */
 declare function recalculateIncomingLags(task: Task, newStartDate: Date, newEndDate: Date, allTasks: Task[], businessDays?: boolean, weekendPredicate?: (date: Date) => boolean): NonNullable<Task['dependencies']>;
+
 /**
- * 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.
+ * Command-level scheduling API.
+ * High-level functions that compose low-level scheduling primitives.
+ * Zero React/DOM/date-fns imports.
  */
-declare function resolveDateRangeFromPixels(mode: 'move' | 'resize-left' | 'resize-right', left: number, width: number, monthStart: Date, dayWidth: number, task: Task, 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.
+ * Move a task to a new start date with cascade and lag recalculation.
+ * Identical to manual composition: moveTaskRange -> recalculateIncomingLags -> universalCascade.
  */
-declare function clampDateRangeForIncomingFS(task: Task, range: {
-    start: Date;
-    end: Date;
-}, allTasks: Task[], mode: 'move' | 'resize-left' | 'resize-right', businessDays?: boolean, weekendPredicate?: (date: Date) => boolean): {
-    start: Date;
-    end: Date;
-};
+declare function moveTaskWithCascade(taskId: string, newStart: Date, snapshot: Task[], options?: ScheduleCommandOptions): ScheduleCommandResult;
+/**
+ * Resize a task by changing its start or end date.
+ * anchor='end': new end date, start stays fixed.
+ * anchor='start': new start date, end stays fixed.
+ */
+declare function resizeTaskWithCascade(taskId: string, anchor: 'start' | 'end', newDate: Date, snapshot: Task[], options?: ScheduleCommandOptions): ScheduleCommandResult;
+/**
+ * Recalculate a task's dates based on its dependency constraints.
+ * Finds all predecessors and computes the most constrained date.
+ */
+declare function recalculateTaskFromDependencies(taskId: string, snapshot: Task[], options?: ScheduleCommandOptions): ScheduleCommandResult;
+/**
+ * Full project schedule recalculation.
+ * Recomputes the project against a continuously updated working snapshot.
+ * Returns only tasks whose normalized state changed.
+ */
+declare function recalculateProjectSchedule(snapshot: Task[], options?: ScheduleCommandOptions): ScheduleCommandResult;
 
 /**
  * Dependency validation and cycle detection.
@@ -407,4 +459,38 @@ declare function isAncestorTask(ancestorId: string, taskId: string, tasks: Task[
  */
 declare function areTasksHierarchicallyRelated(taskId1: string, taskId2: string, tasks: Task[]): boolean;
 
-export { isTaskParent as A, moveTaskRange as B, normalizeDependencyLag as C, DAY_MS as D, normalizeUTCDate as E, parseDateOnly as F, type GanttDateRange as G, recalculateIncomingLags as H, reflowTasksOnModeSwitch as I, removeDependenciesBetweenTasks as J, shiftBusinessDayOffset as K, type LinkType as L, type MonthSpan as M, universalCascade as N, validateDependencies as O, type TaskDependency as P, addBusinessDays as Q, clampDateRangeForIncomingFS as R, getBusinessDaysCount as S, type Task as T, resolveDateRangeFromPixels as U, type ValidationResult as V, type WeekendBlock as W, subtractBusinessDays as X, type DependencyError as a, type GridConfig as b, type GridLine as c, type TaskBarGeometry as d, alignToWorkingDay as e, areTasksHierarchicallyRelated as f, buildAdjacencyList as g, buildTaskRangeFromEnd as h, buildTaskRangeFromStart as i, calculateSuccessorDate as j, cascadeByLinks as k, clampTaskRangeForIncomingFS as l, computeLagFromDates as m, computeParentDates as n, computeParentProgress as o, detectCycles as p, findParentId as q, getAllDependencyEdges as r, getAllDescendants as s, getBusinessDayOffset as t, getChildren as u, getDependencyLag as v, getSuccessorChain as w, getTaskDuration as x, getTransitiveCascadeChain as y, isAncestorTask as z };
+/**
+ * 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, 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, range: {
+    start: Date;
+    end: Date;
+}, allTasks: Task[], mode: 'move' | 'resize-left' | 'resize-right', businessDays?: boolean, weekendPredicate?: (date: Date) => boolean): {
+    start: Date;
+    end: Date;
+};
+
+export { type ScheduleTask as $, isAncestorTask as A, isTaskParent as B, moveTaskRange as C, DAY_MS as D, moveTaskWithCascade as E, normalizeDependencyLag as F, type GanttDateRange as G, normalizeUTCDate as H, parseDateOnly as I, recalculateIncomingLags as J, recalculateProjectSchedule as K, type LinkType as L, type MonthSpan as M, recalculateTaskFromDependencies as N, reflowTasksOnModeSwitch as O, removeDependenciesBetweenTasks as P, resizeTaskWithCascade as Q, resolveDateRangeFromPixels as R, shiftBusinessDayOffset as S, type Task as T, universalCascade as U, type ValidationResult as V, type WeekendBlock as W, validateDependencies as X, type ScheduleCommandOptions as Y, type ScheduleCommandResult as Z, type ScheduleDependency as _, type DependencyError as a, type ScheduleTaskUpdate as a0, type TaskDependency as a1, addBusinessDays as a2, getBusinessDaysCount as a3, subtractBusinessDays as a4, type GridConfig as b, type GridLine as c, type TaskBarGeometry as d, alignToWorkingDay as e, areTasksHierarchicallyRelated as f, buildAdjacencyList as g, buildTaskRangeFromEnd as h, buildTaskRangeFromStart as i, calculateSuccessorDate as j, cascadeByLinks as k, clampDateRangeForIncomingFS as l, clampTaskRangeForIncomingFS as m, computeLagFromDates as n, computeParentDates as o, computeParentProgress as p, detectCycles as q, findParentId as r, getAllDependencyEdges as s, getAllDescendants as t, getBusinessDayOffset as u, getChildren as v, getDependencyLag as w, getSuccessorChain as x, getTaskDuration as y, getTransitiveCascadeChain as z };

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-BlUshzVg.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 clampDateRangeForIncomingFS, m as clampTaskRangeForIncomingFS, n as computeLagFromDates, o as computeParentDates, p as computeParentProgress, q as detectCycles, r as findParentId, s as getAllDependencyEdges, t as getAllDescendants, u as getBusinessDayOffset, v as getChildren, w as getDependencyLag, x as getSuccessorChain, y as getTaskDuration, z as getTransitiveCascadeChain, A as isAncestorTask, B as isTaskParent, C as moveTaskRange, E as moveTaskWithCascade, F as normalizeDependencyLag, H as normalizeUTCDate, I as parseDateOnly, J as recalculateIncomingLags, K as recalculateProjectSchedule, N as recalculateTaskFromDependencies, O as reflowTasksOnModeSwitch, P as removeDependenciesBetweenTasks, Q as resizeTaskWithCascade, R as resolveDateRangeFromPixels, S as shiftBusinessDayOffset, U as universalCascade, X as validateDependencies } from './index-BlUshzVg.mjs';
 import * as RadixPopover from '@radix-ui/react-popover';
 
 /**

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-BlUshzVg.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 clampDateRangeForIncomingFS, m as clampTaskRangeForIncomingFS, n as computeLagFromDates, o as computeParentDates, p as computeParentProgress, q as detectCycles, r as findParentId, s as getAllDependencyEdges, t as getAllDescendants, u as getBusinessDayOffset, v as getChildren, w as getDependencyLag, x as getSuccessorChain, y as getTaskDuration, z as getTransitiveCascadeChain, A as isAncestorTask, B as isTaskParent, C as moveTaskRange, E as moveTaskWithCascade, F as normalizeDependencyLag, H as normalizeUTCDate, I as parseDateOnly, J as recalculateIncomingLags, K as recalculateProjectSchedule, N as recalculateTaskFromDependencies, O as reflowTasksOnModeSwitch, P as removeDependenciesBetweenTasks, Q as resizeTaskWithCascade, R as resolveDateRangeFromPixels, S as shiftBusinessDayOffset, U as universalCascade, X as validateDependencies } from './index-BlUshzVg.js';
 import * as RadixPopover from '@radix-ui/react-popover';
 
 /**

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();
@@ -1405,6 +1662,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) {
@@ -7219,6 +7535,7 @@ var nameContains = (substring, caseSensitive = false) => (task) => {
   calculateWeekGridLines,
   calculateWeekendBlocks,
   cascadeByLinks,
+  clampDateRangeForIncomingFS,
   clampTaskRangeForIncomingFS,
   computeLagFromDates,
   computeParentDates,
@@ -7258,6 +7575,7 @@ var nameContains = (substring, caseSensitive = false) => (task) => {
   isToday,
   isWeekend,
   moveTaskRange,
+  moveTaskWithCascade,
   nameContains,
   normalizeDependencyLag,
   normalizeHierarchyTasks,
@@ -7270,8 +7588,12 @@ var nameContains = (substring, caseSensitive = false) => (task) => {
   pixelsToDate,
   progressInRange,
   recalculateIncomingLags,
+  recalculateProjectSchedule,
+  recalculateTaskFromDependencies,
   reflowTasksOnModeSwitch,
   removeDependenciesBetweenTasks,
+  resizeTaskWithCascade,
+  resolveDateRangeFromPixels,
   shiftBusinessDayOffset,
   subtractBusinessDays,
   universalCascade,