@jaeungkim/gantt-chart 0.4.0 → 1.0.0

package/README.md

@@ -1,111 +1,250 @@
+[![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.
+A Gantt chart for React that you can actually edit. Virtualized rows, four dependency types, a
+working-day calendar, keyboard and screen-reader support, and a date core that runs without a DOM.
+
+**[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)**
+
+The package is two layers. `ReactGanttChart` renders the chart, handles every gesture, and hands
+your app a new `tasks` array each time an edit commits. The tree and calendar math underneath it is
+exported as plain functions, so a server, a worker or a test can call them without rendering
+anything.
+
+## Features
+
+### Rendering
+
+- Rows and time cells are virtualized together. Bars outside the window are not mounted.
+- Five scales, `day` through `year`, each with its own tick unit, drag step and label format.
+- A task list pane on the left with an optional row-number column, behind a draggable splitter.
+- `hierarchy` derives depth and summary rows from `parentId`. A summary row's dates and progress
+  roll up from its children, and it collapses.
+- `lane` packs tasks that never overlap onto one row, side by side.
+- Dependency arrows routed as elbows for all four link types: `FS`, `SS`, `FF`, `SF`.
+- A today line, weekend and holiday shading, and a hover card per bar.
+- A docked detail panel that narrows the timeline instead of covering it. `renderDetail` replaces
+  its body; `detailTaskId` controls which task is open.
+
+### Editing
+
+- Drag a bar to move it, pull either edge to resize it, drag the handle to set progress. Touch and
+  pen get wider grab zones.
+- While a drag is live the dragged dates print in the date-axis cells they land in. Nothing floats
+  over the chart.
+- Draw a dependency from one bar's link handle to another; click an arrow and press Delete to
+  remove it. `onDependencyCreate` and `onDependencyDelete` can veto either.
+- Propose a new task from the **Add task** button under the task list, from `addTask()` on the ref,
+  or by drawing a range below the last row. The chart reports a draft through `onTaskCreate` and
+  never adds the row itself.
+- Drag a task-list row to a new position or a new parent with `allowReorder`. `onTaskMove` can
+  reject the move.
+- The detail panel edits too. Its built-in body changes the name, either date and the progress in
+  place, committing through the same `onTasksChange` and gated by the same per-task flags as the
+  bar gestures. A `renderDetail` body of your own commits through `update(patch)`.
+- Permissions per chart and per task: `readOnly`, `allowMove`, `allowResize`,
+  `allowProgressChange`, `allowLinkCreate`, `allowLinkDelete`, `allowTaskCreate`, `allowReorder`,
+  plus `minDate` and `maxDate` drag bounds.
+- Every committed gesture ends in one `onTasksChange` call with the complete next array.
+
+### Dates
+
+- `workingCalendar` moves a drop forward off a weekend or a holiday. `workingWeekdays` says which
+  weekdays are worked and `holidays` lists the days off beyond them; both feed the calendar and the
+  shading, so the two cannot drift apart.
+- A holiday can carry a `label` and a `color`. The name is written in the tick row over its band and
+  the colour tints it, so it reads apart from the weekend beside it.
+- `visibleStart` and `visibleEnd` pin the range; `infiniteScroll` grows it at either end and
+  `onRangeChange` reports every change.
+- Every date is UTC. A bare `YYYY-MM-DD` lands on the day it names in every viewer's time zone.
+
+### Keyboard and screen readers
+
+- The chart is one ARIA treegrid with a single roving tab stop. Arrow keys move between rows and
+  cells; Home and End jump.
+- Bars move, resize and step their progress from the keyboard. Rows reorder, indent and outdent.
+  Ctrl/Cmd + ArrowUp and ArrowDown step the scale, and edits are announced.
+- A bar's accessible name is built from the task name, its dates and its progress.
+- The gestures with no keyboard equivalent are written down in
+  [Keyboard and screen readers](https://gantt.jaeungkim.com/docs/accessibility), not hidden.
+
+### Locale and theme
+
+- `locale` renders every date label through `Intl.DateTimeFormat`. `formats` overrides the tick,
+  header and tooltip labels per scale, and `firstDayOfWeek` picks where a week starts. No locale
+  package needed.
+- `theme` takes `'light'`, `'dark'` or `'system'`. Omitted, the chart follows the host page's
+  `color-scheme`, which is what an app's own light/dark toggle already sets.
+- 26 `--gantt-*` custom properties scoped to `.gantt-container`, so they cannot collide with your
+  own tokens.
+- A per-task `color` derives the bar, its progress fill, its hover shade and a readable label color
+  from one value. A per-task `className` reaches the bar and its task-list row.
 
-**[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)**
+### Imperative API
 
-## Motivation
+A `ref` of type `GanttHandle` exposes `scrollToDate`, `scrollToToday`, `scrollToTask`, `setScale`,
+`zoomToFit`, `openDetail`, `closeDetail`, `addTask` and `getScrollElement`. The chart renders no
+toolbar and no scale picker; you render the control and drive it through the ref.
 
-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.
+### Headless core
 
-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.
+`buildTaskTree`, `collectSubtreeIds`, `rollUpTasks`, `sortTasksBySequence`, `validateMove`,
+`moveTask`, `createWorkingCalendar` and `CALENDAR_DAYS` import no React and touch no DOM. They are
+the same functions the chart runs, so a report on the server and the bars in the browser agree.
+
+### Packaging
+
+- TypeScript types for every prop, callback and helper.
+- ESM and CJS builds, one stylesheet at `@jaeungkim/gantt-chart/style.css`.
+- React 18 and 19 as peer dependencies. Two runtime dependencies: `dayjs` and `zustand`.
+- Published from CI with npm provenance.
 
 ## 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.
 
-## 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.
+That chart is already editable. The chart keeps no canonical copy of your data: a committed gesture
+ends in one `onTasksChange` call with the complete next array, so your app stays the source of
+truth.
 
-Full walkthrough: **[Quick start](https://github.com/jaeungkim/gantt-chart/blob/main/docs/en/quick-start.md)**.
+### Add a scale control
 
-## What it does
+The chart ships no toolbar, so the scale picker is a control you own: render it, and call `setScale`
+on the ref. `onScaleChange` fires for every source, so your control stays in step when Ctrl/Cmd +
+wheel or Ctrl/Cmd + arrow moves the scale instead.
 
-**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.
+The whole recipe is in **[Imperative API](https://gantt.jaeungkim.com/docs/imperative-api)**.
 
-**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.
+### Use the core without a chart
 
-**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.
+```ts
+import { createWorkingCalendar, rollUpTasks, type Task } from '@jaeungkim/gantt-chart';
 
-**Accessibility** — one ARIA treegrid with a roving tab stop; bars move, resize and step their
-progress from the keyboard.
+const calendar = createWorkingCalendar({ holidays: ['2026-09-21'] });
+const rolled = rollUpTasks(tasks); // summary rows recomputed from their children
+```
 
-**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.
+Full walkthroughs: **[Quick start](https://gantt.jaeungkim.com/docs/quick-start)** and
+**[Headless core](https://gantt.jaeungkim.com/docs/headless-core)**.
 
-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)**.
+## What it leaves to you
+
+The chart renders the timeline and handles the gestures. Your app owns everything else:
+
+- Data fetching and persistence. Tasks arrive as a prop; nothing is stored, not even the scale.
+- Validation. Ids, date order and parseable dates are not checked before render.
+- Automatic rescheduling. Moving a predecessor never moves its successors.
+- Chrome. No toolbar, scale picker, zoom buttons or collapse button.
+- Resources, costs, export and print.
+
+The full boundary list is in
+**[Introduction](https://gantt.jaeungkim.com/docs/introduction)**.
 
 ## Documentation
 
-| Page | |
+| Guide | What it covers |
 |---|---|
-| [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 |
-
-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)**
+| [Introduction](https://gantt.jaeungkim.com/docs/introduction) | What the library is, and what it deliberately leaves to you |
+| [Concepts and vocabulary](https://gantt.jaeungkim.com/docs/concepts) | Every term the rest of the docs use, defined once |
+| [Quick start](https://gantt.jaeungkim.com/docs/quick-start) | Install to a working, editable chart |
+| [Task data](https://gantt.jaeungkim.com/docs/task-data) | The `Task` shape, date handling, and how the `tasks` prop is compared |
+| [Task list and hierarchy](https://gantt.jaeungkim.com/docs/task-list) | The left pane and the `parentId` tree |
+| [Lanes](https://gantt.jaeungkim.com/docs/lanes) | The `lane` task field, which packs tasks that never overlap onto one row |
+| [The timeline](https://gantt.jaeungkim.com/docs/timeline) | Scales, range, zoom, the today line, and non-working days |
+| [Editing tasks](https://gantt.jaeungkim.com/docs/editing) | Move, resize, progress, permissions, drag bounds, and touch |
+| [Creating tasks](https://gantt.jaeungkim.com/docs/task-creation) | The three ways a new task is proposed, and `onTaskCreate` |
+| [Reordering rows](https://gantt.jaeungkim.com/docs/reordering) | Dragging a row to a new position or a new parent, and `onTaskMove` |
+| [Dependencies](https://gantt.jaeungkim.com/docs/dependencies) | The four link types, and drawing arrows |
+| [Working calendar](https://gantt.jaeungkim.com/docs/working-calendar) | Keeping a drop off weekends and holidays |
+| [Detail panel](https://gantt.jaeungkim.com/docs/detail-panel) | The docked side panel: what opens it, editing in place, `renderDetail`, and controlling it |
+| [Events](https://gantt.jaeungkim.com/docs/events) | Every callback a click, a drag and a keyboard edit fire |
+| [Styling](https://gantt.jaeungkim.com/docs/styling) | Per-task color and class names |
+| [Imperative API](https://gantt.jaeungkim.com/docs/imperative-api) | The `ref` handle: scrolling, zoom, the detail panel and task creation |
+| [Keyboard and screen readers](https://gantt.jaeungkim.com/docs/accessibility) | The key map, the ARIA tree, and the gaps |
+| [Locale and date formats](https://gantt.jaeungkim.com/docs/i18n) | `locale`, per-scale overrides, week start |
+| [Theming](https://gantt.jaeungkim.com/docs/theming) | The theme prop and the CSS custom properties |
+| [Headless core](https://gantt.jaeungkim.com/docs/headless-core) | Tree and calendar math without React or a DOM |
+
+| Reference | Symbols |
+|---|---|
+| [GanttProps](https://gantt.jaeungkim.com/docs/ref/props) | `GanttProps` |
+| [Task and task types](https://gantt.jaeungkim.com/docs/ref/task) | `Task`, `TaskDependency`, `DependencyType`, `TaskTransformed` |
+| [GanttInteractionConfig](https://gantt.jaeungkim.com/docs/ref/interaction-config) | `GanttInteractionConfig` |
+| [GanttRow](https://gantt.jaeungkim.com/docs/ref/rows) | `GanttRow` |
+| [Detail renderer](https://gantt.jaeungkim.com/docs/ref/renderers) | `GanttDetailRenderer`, `GanttDetailRenderProps` |
+| [GanttHandle](https://gantt.jaeungkim.com/docs/ref/handle) | `GanttHandle`, `GanttScrollApi`, `GanttDetailApi`, `GanttTaskCreateApi`, `GanttScrollOptions`, `GanttZoomAnchor` |
+| [Scale and theme types](https://gantt.jaeungkim.com/docs/ref/scales) | `GanttScaleKey`, `GanttScaleFormat`, `GanttFormatOverrides`, `GanttTheme`, `Holiday` |
+| [Tree helpers](https://gantt.jaeungkim.com/docs/ref/core-tree) | `buildTaskTree`, `collectSubtreeIds`, `rollUpTasks`, `moveTask`, `validateMove`, `sortTasksBySequence` |
+| [Working calendar helpers](https://gantt.jaeungkim.com/docs/ref/core-calendar) | `createWorkingCalendar`, `CALENDAR_DAYS`, `WorkingCalendar` |
+
+Full docs: **[English](https://gantt.jaeungkim.com/docs)** · **[한국어](https://gantt.jaeungkim.com/ko/docs)**
 
 ## Contributing
 

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 {};