@jaeungkim/gantt-chart 0.3.1 → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 jaeungkim
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,160 +1,258 @@
-# @jaeungkim/gantt-chart
-
-<!-- ![React Gantt Chart](https://raw.githubusercontent.com/jaeungkim/gantt-chart/main/public/readmeImg.png) -->
-
-Lightweight, high-performance Gantt chart component for React applications. Designed for fast rendering with virtualization and clean, minimal aesthetics.
-
-## 🎯 Motivation
-
-I originally wanted to use Microsoft Project's Gantt Chart for personal project management, but it required a subscription 😔. Thus, I decided to build my own Gantt chart, referencing various open-source projects and examples, including MS Project, DHTMLX, Frappe Gantt Chart, and etc.
-
-Since there aren't many open-source Gantt chart solutions available, I hope this project will be useful for others as well. I am very open to feedback, feature requests, and contributions to make this Gantt chart as robust and versatile as possible.
-
-Currently, this project is built specifically for React due to my development background, but in the future, I may explore making it available for other frameworks as well. Since this is my first open-source project, I look forward to learning and improving it with the community!
-
-## ✨ Features
-
-- 📆 Multiple timeline scales: Day, Week, Month, Year
-- 🔄 Drag-and-drop support:
-  - Move entire task bars
-  - Resize from left/right edges
-  - Snap to configured intervals
-- 🧲 Smart dependency arrows (FS, SS, FF, SF)
-- ⚡ Virtualized rendering for performance
-- 🌙 Light/Dark/System theme support
-- 📍 Today marker indicator
-- 💬 Drag tooltip showing date changes
-- 📦 Lightweight with minimal dependencies
+[![Banner](https://raw.githubusercontent.com/jaeungkim/gantt-chart/main/public/banner.png)](https://gantt.jaeungkim.com)
 
-## 📺 [Demo](https://jaeungkim.com/gantt-chart)
-
-## 🚀 Getting Started
+# @jaeungkim/gantt-chart
 
-### Installation
+[![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 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.
+
+### Imperative API
+
+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.
+
+### Headless core
+
+`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
-npm install @jaeungkim/gantt-chart
-# or
-yarn add @jaeungkim/gantt-chart
+pnpm add @jaeungkim/gantt-chart
+# npm install @jaeungkim/gantt-chart
+# yarn add @jaeungkim/gantt-chart
 ```
 
-### Basic Usage
+`react` and `react-dom` (`^18` or `^19`) are peer dependencies.
+
+## Quick example
 
 ```tsx
-import { ReactGanttChart } from '@jaeungkim/gantt-chart';
-import type { Task } from '@jaeungkim/gantt-chart';
+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',
-    dependencies: [],
+    progress: 100,
   },
   {
-    id: '2',
-    name: 'Requirements Gathering',
-    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="100vh"
-      width="100%"
-      theme="system"
+      onTasksChange={setTasks}
+      height={420}
+      showTaskList
       defaultScale="month"
-      onTasksChange={(updated) => console.log('Tasks updated:', updated)}
     />
   );
 }
 ```
 
-## Props
-
-| Prop | Type | Default | Description |
-|------|------|---------|-------------|
-| `tasks` | `Task[]` | `[]` | Array of task objects to render |
-| `onTasksChange` | `(tasks: Task[]) => void` | - | Callback when tasks are moved or resized |
-| `height` | `number \| string` | `600` | Chart height (px or CSS value) |
-| `width` | `number \| string` | `"100%"` | Chart width (px or CSS value) |
-| `theme` | `"light" \| "dark" \| "system"` | - | Theme mode |
-| `defaultScale` | `"day" \| "week" \| "month" \| "year"` | `"month"` | Initial timeline scale |
-| `className` | `string` | - | Additional CSS class for the container |
-
-## Task Format
-
-All dates must be in **UTC ISO string format**: `"2024-06-01T09:00:00Z"`
-
-```ts
-interface Task {
-  id: string;
-  name: string;
-  startDate: string;    // UTC ISO string
-  endDate: string;      // UTC ISO string
-  parentId: string | null;
-  sequence: string;
-  dependencies?: TaskDependency[];
-}
-
-interface TaskDependency {
-  targetId: string;
-  type: DependencyType;
-}
-
-type DependencyType = 'FS' | 'SS' | 'FF' | 'SF';
-// FS = Finish-to-Start
-// SS = Start-to-Start
-// FF = Finish-to-Finish
-// SF = Start-to-Finish
-```
-
-## Timeline Scales
+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.
 
-| Scale | Header Label | Tick Unit | Drag Step |
-|-------|-------------|-----------|-----------|
-| `day` | Day | Hour | 1 hour |
-| `week` | Week | Day | 6 hours |
-| `month` | Month | Day | 1 day |
-| `year` | Year | Month | 7 days |
+### Add a scale control
 
-Switch scales using the dropdown at the top-right of the chart.
+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.
 
-## Theming
+The whole recipe is in **[Imperative API](https://gantt.jaeungkim.com/docs/imperative-api)**.
 
-The chart supports three theme modes:
+### Use the core without a chart
 
-- **`light`** - Light background with dark text
-- **`dark`** - Dark background with light text  
-- **`system`** - Follows system preference (uses `prefers-color-scheme`)
+```ts
+import { createWorkingCalendar, rollUpTasks, type Task } from '@jaeungkim/gantt-chart';
 
-```tsx
-<ReactGanttChart theme="dark" ... />
+const calendar = createWorkingCalendar({ holidays: ['2026-09-21'] });
+const rolled = rollUpTasks(tasks); // summary rows recomputed from their children
 ```
 
-## Roadmap
-
-- [ ] Left sidebar for task names
-- [ ] Right sidebar for task details
-- [ ] Collapsible parent-child rows
-- [ ] Inline editing for task names
-- [ ] Export to PNG/SVG
-- [ ] Custom bar colors
-
-## 🤝 Contributing
-
-Pull requests are welcome!  
-If you find bugs or have suggestions, feel free to open an issue or contribute directly.
-
-## 📄 License
-
-MIT © [jaeungkim](https://github.com/jaeungkim)
+Full walkthroughs: **[Quick start](https://gantt.jaeungkim.com/docs/quick-start)** and
+**[Headless core](https://gantt.jaeungkim.com/docs/headless-core)**.
+
+## 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
+
+| Guide | What it covers |
+|---|---|
+| [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
+
+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
+concrete feature requests.
+
+## License
+
+[MIT](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/bars/hooks/useGanttProgressDrag.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { Task, TaskTransformed } from '../../shared/task';
+interface GanttProgressDragOptions {
+    onTasksChange?: (updatedTasks: Task[]) => void;
+}
+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

@@ -0,0 +1,27 @@
+import { Dayjs } from 'dayjs';
+/** The calendar every piece of date arithmetic in the core routes through. */
+export interface WorkingCalendar {
+    /** 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 */
+    addDays(date: Dayjs, days: number): Dayjs;
+    /** Days from `from` to `to`, counted the same way `addDays` moves. Signed. */
+    daysBetween(from: Dayjs, to: Dayjs): number;
+    /** Smallest d where `addDays(from, d) >= target` - how far a task must move to clear a date */
+    daysUntil(from: Dayjs, target: Dayjs): number;
+    /** Largest d where `addDays(from, d) <= target` - how far a task may slip before it breaks one */
+    daysUpTo(from: Dayjs, target: Dayjs): number;
+    /** The date itself when it is a working day, otherwise the next one (time of day kept) */
+    snapForward(date: Dayjs): Dayjs;
+}
+export interface WorkingCalendarOptions {
+    /** Working weekdays as UTC day numbers, 0 = Sunday (default Mon-Fri) */
+    workingWeekdays?: number[];
+    /** Non-working dates as UTC `YYYY-MM-DD` strings */
+    holidays?: string[];
+}
+/** 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, configured like the chart's non-working-day shading. */
+export declare function createWorkingCalendar(options?: WorkingCalendarOptions): WorkingCalendar;

package/dist/core/dates.d.ts

@@ -0,0 +1,16 @@
+import { default as dayjs, Dayjs } from 'dayjs';
+/**
+ * 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 - 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.
+ * 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

@@ -0,0 +1,3 @@
+export { CALENDAR_DAYS, createWorkingCalendar, type WorkingCalendar, type WorkingCalendarOptions, } from './calendar';
+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 {};