gantt-lib 0.60.0 → 0.60.2

package/dist/index-CliEEiHA.d.ts

@@ -0,0 +1,410 @@
+/**
+ * Dependency link types following PM standard
+ * - FS (Finish-to-Start): Predecessor must finish before successor starts
+ * - SS (Start-to-Start): Predecessor must start before successor starts
+ * - FF (Finish-to-Finish): Predecessor must finish before successor finishes
+ * - SF (Start-to-Finish): Predecessor must start before successor finishes
+ */
+type LinkType = 'FS' | 'SS' | 'FF' | 'SF';
+/**
+ * Single dependency relationship (predecessor link)
+ */
+interface TaskDependency {
+    /** ID of the predecessor task */
+    taskId: string;
+    /** Type of link: FS (finish-to-start), SS, FF, SF */
+    type: LinkType;
+    /** Lag in days (positive or negative integer) */
+    lag: number;
+}
+/**
+ * Error or warning from dependency validation
+ */
+interface DependencyError {
+    /** Type of error */
+    type: 'cycle' | 'constraint' | 'missing-task';
+    /** ID of the task with the error */
+    taskId: string;
+    /** Human-readable error message */
+    message: string;
+    /** Related task IDs (e.g., cycle path, referenced tasks) */
+    relatedTaskIds?: string[];
+}
+/**
+ * Result of dependency validation
+ */
+interface ValidationResult {
+    /** True if no errors found */
+    isValid: boolean;
+    /** Array of errors/warnings (empty if valid) */
+    errors: DependencyError[];
+}
+/**
+ * Task data structure for Gantt chart
+ */
+interface Task {
+    /** Unique identifier for the task */
+    id: string;
+    /** Display name of the task */
+    name: string;
+    /** Task start date (ISO string or Date object) */
+    startDate: string | Date;
+    /** Task end date (ISO string or Date object) */
+    endDate: string | Date;
+    /** Optional color for task bar visualization */
+    color?: string;
+    /** Optional parent task ID for hierarchy relationship */
+    parentId?: string;
+    /**
+     * Optional progress value from 0-100
+     * - Decimal values are allowed and rounded to nearest integer for display
+     * - Values are clamped to 0-100 range
+     * - Undefined or 0 means no progress is displayed
+     * - Progress is visual-only, no user interaction
+     */
+    progress?: number;
+    /**
+     * Optional flag indicating if task is accepted
+     * - Only meaningful when progress is 100%
+     * - Affects the color of the progress bar (green for accepted, yellow for completed)
+     */
+    accepted?: boolean;
+    /**
+     * Optional array of predecessor dependencies
+     * Each dependency specifies a predecessor task, link type, and optional lag
+     */
+    dependencies?: TaskDependency[];
+    /**
+     * Optional flag to prevent drag and resize interactions.
+     * When true, the task bar cannot be moved or resized.
+     * Independent of accepted/progress — consumer controls both separately.
+     */
+    locked?: boolean;
+}
+/**
+ * Date range for Gantt chart display
+ */
+interface GanttDateRange {
+    /** Start date of the visible range */
+    start: Date;
+    /** End date of the visible range */
+    end: Date;
+}
+/**
+ * Task bar positioning and dimensions
+ */
+interface TaskBarGeometry {
+    /** Left position in pixels */
+    left: number;
+    /** Width in pixels */
+    width: number;
+}
+/**
+ * Grid configuration for layout calculations
+ */
+interface GridConfig {
+    /** Width of each day column in pixels */
+    dayWidth: number;
+    /** Height of each task row in pixels */
+    rowHeight: number;
+}
+/**
+ * Represents a month span in the calendar header
+ */
+interface MonthSpan {
+    /** First day of the month (UTC) */
+    month: Date;
+    /** Number of days this month spans in the visible range */
+    days: number;
+    /** Start index in the date range array */
+    startIndex: number;
+}
+/**
+ * Represents a vertical grid line
+ */
+interface GridLine {
+    /** X position in pixels */
+    x: number;
+    /** True if this line is at the start of a month */
+    isMonthStart: boolean;
+    /** True if this line is at the start of a week (Monday) */
+    isWeekStart: boolean;
+}
+/**
+ * Represents a weekend background block
+ */
+interface WeekendBlock {
+    /** Left position in pixels */
+    left: number;
+    /** Width in pixels */
+    width: 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;
+/**
+ * Count business days between two dates (inclusive), excluding weekends.
+ * Returns minimum 1.
+ */
+declare function getBusinessDaysCount(startDate: string | Date, endDate: string | Date, weekendPredicate: (date: Date) => boolean): number;
+/**
+ * Calculate end date by adding N business days to start date.
+ * Returns a Date object.
+ */
+declare function addBusinessDays(startDate: string | Date, businessDays: number, weekendPredicate: (date: Date) => boolean): Date;
+/**
+ * Calculate start date by subtracting N business days from end date.
+ * Returns a Date object.
+ */
+declare function subtractBusinessDays(endDate: string | Date, businessDays: 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;
+
+/**
+ * Dependency calculation functions.
+ * Moved from dependencyUtils.ts — verbatim implementations.
+ * Zero React/DOM/date-fns imports.
+ */
+
+/**
+ * Get lag value from dependency, defaulting to 0.
+ */
+declare function getDependencyLag(dep: Pick<TaskDependency, '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.
+ *
+ * Semantics (lag=0 = natural, gap-free connection):
+ * - FS: lag = succStart - predEnd - 1  (adjacent days = 0)
+ * - SS: lag = succStart - predStart
+ * - FF: lag = succEnd   - predEnd
+ * - SF: lag = succEnd   - predStart + 1  (symmetric to FS)
+ */
+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.
+ *
+ * Link type semantics:
+ * - 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)
+ */
+declare function calculateSuccessorDate(predecessorStart: Date, predecessorEnd: Date, linkType: LinkType, lag?: number, businessDays?: boolean, weekendPredicate?: (date: Date) => boolean): Date;
+
+/**
+ * Cascade engine functions.
+ * Moved from dependencyUtils.ts — verbatim implementations.
+ * Zero React/DOM/date-fns imports.
+ */
+
+/**
+ * Get successor tasks of a dragged task using BFS, filtered by link type(s).
+ */
+declare function getSuccessorChain(draggedTaskId: string, allTasks: Task[], linkTypes?: LinkType[]): Task[];
+/**
+ * Cascade successors by actual link constraints (BFS, constraint-based).
+ */
+declare function cascadeByLinks(movedTaskId: string, newStart: Date, newEnd: Date, allTasks: Task[], skipChildCascade?: boolean): Task[];
+/**
+ * Get transitive closure of successors for cascading.
+ */
+declare function getTransitiveCascadeChain(changedTaskId: string, allTasks: Task[], firstLevelLinkTypes: LinkType[]): Task[];
+/**
+ * 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, newStart: Date, newEnd: Date, allTasks: Task[], businessDays?: boolean, weekendPredicate?: (date: Date) => boolean): Task[];
+/**
+ * Recalculate all task dates when switching between business/calendar day modes.
+ */
+declare function reflowTasksOnModeSwitch(sourceTasks: Task[], toBusinessDays: boolean, weekendPredicate: (date: Date) => boolean): Task[];
+
+/**
+ * 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, 'dependencies'>, proposedStart: Date, proposedEnd: Date, allTasks: Task[], businessDays?: boolean, weekendPredicate?: (date: Date) => boolean): {
+    start: Date;
+    end: Date;
+};
+/**
+ * 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.
+ */
+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;
+};
+
+/**
+ * Dependency validation and cycle detection.
+ * Moved from dependencyUtils.ts — verbatim implementations.
+ * Zero React/DOM/date-fns imports.
+ */
+
+/**
+ * Build adjacency list for dependency graph (task -> successors)
+ */
+declare function buildAdjacencyList(tasks: Task[]): Map<string, string[]>;
+/**
+ * Detect circular dependencies using depth-first search
+ */
+declare function detectCycles(tasks: Task[]): {
+    hasCycle: boolean;
+    cyclePath?: string[];
+};
+/**
+ * Validate all dependencies in the task list
+ */
+declare function validateDependencies(tasks: Task[]): 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.
+ */
+declare function getChildren(parentId: string, tasks: Task[]): Task[];
+/**
+ * Check if a task is a parent (has children).
+ * Returns true if any task has this task as parentId.
+ */
+declare function isTaskParent(taskId: string, tasks: Task[]): boolean;
+/**
+ * Compute parent task dates from children.
+ * Returns { startDate, endDate } where:
+ * - startDate = min(children.startDate) or own startDate if no children
+ * - endDate = max(children.endDate) or own endDate if no children
+ */
+declare function computeParentDates(parentId: string, tasks: Task[]): {
+    startDate: Date;
+    endDate: Date;
+};
+/**
+ * Compute parent task progress from children (weighted average by duration).
+ * Returns 0 if no children.
+ * Progress is rounded to 1 decimal place.
+ */
+declare function computeParentProgress(parentId: string, tasks: Task[]): 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[]): Task[];
+/**
+ * Get all dependency edges for rendering.
+ * Returns array of { predecessorId, successorId, type, lag }
+ */
+declare function getAllDependencyEdges(tasks: Task[]): Array<{
+    predecessorId: string;
+    successorId: string;
+    type: 'FS' | 'SS' | 'FF' | 'SF';
+    lag: number;
+}>;
+/**
+ * Remove dependencies between two tasks in both directions.
+ */
+declare function removeDependenciesBetweenTasks(taskId1: string, taskId2: string, tasks: Task[]): Task[];
+/**
+ * Find the parent ID of a task.
+ */
+declare function findParentId(taskId: string, tasks: Task[]): string | undefined;
+/**
+ * Returns true when ancestorId is an ancestor of taskId in the current hierarchy.
+ */
+declare function isAncestorTask(ancestorId: string, taskId: string, tasks: Task[]): boolean;
+/**
+ * Returns true when tasks are in the same ancestry chain.
+ */
+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 };