@jaeungkim/gantt-chart 0.4.0 → 1.1.0

package/README.md

@@ -1,117 +1,113 @@
+[![Banner](https://raw.githubusercontent.com/jaeungkim/gantt-chart/main/public/banner.png)](https://gantt.jaeungkim.com)
+
 # @jaeungkim/gantt-chart
 
 [![npm version](https://img.shields.io/npm/v/@jaeungkim/gantt-chart)](https://www.npmjs.com/package/@jaeungkim/gantt-chart)
 [![CI](https://github.com/jaeungkim/gantt-chart/actions/workflows/ci.yml/badge.svg)](https://github.com/jaeungkim/gantt-chart/actions/workflows/ci.yml)
 [![license](https://img.shields.io/npm/l/@jaeungkim/gantt-chart)](LICENSE)
 
-A Gantt chart for React: virtualized rows, editable bars, dependency arrows, and a scheduling
-engine that runs without a DOM.
-
-**[Live demo](https://jaeungkim.com/gantt-chart)** · **[Documentation](https://github.com/jaeungkim/gantt-chart/blob/main/docs/en/README.md)** · **[한국어 문서](https://github.com/jaeungkim/gantt-chart/blob/main/docs/ko/README.md)**
+An editable Gantt chart for React.
 
-## Motivation
+[Quick start](https://gantt.jaeungkim.com/docs/quick-start) |
+[Playground](https://gantt.jaeungkim.com/playground) |
+[Documentation](https://gantt.jaeungkim.com/docs) |
+[한국어 문서](https://gantt.jaeungkim.com/ko/docs)
 
-I wanted Microsoft Project's Gantt chart for my own project planning, and it wanted a
-subscription. So I built one, borrowing ideas from MS Project, DHTMLX and Frappe Gantt.
+## Features
 
-There are not many open-source Gantt charts, so I hope this is useful to someone else too.
-Feedback, feature requests and pull requests are all welcome — this is my first open-source
-project and I would like to keep improving it with whoever shows up.
+- Bar drags that move a task, resize it from either edge and set its progress.
+- Dependency arrows for `FS`, `SS`, `FF` and `SF`, drawn between bars and removed with Delete or Backspace.
+- A task list pane with the `parentId` tree, summary roll-up and row reordering.
+- A docked detail panel that narrows the timeline and edits the task in place.
+- Five scales from `day` to `year`, rows and time cells virtualized together, and tasks packed onto shared rows by `lane`.
+- A working calendar from `workingWeekdays` and `holidays`, which also shades the timeline.
+- Keyboard editing and screen reader announcements on one ARIA treegrid.
+- `locale` date labels through `Intl.DateTimeFormat`, and a light, dark or system theme.
 
 ## Install
 
 ```bash
 pnpm add @jaeungkim/gantt-chart
+# npm install @jaeungkim/gantt-chart
+# yarn add @jaeungkim/gantt-chart
 ```
 
-`react` and `react-dom` (`^18` or `^19`) are peer dependencies.
+`react` and `react-dom` (`^18` or `^19`) are peer dependencies. The runtime dependencies are
+`dayjs` and `zustand`.
 
-## Usage
+## Quick example
 
 ```tsx
+import { useState } from 'react';
 import { ReactGanttChart, type Task } from '@jaeungkim/gantt-chart';
 import '@jaeungkim/gantt-chart/style.css';
 
-const tasks: Task[] = [
+const initialTasks: Task[] = [
   {
-    id: '1',
-    name: 'Project kickoff',
-    startDate: '2024-06-01T09:00:00Z',
-    endDate: '2024-06-03T17:00:00Z',
+    id: 'design',
+    name: 'Design',
+    startDate: '2026-03-02',
+    endDate: '2026-03-06',
     parentId: null,
     sequence: '1',
+    progress: 100,
   },
   {
-    id: '2',
-    name: 'Requirements',
-    startDate: '2024-06-04T09:00:00Z',
-    endDate: '2024-06-10T17:00:00Z',
+    id: 'build',
+    name: 'Build',
+    startDate: '2026-03-09',
+    endDate: '2026-03-20',
     parentId: null,
     sequence: '2',
-    dependencies: [{ targetId: '1', type: 'FS' }],
+    progress: 40,
+    dependencies: [{ targetId: 'design', type: 'FS' }],
+  },
+  {
+    id: 'ship',
+    name: 'Ship',
+    startDate: '2026-03-23',
+    endDate: '2026-03-23',
+    parentId: null,
+    sequence: '3',
+    dependencies: [{ targetId: 'build', type: 'FS' }],
   },
 ];
 
-export default function App() {
+export default function ProjectChart() {
+  const [tasks, setTasks] = useState(initialTasks);
+
   return (
     <ReactGanttChart
       tasks={tasks}
-      height={600}
-      theme="system"
+      onTasksChange={setTasks}
+      height={420}
+      showTaskList
       defaultScale="month"
-      onTasksChange={(updated) => console.log(updated)}
     />
   );
 }
 ```
 
-The chart never stores your data. Every committed gesture ends in one `onTasksChange` call with a
-new array, and it is up to you to keep it.
-
-Full walkthrough: **[Quick start](https://github.com/jaeungkim/gantt-chart/blob/main/docs/en/quick-start.md)**.
-
-## What it does
-
-**Rendering** — virtualized rows, a configurable task list pane with a draggable splitter, six
-timeline scales from hour to year, elbow-routed dependency arrows, date markers, range bands,
-non-working-day shading and baseline bars.
-
-**Editing** — move, resize and set progress by dragging; draw a new task on empty row space; draw
-and delete dependency arrows; reorder, indent and outdent rows; undo and redo.
-
-**Scheduling** — successors reschedule on a drag under a policy you choose, a working-day calendar
-makes weekends and holidays stop counting, and the critical path comes with total and free slack.
-The same functions are exported as plain functions you can call on a server or in a worker.
-
-**Accessibility** — one ARIA treegrid with a roving tab stop; bars move, resize and step their
-progress from the keyboard.
-
-**Theming** — `--gantt-*` custom properties scoped to the chart container, a light / dark / system
-theme prop, per-task colors, and four render props for replacing elements outright.
-
-Each of these, and the honest list of what the library does **not** do, is in
-**[Introduction](https://github.com/jaeungkim/gantt-chart/blob/main/docs/en/introduction.md)**.
+That chart is editable. Every committed gesture ends in one `onTasksChange` call with the complete
+next array. The chart persists nothing, including the scale.
 
 ## Documentation
 
-| Page | |
-|---|---|
-| [Quick start](https://github.com/jaeungkim/gantt-chart/blob/main/docs/en/quick-start.md) | install to a working, editable chart |
-| [Task data](https://github.com/jaeungkim/gantt-chart/blob/main/docs/en/task-data.md) | the `Task` shape and how the `tasks` prop is compared |
-| [Editing tasks](https://github.com/jaeungkim/gantt-chart/blob/main/docs/en/editing.md) | gestures, permissions, touch |
-| [Dependencies](https://github.com/jaeungkim/gantt-chart/blob/main/docs/en/dependencies.md) | the four link types and lag |
-| [Scheduling](https://github.com/jaeungkim/gantt-chart/blob/main/docs/en/scheduling.md) | policies, working calendar, critical path, baselines |
-| [Keyboard and screen readers](https://github.com/jaeungkim/gantt-chart/blob/main/docs/en/accessibility.md) | the key map, the ARIA tree, and the gaps |
-| [Theming](https://github.com/jaeungkim/gantt-chart/blob/main/docs/en/theming.md) | the CSS custom properties |
-| [Props](https://github.com/jaeungkim/gantt-chart/blob/main/docs/en/ref/props.md) | every prop, in one table |
+[Quick start](https://gantt.jaeungkim.com/docs/quick-start) goes from install to a chart your app
+can edit. [GanttProps](https://gantt.jaeungkim.com/docs/ref/props) lists every prop, callback and
+default. The chart renders no toolbar, so your app renders the scale control and drives it
+through the `ref` in [Imperative API](https://gantt.jaeungkim.com/docs/imperative-api).
+
+The tree and calendar helpers are exported as plain functions that run without React or a DOM. See
+[Headless core](https://gantt.jaeungkim.com/docs/headless-core).
 
-All 35 pages: **[English](https://github.com/jaeungkim/gantt-chart/blob/main/docs/en/README.md)** · **[한국어](https://github.com/jaeungkim/gantt-chart/blob/main/docs/ko/README.md)**
+Release notes are on [GitHub Releases](https://github.com/jaeungkim/gantt-chart/releases).
 
 ## Contributing
 
 Setup, the checks CI runs, and the branch and PR conventions are in
 [CONTRIBUTING.md](CONTRIBUTING.md). Questions and ideas go in
-[Discussions](https://github.com/jaeungkim/gantt-chart/discussions); issues are for bugs and
+[Discussions](https://github.com/jaeungkim/gantt-chart/discussions). Issues are for bugs and
 concrete feature requests.
 
 ## License

package/dist/Gantt.d.ts

@@ -0,0 +1,5 @@
+import { GanttHandle } from './timeline/hooks/useGanttScrollApi';
+import { GanttProps } from './props';
+/** Gantt chart component. Creates a store per instance, so two charts on one page cannot share state. */
+declare const Gantt: import('react').ForwardRefExoticComponent<GanttProps & import('react').RefAttributes<GanttHandle>>;
+export default Gantt;

package/dist/bars/components/GanttBar.d.ts

@@ -0,0 +1,20 @@
+import { GanttDependencyChange } from '../../dependencies/hooks/useGanttLinkDrag';
+import { GanttBarOptions } from '../../shared/types';
+import { GanttInteractionConfig, TaskTransformed } from '../../shared/task';
+import { WorkingCalendar } from '../../core';
+interface GanttBarProps {
+    currentTask: TaskTransformed;
+    options: GanttBarOptions;
+    interaction?: GanttInteractionConfig;
+    /** Roving tabindex of the treegrid - exactly one cell carries 0, so Tab enters the grid once */
+    tabIndex: number;
+    /** `row:column` coordinate the chart's focus manager looks the cell up by */
+    cellCoord?: string;
+    /** Working-day calendar - drag results snap forward off non-working days */
+    calendar?: WorkingCalendar;
+    /** Scroll the timeline when the drag reaches a viewport edge; Gantt.tsx owns the default */
+    autoScrollOnDrag: boolean;
+    onDependencyCreate?: (change: GanttDependencyChange) => boolean | void;
+}
+export default function GanttBar({ currentTask, options, interaction, tabIndex, cellCoord, calendar, autoScrollOnDrag, onDependencyCreate, }: GanttBarProps): import("react").JSX.Element;
+export {};

package/dist/bars/components/GanttBarsLayer.d.ts

@@ -0,0 +1,24 @@
+import { VirtualItem } from '../../shared/virtual/window';
+import { GanttDependencyChange } from '../../dependencies/hooks/useGanttLinkDrag';
+import { GanttBarOptions } from '../../shared/types';
+import { WorkingCalendar } from '../../core';
+import { GanttInteractionConfig } from '../../shared/task';
+import { GanttFocus } from '../../interaction/utils/a11y';
+import { GanttRow } from '../../rows/utils/rows';
+interface GanttBarsLayerProps {
+    rows: GanttRow[];
+    virtualItems: VirtualItem[];
+    /** Cells before the bars on a row - the bar's column is this plus its lane */
+    gridColumnCount: number;
+    focus: GanttFocus;
+    /** Horizontal culling, shared with the header so the two cannot disagree */
+    isBarVisible: (barLeft: number, barWidth: number) => boolean;
+    options: GanttBarOptions;
+    interaction: GanttInteractionConfig;
+    /** Working-day calendar - drag results snap forward off non-working days */
+    calendar?: WorkingCalendar;
+    autoScrollOnDrag: boolean;
+    onDependencyCreate?: (change: GanttDependencyChange) => boolean | void;
+}
+export default function GanttBarsLayer({ rows, virtualItems, gridColumnCount, focus, isBarVisible, options, interaction, calendar, autoScrollOnDrag, onDependencyCreate, }: GanttBarsLayerProps): (import("react").JSX.Element | null)[];
+export {};

package/dist/bars/components/GanttDragGuides.d.ts

@@ -0,0 +1 @@
+export default function GanttDragGuides(): import("react").JSX.Element | null;

package/dist/bars/hooks/useGanttBarDrag.d.ts

@@ -0,0 +1,16 @@
+import { GanttDragMode } from '../../shared/types';
+import { GanttInteractionConfig, Task, TaskTransformed } from '../../shared/task';
+import { WorkingCalendar } from '../../core';
+export type DragMode = GanttDragMode;
+interface GanttBarDragOptions {
+    onTasksChange?: (updatedTasks: Task[]) => void;
+    /** Scroll the timeline when the drag reaches a viewport edge (default true) */
+    autoScroll?: boolean;
+}
+/** Gantt bar drag behavior; `autoScroll` (default true) scrolls the timeline at a viewport edge. */
+export declare function useGanttBarDrag(task: TaskTransformed, options?: GanttBarDragOptions, interaction?: GanttInteractionConfig, calendar?: WorkingCalendar): {
+    onPointerDown: import('react').PointerEventHandler<HTMLDivElement>;
+    dragMode: GanttDragMode | null;
+    consumeDragClick: () => boolean;
+};
+export {};

package/dist/bars/hooks/useGanttDrawCreate.d.ts

@@ -0,0 +1,25 @@
+import { Dayjs } from 'dayjs';
+import { GanttBottomRowCell, GanttScaleKey } from '../../shared/types';
+/** The task the user drew, handed to `onTaskCreate` - nothing is committed by the chart */
+export interface GanttTaskDraft {
+    /** UTC ISO string, snapped to the current scale */
+    startDate: string;
+    endDate: string;
+}
+export declare function defaultTaskDraft(now: Dayjs, timelineTicks: GanttBottomRowCell[], scaleKey: GanttScaleKey): GanttTaskDraft | null;
+interface DrawGhost {
+    leftPx: number;
+    widthPx: number;
+    topPx: number;
+}
+interface UseGanttDrawCreateParams {
+    enabled: boolean;
+    rowCount: number;
+    onTaskCreate?: (draft: GanttTaskDraft) => void;
+}
+export declare function drawSlotTopPx(offsetY: number, rowCount: number): number | null;
+export declare function useGanttDrawCreate({ enabled, rowCount, onTaskCreate, }: UseGanttDrawCreateParams): {
+    onDrawPointerDown: (e: React.PointerEvent<HTMLDivElement>) => void;
+    ghost: DrawGhost | null;
+};
+export {};

package/dist/{hooks → bars/hooks}/useGanttProgressDrag.d.ts

@@ -1,16 +1,11 @@
 import { default as React } from 'react';
-import { GanttBeforeChangeHandler } from '../types/gantt';
-import { Task, TaskTransformed } from '../types/task';
-export interface GanttProgressDragOptions {
+import { Task, TaskTransformed } from '../../shared/task';
+interface GanttProgressDragOptions {
     onTasksChange?: (updatedTasks: Task[]) => void;
-    onBeforeTaskChange?: GanttBeforeChangeHandler;
 }
-/**
- * Progress handle drag hook
- * Previews with a local value while dragging, commits to rawTasks on pointerup
- */
 export declare function useGanttProgressDrag(task: TaskTransformed, barRef: React.RefObject<HTMLDivElement | null>, options?: GanttProgressDragOptions): {
     onProgressPointerDown: React.PointerEventHandler<HTMLDivElement>;
     progress: number | null;
     isDraggingProgress: boolean;
 };
+export {};

package/dist/core/calendar.d.ts

@@ -1,14 +1,7 @@
 import { Dayjs } from 'dayjs';
-/**
- * The calendar every piece of date arithmetic in the core routes through.
- *
- * There is exactly one notion of "a day" in the engine: whatever this object says.
- * The default calendar counts every day, so the plain calendar-date behaviour is not a
- * separate code path - it is the same code with a calendar that never skips anything.
- * Turning the working-day calendar on swaps the object; nothing else changes.
- */
+/** The calendar every piece of date arithmetic in the core routes through. */
 export interface WorkingCalendar {
-    /** False for the default calendar (every day counts) - lets callers take the cheap path */
+    /** False for the default calendar (every day counts) */
     readonly skipsNonWorkingDays: boolean;
     isWorkingDay(date: Dayjs): boolean;
     /** Moves `days` days forward (or backward), skipping non-working days */
@@ -27,19 +20,8 @@ export interface WorkingCalendarOptions {
     workingWeekdays?: number[];
     /** Non-working dates as UTC `YYYY-MM-DD` strings */
     holidays?: string[];
-    /** Replaces the weekday + holiday check entirely */
-    isNonWorkingDay?: (date: Dayjs) => boolean;
 }
-/**
- * The default calendar: every day counts.
- * Date arithmetic through it is plain calendar arithmetic, so it is what keeps the
- * scheduling features behaviour-neutral until a host opts into working days.
- */
+/** The default calendar: every day counts, so arithmetic through it is plain calendar arithmetic. */
 export declare const CALENDAR_DAYS: WorkingCalendar;
-/**
- * A calendar that skips weekends and holidays.
- *
- * Takes the same configuration the chart already uses to shade non-working days
- * (`holidays` / `isNonWorkingDay`), so what is shaded and what is skipped cannot drift.
- */
+/** A calendar that skips weekends and holidays, configured like the chart's non-working-day shading. */
 export declare function createWorkingCalendar(options?: WorkingCalendarOptions): WorkingCalendar;

package/dist/core/dates.d.ts

@@ -1,32 +1,16 @@
 import { default as dayjs, Dayjs } from 'dayjs';
 /**
- * The chart's own dayjs - always parses and displays in UTC mode.
- *
- * The contract for task dates is "UTC ISO string" (README > Task Format), so
- * positioning and labels follow UTC too. Parsing in local mode would draw the same
- * data in different date cells depending on where the viewer is (#84), and local
- * calendar DST days (23/25 hours) would make cell widths wobble as well (#28).
- *
- * - A string carrying a zone ('...Z', '+09:00') displays that instant as a UTC time
- * - A string without a zone ('2025-06-01', '2025-06-01T09:00') is read as a UTC wall
- *   clock, so it displays exactly as written, whatever the viewer's time zone
+ * The chart's own dayjs - always parses and displays in UTC, so the same data lands in the
+ * same cells for every viewer and DST never changes a cell's width (#84, #28).
  */
 declare const ganttDayjs: typeof dayjs.utc;
 export default ganttDayjs;
-/**
- * Calendar quarter of the date, 1-4
- *
- * Written out instead of pulling in dayjs' quarterOfYear plugin - the quarter scale
- * needs exactly these two lines of it, and the plugin would grow the bundle for every
- * consumer, quarter scale in use or not.
- */
+/** Calendar quarter of the date, 1-4 - inlined so dayjs' quarterOfYear plugin stays out of the bundle */
 export declare function quarterOfYear(date: Dayjs): number;
 /** First moment of the calendar quarter the date falls in */
 export declare function startOfQuarter(date: Dayjs): Dayjs;
 /**
- * First moment of the week the date falls in
- *
- * `firstDayOfWeek` is 0 = Sunday .. 6 = Saturday. dayjs' own `startOf('week')` is fixed
- * to the locale dayjs was loaded with (Sunday), so the week boundary is computed here.
+ * First moment of the week the date falls in; `firstDayOfWeek` is 0 = Sunday .. 6 = Saturday.
+ * Computed here because dayjs' `startOf('week')` is fixed to the loaded locale.
  */
 export declare function startOfWeek(date: Dayjs, firstDayOfWeek?: number): Dayjs;

package/dist/core/index.d.ts

@@ -1,16 +1,3 @@
-/**
- * The headless scheduling core.
- *
- * Everything under `src/core/` is plain data and pure functions - no React, no DOM, no
- * pixels - so it runs in Node, is unit-testable on its own, and could be published as a
- * separate entry point without dragging the renderer along. The boundary is enforced by an
- * eslint rule in `eslint.config.js`; keep anything that touches refs, elements or bar
- * geometry in `src/utils/` instead.
- */
-export { default as dayjs } from './dates';
-export type { DependencyType, Task, TaskDependency, TaskType, } from './types';
-export { isMilestoneTask, normalizeProgress } from './types';
 export { CALENDAR_DAYS, createWorkingCalendar, type WorkingCalendar, type WorkingCalendarOptions, } from './calendar';
-export { buildTaskGraph, canLink, findPath, linkDelta, linkKey, scheduleTasks, shiftTask, taskEnd, taskStart, type ScheduleOptions, type ScheduleResult, type SchedulingLink, type SchedulingPolicy, type TaskGraph, } from './scheduling';
-export { backwardPass, computeCriticalPath, forwardPass, type CriticalPathOptions, type CriticalPathResult, type EarlyDates, type LateDates, type TaskScheduleMetrics, } from './criticalPath';
 export { buildTaskTree, collectSubtreeIds, getVisibleTasks, rollUpTasks, type TaskTree, } from './tree';
+export { moveTask, sortTasksBySequence, validateMove, type GanttMoveOptions, } from './reorder';

package/dist/core/reorder.d.ts

@@ -0,0 +1,55 @@
+import { Task } from './types';
+/** Where a task is going: a parent, and a slot among that parent's children */
+export interface GanttTaskMove {
+    taskId: string;
+    /** New parent, null for the root level */
+    toParentId: string | null;
+    /** Slot among the new parent's children, counted in the list as it stands after the move */
+    toIndex: number;
+}
+/** The move that was applied - `toIndex` for an index-based API, `afterId`/`beforeId` for a position-based one */
+export interface GanttTaskMoveChange extends GanttTaskMove {
+    fromParentId: string | null;
+    fromIndex: number;
+    /** Sibling the task now follows - null when it is the first child */
+    afterId: string | null;
+    /** Sibling the task now precedes - null when it is the last child */
+    beforeId: string | null;
+}
+/** Where a drop lands relative to the row under the pointer */
+export type GanttDropMode = "before" | "after" | "child";
+/** Why a move was refused - null from `validateMove` means it is allowed */
+export type GanttMoveRejection = "unknown-task" | "unknown-parent" | "read-only" | "cycle" | "reparent-disabled" | "no-op";
+export interface GanttMoveOptions {
+    /** Whether the parentId hierarchy is on - off, depth comes from `sequence` and a reparent is refused */
+    hierarchy: boolean;
+    /** Whether this task may be moved at all - left out, every task may */
+    canReorder?: (task: Task) => boolean;
+}
+/** The sibling lists a move is measured against - `toIndex` is counted against exactly these */
+interface TaskOrder {
+    /** Normalized parent of each task - null for a root, an orphan or a cycle */
+    parentOf: ReadonlyMap<string, string | null>;
+    /** One parent's children in row order; pass null for the root list */
+    childrenOf: (parentId: string | null) => readonly string[];
+}
+/** Sort tasks by their sequence hierarchy - row order comes from this and nothing else */
+export declare function sortTasksBySequence<T extends Pick<Task, "sequence">>(tasks: T[]): T[];
+/** Reads the ordered forest the moves below are counted against */
+export declare function buildTaskOrder(tasks: Task[], hierarchy: boolean): TaskOrder;
+/**
+ * The move a drop on `targetId` would make: `before`/`after` make it a sibling, `child`
+ * appends it. Says nothing about whether the move is allowed - that is `validateMove`.
+ */
+export declare function moveForDrop(order: TaskOrder, taskId: string, targetId: string, mode: GanttDropMode): GanttTaskMove;
+/** Whether a move can be applied, and why not when it cannot - runs on every frame of a row drag */
+export declare function validateMove(tasks: Task[], move: GanttTaskMove, options: GanttMoveOptions): GanttMoveRejection | null;
+/**
+ * Applies a move, renumbering every sequence from the resulting row order; `parentId` is rewritten
+ * on the moved task only. Null when refused (`validateMove` says why); unchanged tasks keep identity.
+ */
+export declare function moveTask(tasks: Task[], move: GanttTaskMove, options: GanttMoveOptions): {
+    tasks: Task[];
+    change: GanttTaskMoveChange;
+} | null;
+export {};

package/dist/core/tree.d.ts

@@ -2,12 +2,8 @@ import { Task } from './types';
 /** The minimum a task needs for the tree math - TaskTransformed fits as-is */
 type TaskNode = Pick<Task, "id" | "parentId">;
 /**
- * A normalized tree built from parentId
- *
- * Orphans (a parent id that is not in the data), self-references and cyclic chains all get
- * their parent link cut and become roots. The parentOf/childIds that come out are therefore
- * always acyclic, so the functions below - and the render - can walk up or down without
- * risking an infinite loop.
+ * A normalized tree built from parentId. Orphans, self-references and cycles lose their
+ * parent link and become roots, so what comes out is always acyclic.
  */
 export interface TaskTree {
     /** parent id -> child ids (in input order) */
@@ -31,12 +27,8 @@ export declare function collectSubtreeIds(tasks: TaskNode[], rootId: string, tre
  */
 export declare function getVisibleTasks<T extends TaskNode>(tasks: T[], collapsedIds: Iterable<string>, tree?: TaskTree): T[];
 /**
- * The tasks with every parent recomputed as a summary row
- *
- * Start and end always come from the children, never from what the data says
- * (min(child start)..max(child end); a milestone child counts at its startDate alone).
- * Deepest first, so a grandchild's move travels up through the parent and the grandparent.
- * An explicit progress is left alone; only a missing one is rolled up from the children.
+ * The tasks with every parent recomputed as a summary row: start/end always from the children
+ * (deepest first, so a move travels all the way up); an explicit progress is left alone.
  */
 export declare function rollUpTasks(tasks: Task[], tree?: TaskTree): Task[];
 export {};

package/dist/core/types.d.ts

@@ -1,23 +1,8 @@
-/**
- * The task data model - the part of it the headless core owns.
- *
- * Everything here is plain data and pure functions: no React, no DOM, no pixels.
- * `src/types/task.ts` re-exports these and adds the render-side types (bar geometry,
- * arrow coordinates) on top.
- */
-export type TaskType = 'task' | 'milestone';
 export type DependencyType = 'FS' | 'SS' | 'FF' | 'SF';
 export interface TaskDependency {
     /** The predecessor's id - a task's `dependencies` list the tasks it waits on */
     targetId: string;
     type: DependencyType;
-    /**
-     * Signed delay between the two ends of the link, in days
-     *
-     * Positive is lag (wait this long after the predecessor), negative is lead (overlap).
-     * Counted in working days when the working-day calendar is on, calendar days otherwise.
-     */
-    lag?: number;
 }
 export interface Task {
     id: string;
@@ -26,26 +11,13 @@ export interface Task {
     endDate: string;
     parentId: string | null;
     sequence: string;
-    /** Task kind - 'milestone' renders as a diamond at startDate (default 'task') */
-    type?: TaskType;
     /** Progress 0-100 (%) - omitted means no progress display */
     progress?: number;
-    /**
-     * Bar color - any CSS color value
-     *
-     * The progress fill and the hover shade are derived from it, so one value colors the
-     * whole bar. Omitted, the `--gantt-*` theme tokens decide as before.
-     */
+    /** Bar color (any CSS color) - progress fill and hover shade derive from it; omitted, the `--gantt-*` tokens decide */
     color?: string;
     /** Extra class name put on this task's bar and its task-list row */
     className?: string;
-    /**
-     * Swimlane this task shares a row with
-     *
-     * Tasks with the same lane (inside the same group) are drawn side by side on one
-     * row; overlapping ones stack onto extra rows automatically. Omitted, the task
-     * gets a row of its own as before.
-     */
+    /** Lane this task shares a row with - lane-mates draw side by side, overlaps stack onto extra rows */
     lane?: string;
     dependencies?: TaskDependency[];
     /** Blocks every gesture on this task - overrides the chart's `readOnly` prop */
@@ -60,17 +32,12 @@ export interface Task {
     allowLinkCreate?: boolean;
     /** Allows/blocks deleting a dependency this task owns - overrides both `readOnly` settings */
     allowLinkDelete?: boolean;
+    /** Allows/blocks dragging this row to a new position or parent - opt-in, off unless this or the chart's `allowReorder` turns it on */
+    allowReorder?: boolean;
     /** Earliest date this task may be dragged to (ISO string) - overrides the chart's `minDate` */
     minDate?: string;
     /** Latest date this task may be dragged to (ISO string) - overrides the chart's `maxDate` */
     maxDate?: string;
-    /** The scheduling engine never moves this task; it still constrains its successors */
-    manuallyScheduled?: boolean;
-    /** Planned start snapshot - drawn as a thin bar under the live one (UTC ISO string) */
-    baselineStart?: string;
-    /** Planned end snapshot (UTC ISO string) */
-    baselineEnd?: string;
 }
-export declare function isMilestoneTask(task: Pick<Task, 'type'>): boolean;
 /** Normalizes progress into the 0-100 range; null when the value is missing or invalid */
 export declare function normalizeProgress(progress: number | undefined): number | null;

package/dist/{components → dependencies/components}/GanttDependencyArrows.d.ts

@@ -1,15 +1,13 @@
 import { GanttDependencyChange } from '../hooks/useGanttLinkDrag';
-import { GanttInteractionConfig, Task, TaskTransformed } from '../types/task';
+import { GanttVirtualization } from '../../timeline/hooks/useGanttVirtualization';
+import { GanttInteractionConfig, Task, TaskTransformed } from '../../shared/task';
 interface Props {
     transformedTasks: TaskTransformed[];
-    /** Row count of the chart - a lane row can carry several tasks, so it is not the task count */
     rowCount: number;
-    /** Link keys on the critical path (from computeCriticalPath) - undefined when it is off */
-    criticalLinkIds?: Set<string>;
+    virtual: GanttVirtualization;
     interaction?: GanttInteractionConfig;
     onTasksChange?: (updatedTasks: Task[]) => void;
-    /** Returning false keeps the dependency */
     onDependencyDelete?: (change: GanttDependencyChange) => boolean | void;
 }
-export default function GanttDependencyArrows({ transformedTasks, rowCount, criticalLinkIds, interaction, onTasksChange, onDependencyDelete, }: Props): import("react").JSX.Element;
+export default function GanttDependencyArrows({ transformedTasks, rowCount, virtual, interaction, onTasksChange, onDependencyDelete, }: Props): import("react").JSX.Element;
 export {};

package/dist/{hooks → dependencies/hooks}/useGanttLinkDrag.d.ts

@@ -1,5 +1,5 @@
-import { DependencyType, GanttInteractionConfig, Task, TaskTransformed } from '../types/task';
-import { LinkAnchor } from '../utils/dependency';
+import { DependencyType, GanttInteractionConfig, Task, TaskTransformed } from '../../shared/task';
+import { LinkAnchor } from '../utils/link';
 /** The link the user drew, handed to `onDependencyCreate` before anything is committed */
 export interface GanttDependencyChange {
     /** Task the drag started on */
@@ -12,19 +12,8 @@ interface UseGanttLinkDragParams {
     task: TaskTransformed;
     interaction?: GanttInteractionConfig;
     onTasksChange?: (updatedTasks: Task[]) => void;
-    /** Returning false rejects the link */
     onDependencyCreate?: (change: GanttDependencyChange) => boolean | void;
 }
-/**
- * Dragging a dependency from one of a bar's connector dots to another bar
- *
- * The gesture's direction is the dependency's direction: the bar the drag starts on is
- * the predecessor, the bar it lands on the successor. Which ends the two dots sit on
- * decides the type (see `linkTypeFromAnchors`).
- *
- * The drop target is found with `elementFromPoint` rather than from the bar geometry, so
- * virtualization, scrolling and the sticky task list pane all take care of themselves.
- */
 export declare function useGanttLinkDrag({ task, interaction, onTasksChange, onDependencyCreate, }: UseGanttLinkDragParams): {
     startLink: (anchor: LinkAnchor) => (e: React.PointerEvent<HTMLElement>) => void;
 };

package/dist/dependencies/utils/arrowPath.d.ts

@@ -0,0 +1,20 @@
+import { RenderedDependency, TaskTransformed } from '../../shared/task';
+import { LinkAnchor } from './link';
+interface DragOffset {
+    offsetX: number;
+    offsetWidth: number;
+}
+export declare function getSmartGanttPath(dependencyType: string, startX: number, startY: number, endX: number, endY: number): string;
+export declare function anchorPoint(task: TaskTransformed, anchor: LinkAnchor, offset?: DragOffset): {
+    x: number;
+    y: number;
+};
+export declare function buildTaskIndex(transformedTasks: TaskTransformed[]): Map<string, TaskTransformed>;
+export interface ArrowViewport {
+    topPx: number;
+    bottomPx: number;
+    isBarVisible: (left: number, width: number) => boolean;
+}
+export declare function isArrowVisible(dep: Pick<RenderedDependency, "fromX" | "fromY" | "toX" | "toY">, viewport: ArrowViewport): boolean;
+export declare function buildDependencies(taskById: Map<string, TaskTransformed>, liveOffsets: Record<string, DragOffset>): RenderedDependency[];
+export {};