gantt-lib 0.53.0 → 0.60.0

package/dist/index.d.mts

@@ -213,38 +213,23 @@ declare const normalizeTaskDates: (startDate: string | Date, endDate: string | D
 };
 /**
  * Count business days between two dates (inclusive), excluding weekends
+ * Delegates to core/scheduling/dateMath for implementation.
  * @param startDate - Start date (string or Date)
  * @param endDate - End date (string or Date)
  * @param weekendPredicate - Function that returns true for weekends
  * @returns Number of business days (minimum 1)
- *
- * Example:
- * getBusinessDaysCount('2026-03-14', '2026-03-17', (d) => d.getUTCDay() === 0 || d.getUTCDay() === 6)
- * // Returns 2 (Fri + Mon, Sat/Sun excluded)
  */
 declare function getBusinessDaysCount(startDate: string | Date, endDate: string | Date, weekendPredicate: (date: Date) => boolean): number;
 /**
- * Calculate end date by adding business days to start date
- * @param startDate - Start date (string or Date)
- * @param businessDays - Number of business days to add (minimum 1)
- * @param weekendPredicate - Function that returns true for weekends
+ * Calculate end date by adding business days to start date.
+ * Delegates to core/scheduling/dateMath, converts Date result to string.
  * @returns End date as YYYY-MM-DD string
- *
- * Example:
- * addBusinessDays('2026-03-14', 4, (d) => d.getUTCDay() === 0 || d.getUTCDay() === 6)
- * // Returns '2026-03-19' (Fri + Mon + Tue + Wed, Sat/Sun skipped)
  */
 declare function addBusinessDays(startDate: string | Date, businessDays: number, weekendPredicate: (date: Date) => boolean): string;
 /**
- * Subtract business days from a date (inverse of addBusinessDays)
- * @param endDate - End date (string or Date)
- * @param businessDays - Number of business days to subtract (minimum 1)
- * @param weekendPredicate - Function that returns true for weekends
+ * Subtract business days from a date (inverse of addBusinessDays).
+ * Delegates to core/scheduling/dateMath, converts Date result to string.
  * @returns Start date as YYYY-MM-DD string
- *
- * Example:
- * subtractBusinessDays('2026-03-19', 4, (d) => d.getUTCDay() === 0 || d.getUTCDay() === 6)
- * // Returns '2026-03-14' (going backwards: Fri[Thu][Wed][Tue]Mon, Sat/Sun skipped)
  */
 declare function subtractBusinessDays(endDate: string | Date, businessDays: number, weekendPredicate: (date: Date) => boolean): string;
 
@@ -1018,40 +1003,62 @@ interface UseTaskDragReturn {
  */
 declare const useTaskDrag: (options: UseTaskDragOptions) => UseTaskDragReturn;
 
-declare function getDependencyLag(dep: Pick<TaskDependency$1, 'lag'>): number;
-declare function normalizeDependencyLag(linkType: LinkType, lag: number, predecessorStart: Date, predecessorEnd: Date, businessDays?: boolean, weekendPredicate?: (date: Date) => boolean): number;
+/**
+ * Pure date math utilities for the core scheduling module.
+ * Zero React/DOM/date-fns dependencies.
+ *
+ * Functions moved from:
+ *   - dependencyUtils.ts: normalizeUTCDate, parseDateOnly, getBusinessDayOffset, shiftBusinessDayOffset, DAY_MS
+ *   - dateUtils.ts: getBusinessDaysCount, addBusinessDays, subtractBusinessDays
+ */
+declare const DAY_MS: number;
+/**
+ * Normalize a Date to UTC midnight (hours/minutes/seconds zeroed).
+ */
+declare function normalizeUTCDate(date: Date): Date;
+/**
+ * Parse a date string or Date object to a UTC midnight Date.
+ * Handles ISO strings like "2025-01-15" by appending T00:00:00.000Z.
+ */
+declare function parseDateOnly(date: string | Date): Date;
+/**
+ * Compute the business-day offset between two dates.
+ * Steps through each calendar day, counting only non-weekend days.
+ * Returns a positive number if toDate > fromDate, negative if toDate < fromDate.
+ */
+declare function getBusinessDayOffset(fromDate: Date, toDate: Date, weekendPredicate: (date: Date) => boolean): number;
+/**
+ * Shift a date by a business-day offset, skipping weekends.
+ */
+declare function shiftBusinessDayOffset(date: Date, offset: number, weekendPredicate: (date: Date) => boolean): Date;
+/**
+ * Snap a date to the nearest working day in the given direction.
+ */
 declare function alignToWorkingDay(date: Date, direction: 1 | -1, weekendPredicate: (date: Date) => boolean): Date;
+/**
+ * Get task duration in days (inclusive).
+ * If businessDays mode, counts business days using weekendPredicate.
+ * Otherwise, counts calendar days.
+ */
 declare function getTaskDuration(startDate: string | Date, endDate: string | Date, businessDays?: boolean, weekendPredicate?: (date: Date) => boolean): number;
-declare function buildTaskRangeFromStart(startDate: Date, duration: number, businessDays?: boolean, weekendPredicate?: (date: Date) => boolean, snapDirection?: 1 | -1): {
-    start: Date;
-    end: Date;
-};
-declare function buildTaskRangeFromEnd(endDate: Date, duration: number, businessDays?: boolean, weekendPredicate?: (date: Date) => boolean, snapDirection?: 1 | -1): {
-    start: Date;
-    end: Date;
-};
-declare function moveTaskRange(originalStart: string | Date, originalEnd: string | Date, proposedStart: Date, businessDays?: boolean, weekendPredicate?: (date: Date) => boolean, snapDirection?: 1 | -1): {
-    start: Date;
-    end: Date;
-};
-declare function clampTaskRangeForIncomingFS(task: Pick<Task$1, 'dependencies'>, proposedStart: Date, proposedEnd: Date, allTasks: Task$1[], businessDays?: boolean, weekendPredicate?: (date: Date) => boolean): {
-    start: Date;
-    end: Date;
-};
+
 /**
- * Build adjacency list for dependency graph (task -> successors)
+ * Dependency calculation functions.
+ * Moved from dependencyUtils.ts — verbatim implementations.
+ * Zero React/DOM/date-fns imports.
  */
-declare function buildAdjacencyList(tasks: Task$1[]): Map<string, string[]>;
+
 /**
- * Detect circular dependencies using depth-first search
+ * Get lag value from dependency, defaulting to 0.
  */
-declare function detectCycles(tasks: Task$1[]): {
-    hasCycle: boolean;
-    cyclePath?: string[];
-};
+declare function getDependencyLag(dep: Pick<TaskDependency$1, 'lag'>): number;
+/**
+ * Normalize lag for FS links — clamp to >= -predecessorDuration.
+ */
+declare function normalizeDependencyLag(linkType: LinkType, lag: number, predecessorStart: Date, predecessorEnd: Date, businessDays?: boolean, weekendPredicate?: (date: Date) => boolean): number;
 /**
  * Compute lag (in days) from actual predecessor/successor dates.
- * This is the single source of truth for lag semantics across chips, arrows, and drag.
+ * This is the single source of truth for lag semantics.
  *
  * Semantics (lag=0 = natural, gap-free connection):
  * - FS: lag = succStart - predEnd - 1  (adjacent days = 0)
@@ -1061,73 +1068,111 @@ declare function detectCycles(tasks: Task$1[]): {
  */
 declare function computeLagFromDates(linkType: LinkType, predStart: Date, predEnd: Date, succStart: Date, succEnd: Date, businessDays?: boolean, weekendPredicate?: (date: Date) => boolean): number;
 /**
- * Calculate successor date based on predecessor dates, link type, and lag
+ * Calculate successor date based on predecessor dates, link type, and lag.
  *
  * Link type semantics:
- * - FS: Successor start = Predecessor end + lag + 1 day  (lag=0 → next day)
+ * - FS: Successor start = Predecessor end + lag + 1 day  (lag=0 -> next day)
  * - SS: Successor start = Predecessor start + lag
  * - FF: Successor end   = Predecessor end + lag
- * - SF: Successor end   = Predecessor start + lag - 1 day  (lag=0 → day before)
+ * - SF: Successor end   = Predecessor start + lag - 1 day  (lag=0 -> day before)
  */
 declare function calculateSuccessorDate(predecessorStart: Date, predecessorEnd: Date, linkType: LinkType, lag?: number, businessDays?: boolean, weekendPredicate?: (date: Date) => boolean): Date;
+
 /**
- * Validate all dependencies in the task list
+ * Cascade engine functions.
+ * Moved from dependencyUtils.ts — verbatim implementations.
+ * Zero React/DOM/date-fns imports.
  */
-declare function validateDependencies(tasks: Task$1[]): ValidationResult;
+
 /**
  * Get successor tasks of a dragged task using BFS, filtered by link type(s).
- *
- * Returns tasks in breadth-first order (direct successors first, then their successors).
- * The dragged task itself is NOT included in the returned array.
- *
- * The visited set prevents infinite loops in case of cycles (cycle detection already
- * prevents cycles in valid data, but the guard adds safety during cascade computation).
- *
- * @param draggedTaskId - ID of the task being dragged
- * @param allTasks - All tasks in the chart
- * @param linkTypes - Dependency types to follow (default: ['FS'] preserves Phase 7 behavior)
  */
 declare function getSuccessorChain(draggedTaskId: string, allTasks: Task$1[], linkTypes?: LinkType[]): Task$1[];
 /**
  * Cascade successors by actual link constraints (BFS, constraint-based).
- *
- * Each successor in the chain is positioned using calculateSuccessorDate
- * with the predecessor's NEW dates and the actual lag — not a flat delta.
- *
- * - FS/SS: constraintDate = new start of successor (duration preserved)
- * - FF/SF: constraintDate = new end of successor (duration preserved)
- *
- * Locked tasks break the chain.
- * Also cascades hierarchy children when a parent moves (when parent moves by
- * dependency link, children must move with it to maintain parent-child relationship).
- * Returns only the cascaded successors (not the moved task itself).
  */
 declare function cascadeByLinks(movedTaskId: string, newStart: Date, newEnd: Date, allTasks: Task$1[], skipChildCascade?: boolean): Task$1[];
 /**
  * Get transitive closure of successors for cascading.
- *
- * Direct successors of the changed task are filtered by firstLevelLinkTypes.
- * Their successors (and so on) are included regardless of link type.
- *
- * Also includes hierarchy children of any parent task in the chain - when a parent
- * moves via dependency cascade, its children must move with it.
  */
 declare function getTransitiveCascadeChain(changedTaskId: string, allTasks: Task$1[], firstLevelLinkTypes: LinkType[]): Task$1[];
+/**
+ * Universal cascade engine that propagates a moved task's new position through
+ * the entire dependency+hierarchy graph using BFS with change detection.
+ */
+declare function universalCascade(movedTask: Task$1, newStart: Date, newEnd: Date, allTasks: Task$1[], businessDays?: boolean, weekendPredicate?: (date: Date) => boolean): Task$1[];
+/**
+ * Recalculate all task dates when switching between business/calendar day modes.
+ */
+declare function reflowTasksOnModeSwitch(sourceTasks: Task$1[], toBusinessDays: boolean, weekendPredicate: (date: Date) => boolean): Task$1[];
+
+/**
+ * High-level schedule command functions.
+ * Moved from dependencyUtils.ts — verbatim implementations.
+ * Zero React/DOM/date-fns imports.
+ */
+
+/**
+ * Build a task range (start/end dates) from a start date and duration.
+ */
+declare function buildTaskRangeFromStart(startDate: Date, duration: number, businessDays?: boolean, weekendPredicate?: (date: Date) => boolean, snapDirection?: 1 | -1): {
+    start: Date;
+    end: Date;
+};
+/**
+ * Build a task range (start/end dates) from an end date and duration.
+ */
+declare function buildTaskRangeFromEnd(endDate: Date, duration: number, businessDays?: boolean, weekendPredicate?: (date: Date) => boolean, snapDirection?: 1 | -1): {
+    start: Date;
+    end: Date;
+};
+/**
+ * Move a task range to a new start date, preserving duration.
+ */
+declare function moveTaskRange(originalStart: string | Date, originalEnd: string | Date, proposedStart: Date, businessDays?: boolean, weekendPredicate?: (date: Date) => boolean, snapDirection?: 1 | -1): {
+    start: Date;
+    end: Date;
+};
+/**
+ * Clamp task range start date based on incoming FS dependencies.
+ */
+declare function clampTaskRangeForIncomingFS(task: Pick<Task$1, 'dependencies'>, proposedStart: Date, proposedEnd: Date, allTasks: Task$1[], businessDays?: boolean, weekendPredicate?: (date: Date) => boolean): {
+    start: Date;
+    end: Date;
+};
 /**
  * Recalculate incoming dependency lags after a task's dates change.
- * Used when completing a drag or applying a manual date change.
  */
 declare function recalculateIncomingLags(task: Task$1, newStartDate: Date, newEndDate: Date, allTasks: Task$1[], businessDays?: boolean, weekendPredicate?: (date: Date) => boolean): NonNullable<Task$1['dependencies']>;
+
 /**
- * Get all dependency edges for rendering
- * Returns array of { predecessorId, successorId, type, lag }
+ * Dependency validation and cycle detection.
+ * Moved from dependencyUtils.ts — verbatim implementations.
+ * Zero React/DOM/date-fns imports.
  */
-declare function getAllDependencyEdges(tasks: Task$1[]): Array<{
-    predecessorId: string;
-    successorId: string;
-    type: LinkType;
-    lag: number;
-}>;
+
+/**
+ * Build adjacency list for dependency graph (task -> successors)
+ */
+declare function buildAdjacencyList(tasks: Task$1[]): Map<string, string[]>;
+/**
+ * Detect circular dependencies using depth-first search
+ */
+declare function detectCycles(tasks: Task$1[]): {
+    hasCycle: boolean;
+    cyclePath?: string[];
+};
+/**
+ * Validate all dependencies in the task list
+ */
+declare function validateDependencies(tasks: Task$1[]): ValidationResult;
+
+/**
+ * Hierarchy scheduling functions.
+ * Moved from dependencyUtils.ts — verbatim implementations.
+ * Zero React/DOM/date-fns imports.
+ */
+
 /**
  * Get all child tasks of a parent task.
  * Returns tasks where task.parentId === parentId.
@@ -1154,23 +1199,27 @@ declare function computeParentDates(parentId: string, tasks: Task$1[]): {
  * Progress is rounded to 1 decimal place.
  */
 declare function computeParentProgress(parentId: string, tasks: Task$1[]): number;
+/**
+ * Get all descendant tasks of a parent task (transitive closure of children).
+ * Returns all tasks where task.parentId is in the hierarchy of the parent.
+ */
+declare function getAllDescendants(parentId: string, tasks: Task$1[]): Task$1[];
+/**
+ * Get all dependency edges for rendering.
+ * Returns array of { predecessorId, successorId, type, lag }
+ */
+declare function getAllDependencyEdges(tasks: Task$1[]): Array<{
+    predecessorId: string;
+    successorId: string;
+    type: 'FS' | 'SS' | 'FF' | 'SF';
+    lag: number;
+}>;
 /**
  * Remove dependencies between two tasks in both directions.
- * When tasks become parent-child, their dependency link becomes meaningless.
- *
- * @param taskId1 - First task ID
- * @param taskId2 - Second task ID
- * @param tasks - All tasks array
- * @returns New tasks array with dependencies between the two tasks removed
  */
 declare function removeDependenciesBetweenTasks(taskId1: string, taskId2: string, tasks: Task$1[]): Task$1[];
 /**
  * Find the parent ID of a task.
- * Returns the parentId of the task if found, undefined otherwise.
- *
- * @param taskId - ID of the task to find parent for
- * @param tasks - All tasks array
- * @returns Parent task ID or undefined if task is root or not found
  */
 declare function findParentId(taskId: string, tasks: Task$1[]): string | undefined;
 /**
@@ -1178,63 +1227,9 @@ declare function findParentId(taskId: string, tasks: Task$1[]): string | undefin
  */
 declare function isAncestorTask(ancestorId: string, taskId: string, tasks: Task$1[]): boolean;
 /**
- * Returns true when tasks are in the same ancestry chain (ancestor/descendant in either direction).
+ * Returns true when tasks are in the same ancestry chain.
  */
 declare function areTasksHierarchicallyRelated(taskId1: string, taskId2: string, tasks: Task$1[]): boolean;
-/**
- * Get all descendant tasks of a parent task (transitive closure of children).
- * Returns all tasks where task.parentId is in the hierarchy of the parent.
- *
- * @param parentId - ID of the parent task
- * @param tasks - All tasks array
- * @returns Array of descendant tasks (not including the parent itself)
- */
-declare function getAllDescendants(parentId: string, tasks: Task$1[]): Task$1[];
-/**
- * Universal cascade engine that propagates a moved task's new position through
- * the entire dependency+hierarchy graph using BFS with change detection.
- *
- * Three rules applied in BFS order:
- *
- *   RULE 1 — Hierarchy children of a parent task shift by the parent's delta.
- *            Applied only when the parent arrived as 'direct', 'child-delta', or 'dependency'.
- *            Skipped for 'parent-recalc' (parent was computed FROM children).
- *
- *   RULE 2 — Parent task is recomputed as min(children.start)..max(children.end).
- *            Re-queued every time a child changes (no visited guard — uses change detection).
- *            This ensures the parent reflects ALL cascaded children, not just the first one.
- *
- *   RULE 3 — Dependency successors are repositioned via calculateSuccessorDate.
- *            Effective lag is computed from original dates (not stored dep.lag).
- *            Re-queued if predecessor's dates changed (change detection).
- *
- * Change detection prevents infinite loops: a task is only re-queued if its
- * computed dates differ from what's already in updatedDates.
- *
- * @param movedTask  - The task that was directly moved/resized (already has new dates).
- * @param newStart   - New start date of the moved task.
- * @param newEnd     - New end date of the moved task.
- * @param allTasks   - All tasks in the chart (original, unmodified dates).
- * @param businessDays - If true, dependency calculations skip weekends.
- * @param weekendPredicate - Function that returns true for weekends.
- */
-declare function universalCascade(movedTask: Task$1, newStart: Date, newEnd: Date, allTasks: Task$1[], businessDays?: boolean, weekendPredicate?: (date: Date) => boolean): Task$1[];
-/**
- * Пересчитывает даты всех задач при переключении режима рабочих/календарных дней.
- *
- * Calendar → Working (toBusinessDays=true):
- *   - duration число сохраняется (10 кал → 10 раб)
- *   - start на выходном → сдвигается на ближайший рабочий
- *   - end пересчитывается через buildTaskRangeFromStart
- *   - каскад зависимостей (расширение может нарушить constraints)
- *
- * Working → Calendar (toBusinessDays=false):
- *   - start остаётся как есть
- *   - duration число сохраняется, но теперь считается как календарные дни
- *   - end сдвигается ближе
- *   - каскад НЕ нужен (сжатие не нарушает зависимости)
- */
-declare function reflowTasksOnModeSwitch(sourceTasks: Task$1[], toBusinessDays: boolean, weekendPredicate: (date: Date) => boolean): Task$1[];
 
 /**
  * Checks whether a task is behind the expected progress for the current date.
@@ -1424,4 +1419,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, type GanttDateRange, GridBackground, type GridConfig, type GridLine, Input, type InputProps, type MonthBlock, type MonthSpan, Popover, PopoverContent, type PopoverContentProps, type PopoverProps, PopoverTrigger, type Task, type TaskBarGeometry, type TaskDependency, TaskList, type TaskListColumn, type TaskListColumnContext, type TaskListProps, type TaskPredicate, TaskRow, TimeScaleHeader, TodayIndicator, type VisibleReorderPosition, type WeekBlock, type WeekSpan, type WeekendBlock, type YearSpan, addBusinessDays, alignToWorkingDay, and, areTasksHierarchicallyRelated, buildAdjacencyList, buildTaskRangeFromEnd, buildTaskRangeFromStart, calculateBezierPath, calculateDependencyPath, calculateGridLines, calculateGridWidth, calculateMonthGridLines, calculateOrthogonalPath, calculateSuccessorDate, calculateTaskBar, calculateWeekGridLines, calculateWeekendBlocks, cascadeByLinks, clampTaskRangeForIncomingFS, computeLagFromDates, computeParentDates, computeParentProgress, createCustomDayPredicate, createDateKey, detectCycles, detectEdgeZone, expired, findParentId, flattenHierarchy, formatDateLabel, formatDateRangeLabel, getAllDependencyEdges, getAllDescendants, getBusinessDaysCount, getChildren, getCursorForPosition, getDayOffset, getDependencyLag, getMonthBlocks, getMonthDays, getMonthSpans, getMultiMonthDays, getSuccessorChain, getTaskDuration, getTransitiveCascadeChain, getVisibleReorderPosition, getWeekBlocks, getWeekSpans, getYearSpans, inDateRange, isAncestorTask, isTaskExpired, isTaskParent, isToday, isWeekend, moveTaskRange, nameContains, normalizeDependencyLag, normalizeHierarchyTasks, normalizeTaskDates, not, or, parseUTCDate, pixelsToDate, progressInRange, recalculateIncomingLags, reflowTasksOnModeSwitch, removeDependenciesBetweenTasks, subtractBusinessDays, universalCascade, useTaskDrag, validateDependencies, withoutDeps };
+export { type BuiltInTaskListColumnId, Button, type ButtonProps, Calendar, type CalendarProps, type CustomDayConfig, type CustomDayPredicateConfig, DAY_MS, DatePicker, type DatePickerProps, type DependencyError, DragGuideLines, GanttChart, type GanttChartHandle, type GanttChartProps, type GanttDateRange, GridBackground, type GridConfig, type GridLine, Input, type InputProps, type LinkType, type MonthBlock, type MonthSpan, Popover, PopoverContent, type PopoverContentProps, type PopoverProps, PopoverTrigger, type Task, type TaskBarGeometry, type TaskDependency, TaskList, type TaskListColumn, type TaskListColumnContext, type TaskListProps, type TaskPredicate, TaskRow, TimeScaleHeader, TodayIndicator, type ValidationResult, type VisibleReorderPosition, type WeekBlock, type WeekSpan, type WeekendBlock, type YearSpan, addBusinessDays, alignToWorkingDay, and, areTasksHierarchicallyRelated, buildAdjacencyList, buildTaskRangeFromEnd, buildTaskRangeFromStart, calculateBezierPath, calculateDependencyPath, calculateGridLines, calculateGridWidth, calculateMonthGridLines, calculateOrthogonalPath, calculateSuccessorDate, calculateTaskBar, calculateWeekGridLines, calculateWeekendBlocks, cascadeByLinks, clampTaskRangeForIncomingFS, computeLagFromDates, computeParentDates, computeParentProgress, createCustomDayPredicate, createDateKey, detectCycles, detectEdgeZone, expired, findParentId, flattenHierarchy, formatDateLabel, formatDateRangeLabel, getAllDependencyEdges, getAllDescendants, getBusinessDayOffset, getBusinessDaysCount, getChildren, getCursorForPosition, getDayOffset, getDependencyLag, getMonthBlocks, getMonthDays, getMonthSpans, getMultiMonthDays, getSuccessorChain, getTaskDuration, getTransitiveCascadeChain, getVisibleReorderPosition, getWeekBlocks, getWeekSpans, getYearSpans, inDateRange, isAncestorTask, isTaskExpired, isTaskParent, isToday, isWeekend, moveTaskRange, nameContains, normalizeDependencyLag, normalizeHierarchyTasks, normalizeTaskDates, normalizeUTCDate, not, or, parseDateOnly, parseUTCDate, pixelsToDate, progressInRange, recalculateIncomingLags, reflowTasksOnModeSwitch, removeDependenciesBetweenTasks, shiftBusinessDayOffset, subtractBusinessDays, universalCascade, useTaskDrag, validateDependencies, withoutDeps };