@jaeungkim/gantt-chart 0.3.0 → 0.4.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,62 +1,49 @@
 # @jaeungkim/gantt-chart
 
-<!-- ![React Gantt Chart](https://raw.githubusercontent.com/jaeungkim/gantt-chart/main/public/readmeImg.png) -->
+[![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)
 
-Lightweight, high-performance Gantt chart component for React applications. Designed for fast rendering with virtualization and clean, minimal aesthetics.
+A Gantt chart for React: virtualized rows, editable bars, dependency arrows, and a scheduling
+engine that runs without a DOM.
 
-## 🎯 Motivation
+**[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)**
 
-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.
+## Motivation
 
-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.
+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.
 
-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!
+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.
 
-## ✨ 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
-
-## 📺 [Demo](https://jaeungkim.com/gantt-chart)
-
-## 🚀 Getting Started
-
-### Installation
+## Install
 
 ```bash
-npm install @jaeungkim/gantt-chart
-# or
-yarn add @jaeungkim/gantt-chart
+pnpm add @jaeungkim/gantt-chart
 ```
 
-### Basic Usage
+`react` and `react-dom` (`^18` or `^19`) are peer dependencies.
+
+## Usage
 
 ```tsx
-import { ReactGanttChart } from '@jaeungkim/gantt-chart';
-import type { Task } from '@jaeungkim/gantt-chart';
+import { ReactGanttChart, type Task } from '@jaeungkim/gantt-chart';
+import '@jaeungkim/gantt-chart/style.css';
 
 const tasks: Task[] = [
   {
     id: '1',
-    name: 'Project Kickoff',
+    name: 'Project kickoff',
     startDate: '2024-06-01T09:00:00Z',
     endDate: '2024-06-03T17:00:00Z',
     parentId: null,
     sequence: '1',
-    dependencies: [],
   },
   {
     id: '2',
-    name: 'Requirements Gathering',
+    name: 'Requirements',
     startDate: '2024-06-04T09:00:00Z',
     endDate: '2024-06-10T17:00:00Z',
     parentId: null,
@@ -69,92 +56,64 @@ export default function App() {
   return (
     <ReactGanttChart
       tasks={tasks}
-      height="100vh"
-      width="100%"
+      height={600}
       theme="system"
       defaultScale="month"
-      onTasksChange={(updated) => console.log('Tasks updated:', updated)}
+      onTasksChange={(updated) => console.log(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[];
-}
+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.
 
-interface TaskDependency {
-  targetId: string;
-  type: DependencyType;
-}
+Full walkthrough: **[Quick start](https://github.com/jaeungkim/gantt-chart/blob/main/docs/en/quick-start.md)**.
 
-type DependencyType = 'FS' | 'SS' | 'FF' | 'SF';
-// FS = Finish-to-Start
-// SS = Start-to-Start
-// FF = Finish-to-Finish
-// SF = Start-to-Finish
-```
+## What it does
 
-## Timeline Scales
+**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.
 
-| 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 |
+**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.
 
-Switch scales using the dropdown at the top-right of the 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.
 
-## Theming
+**Accessibility** — one ARIA treegrid with a roving tab stop; bars move, resize and step their
+progress from the keyboard.
 
-The chart supports three theme modes:
+**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.
 
-- **`light`** - Light background with dark text
-- **`dark`** - Dark background with light text  
-- **`system`** - Follows system preference (uses `prefers-color-scheme`)
+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)**.
 
-```tsx
-<ReactGanttChart theme="dark" ... />
-```
+## Documentation
 
-## Roadmap
+| 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 |
 
-- [ ] 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
+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)**
 
-## 🤝 Contributing
+## Contributing
 
-Pull requests are welcome!  
-If you find bugs or have suggestions, feel free to open an issue or contribute directly.
+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
+## License
 
-MIT © [jaeungkim](https://github.com/jaeungkim)
+[MIT](LICENSE)

package/dist/components/GanttBar.d.ts

@@ -0,0 +1,23 @@
+import { GanttDependencyChange } from '../hooks/useGanttLinkDrag';
+import { GanttBarOptions, GanttScheduling } from '../types/gantt';
+import { GanttInteractionConfig, TaskTransformed } from '../types/task';
+interface GanttBarProps {
+    currentTask: TaskTransformed;
+    options?: GanttBarOptions;
+    interaction?: GanttInteractionConfig;
+    /**
+     * Roving tabindex of the treegrid (default -1)
+     *
+     * Exactly one cell in the chart carries 0, so Tab enters and leaves the whole
+     * grid once and the arrow keys move within it.
+     */
+    tabIndex?: number;
+    /** `row:column` coordinate the chart's focus manager looks the cell up by */
+    cellCoord?: string;
+    scheduling?: GanttScheduling;
+    /** Scroll the timeline when the drag reaches a viewport edge (default true) */
+    autoScrollOnDrag?: boolean;
+    onDependencyCreate?: (change: GanttDependencyChange) => boolean | void;
+}
+export default function GanttBar({ currentTask, options, interaction, tabIndex, cellCoord, scheduling, autoScrollOnDrag, onDependencyCreate, }: GanttBarProps): import("react").JSX.Element;
+export {};

package/dist/components/GanttChartHeader.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+import { GanttBottomRowCell, GanttHeaderCellRenderer, GanttScaleKey } from '../types/gantt';
+interface GanttChartHeaderProps {
+    bottomRowCells: GanttBottomRowCell[];
+    selectedScale: GanttScaleKey;
+    width: number;
+    /** Scroll container used to virtualize the bottom time cells (pinning the top group labels is done with CSS sticky) */
+    scrollRef: React.RefObject<HTMLDivElement | null>;
+    /** Replaces a header cell wholesale - both rows go through it */
+    renderHeaderCell?: GanttHeaderCellRenderer;
+}
+/**
+ * Gantt chart header component
+ * Renders the top group labels and the bottom time cells
+ */
+declare function GanttChartHeader({ bottomRowCells, selectedScale, width, scrollRef, renderHeaderCell, }: GanttChartHeaderProps): React.JSX.Element;
+export default GanttChartHeader;

package/dist/components/GanttDependencyArrows.d.ts

@@ -0,0 +1,15 @@
+import { GanttDependencyChange } from '../hooks/useGanttLinkDrag';
+import { GanttInteractionConfig, Task, TaskTransformed } from '../types/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>;
+    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 {};

package/dist/components/GanttDragGuides.d.ts

@@ -0,0 +1,9 @@
+interface GanttDragGuidesProps {
+    width: number;
+}
+/**
+ * Shows the start/end points during a drag as vertical guides running up through the header
+ * Each guide carries the current date label at its top, so the moment can be read straight off the header
+ */
+export default function GanttDragGuides({ width }: GanttDragGuidesProps): import("react").JSX.Element | null;
+export {};

package/dist/components/GanttGridSplitter.d.ts

@@ -0,0 +1,14 @@
+interface GanttGridSplitterProps {
+    width: number;
+    onWidthChange: (width: number) => void;
+}
+/**
+ * Drag handle between the task list and the timeline
+ *
+ * Rendered outside the scroll container rather than inside the grid pane: the
+ * pane sits inside the treegrid, whose only children may be rows, and a
+ * separator there would also be a second tab stop in a widget that is meant to
+ * have exactly one.
+ */
+export default function GanttGridSplitter({ width, onWidthChange, }: GanttGridSplitterProps): import("react").JSX.Element;
+export {};

package/dist/components/GanttMarkers.d.ts

@@ -0,0 +1,18 @@
+import { PositionedBand, PositionedMarker } from '../utils/timeline';
+/**
+ * Shaded date-range bands (sprints, phases)
+ *
+ * Drawn on the background layer, below the rows, arrows and bars.
+ */
+export declare function GanttRangeBands({ bands }: {
+    bands: PositionedBand[];
+}): import("react").JSX.Element | null;
+/**
+ * Vertical date markers (deadlines, releases, and the chart's own today line)
+ *
+ * `data-warning` is set when a task the marker watches ends past its date, so the warning
+ * look is a plain CSS attribute selector the host can restyle.
+ */
+export declare function GanttMarkers({ markers }: {
+    markers: PositionedMarker[];
+}): import("react").JSX.Element | null;

package/dist/components/GanttTaskGrid.d.ts

@@ -0,0 +1,42 @@
+import { VirtualItem } from '@tanstack/react-virtual';
+import { GanttColumn, GanttReorderChange } from '../types/gantt';
+import { GanttInteractionConfig, Task, TaskTransformed } from '../types/task';
+import { GanttFocus } from '../utils/a11y';
+import { GanttRow } from '../utils/grouping';
+interface GanttTaskGridProps {
+    /** The rows on screen (collapsed subtrees and groups are already filtered out) */
+    rows: GanttRow[];
+    columns: GanttColumn[];
+    /** The timeline's own virtualization result - leaves no room for the rows to drift apart */
+    virtualItems: VirtualItem[];
+    totalHeight: number;
+    width: number;
+    hierarchy: boolean;
+    collapsedIds: Set<string>;
+    onToggleCollapse: (rowId: string) => void;
+    /** Which cell currently holds the chart's single tab stop */
+    focus: GanttFocus;
+    /** Whether rows can be dragged to reorder and re-parent */
+    allowRowReorder: boolean;
+    /** The same guards the bars use - a row is draggable only where the task can move */
+    interaction: GanttInteractionConfig;
+    onReorder?: (change: GanttReorderChange) => void | boolean;
+    onTasksChange?: (updatedTasks: Task[]) => void;
+    /** The selected row, highlighted in step with its bar */
+    selectedTaskId?: string | null;
+    onRowClick?: (task: TaskTransformed, event: React.MouseEvent) => void;
+    onRowDoubleClick?: (task: TaskTransformed, event: React.MouseEvent) => void;
+}
+/**
+ * The task grid on the left
+ *
+ * A sticky column inside the timeline's own scroll container, so vertical scrolling is
+ * locked to the rows by construction.
+ * (Syncing two panes through scroll events drifts the moment virtualization kicks in)
+ *
+ * These rows are the treegrid's `row` elements: each one owns its bars in the
+ * timeline through `aria-owns`, which is what makes the two panes read as a
+ * single widget rather than two unrelated lists.
+ */
+export default function GanttTaskGrid({ rows, columns, virtualItems, totalHeight, width, hierarchy, collapsedIds, onToggleCollapse, focus, allowRowReorder, interaction, onReorder, onTasksChange, selectedTaskId, onRowClick, onRowDoubleClick, }: GanttTaskGridProps): import("react").JSX.Element;
+export {};

package/dist/components/ScaleSelector.d.ts

@@ -0,0 +1,11 @@
+import { GanttScaleKey } from '../types/gantt';
+interface ScaleSelectorProps {
+    selectedScale: GanttScaleKey;
+    onScaleChange: (scale: GanttScaleKey) => void;
+}
+/**
+ * Segmented control for choosing the Gantt chart scale
+ * Uses a pill-style button group instead of a dropdown
+ */
+export default function ScaleSelector({ selectedScale, onScaleChange, }: ScaleSelectorProps): import("react").JSX.Element;
+export {};

package/dist/constants/gantt.d.ts

@@ -0,0 +1,47 @@
+import { GanttColumn, GanttScaleConfig, GanttScaleKey } from '../types/gantt';
+export declare const NODE_HEIGHT = 38;
+/** Full timeline header height (44 top group + 28 bottom cell + 1 border) - the grid header matches it */
+export declare const HEADER_HEIGHT = 73;
+/** Default grid column width (px) */
+export declare const DEFAULT_COLUMN_WIDTH = 120;
+/** Grid pane width limits (px) */
+export declare const MIN_GRID_WIDTH = 120;
+export declare const MAX_GRID_WIDTH = 800;
+/** Indentation per tree level (px) */
+export declare const TREE_INDENT = 16;
+/**
+ * Default task grid columns
+ * Replaceable wholesale through the columns prop, so no header label is baked into the library.
+ */
+export declare const DEFAULT_COLUMNS: GanttColumn[];
+export declare const TIMELINE_SHIFT_BUFFER = 5;
+/** Bars render at least this wide, however narrow they are (px) - keeps short tasks grabbable */
+export declare const MIN_BAR_WIDTH = 14;
+/** Below this width the task name is shown outside the bar (px) */
+export declare const MIN_LABEL_INSIDE_WIDTH = 56;
+/** Size of the resize edge hit area (px) */
+export declare const EDGE_THRESHOLD = 8;
+/**
+ * Size of the resize edge hit area for touch and pen (px)
+ *
+ * The 44px accessibility guideline, applied to the axis the bar can grow along. A bar
+ * is half a row tall, so the target cannot also be 44px high without covering the row
+ * next to it - what keeps a mistimed tap harmless instead is the long press: a touch
+ * has to rest on the edge before anything is lifted.
+ */
+export declare const TOUCH_EDGE_THRESHOLD = 44;
+/** Below this bar width there is no edge resizing and the whole bar is the move handle (px) */
+export declare const MIN_RESIZABLE_WIDTH: number;
+/** Same rule for touch - below this a bar is move-only, so the edges cannot swallow it (px) */
+export declare const MIN_TOUCH_RESIZABLE_WIDTH: number;
+/** Side length of the milestone diamond (px, before the 45-degree rotation) */
+export declare const MILESTONE_SIZE = 16;
+/** Horizontal distance from the diamond's center to its vertex (px) */
+export declare const MILESTONE_HALF_DIAGONAL: number;
+/**
+ * Date display format per scale (shared by the tooltip and the drag guides) - year included, 24-hour clock
+ * The chart is drawn in UTC, so the zone is spelled out only on the day scale, where the time is visible
+ */
+export declare const DATE_FORMATS: Record<GanttScaleKey, string>;
+/** Declaration order is the order the scale selector lists the scales in - finest first */
+export declare const GANTT_SCALE_CONFIG: Record<GanttScaleKey, GanttScaleConfig>;

package/dist/core/calendar.d.ts

@@ -0,0 +1,45 @@
+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.
+ */
+export interface WorkingCalendar {
+    /** False for the default calendar (every day counts) - lets callers take the cheap path */
+    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[];
+    /** 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.
+ */
+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.
+ */
+export declare function createWorkingCalendar(options?: WorkingCalendarOptions): WorkingCalendar;

package/dist/core/criticalPath.d.ts

@@ -0,0 +1,67 @@
+import { Dayjs } from 'dayjs';
+import { WorkingCalendar } from './calendar';
+import { TaskGraph } from './scheduling';
+import { Task } from './types';
+/**
+ * Critical path method over the dependency graph.
+ *
+ * Every task carries real dates, so its own start acts as a "no earlier than" constraint:
+ * the forward pass moves a task later when a predecessor demands it and never earlier, and
+ * the backward pass works out how much later each task could still finish without pushing
+ * the project's end out. Zero difference between the two is zero slack - the critical path.
+ *
+ * Everything is measured as a whole-day shift of the task's own dates, so times of day
+ * survive untouched and the numbers are working days whenever the calendar says so.
+ */
+export interface EarlyDates {
+    start: Dayjs;
+    finish: Dayjs;
+    /** Days later than the task's own dates */
+    shift: number;
+}
+export interface LateDates {
+    start: Dayjs;
+    finish: Dayjs;
+    /** Days later than the task's own dates the task could still run */
+    shift: number;
+}
+export interface TaskScheduleMetrics {
+    earlyStart: string;
+    earlyFinish: string;
+    lateStart: string;
+    lateFinish: string;
+    /** Days a task can slip before the project's finish moves */
+    totalSlack: number;
+    /** Days a task can slip before any successor's early start moves */
+    freeSlack: number;
+    critical: boolean;
+    /** Calendar days, or working days when the working-day calendar is on */
+    duration: number;
+}
+export interface CriticalPathResult {
+    metrics: Map<string, TaskScheduleMetrics>;
+    criticalTaskIds: Set<string>;
+    /** Keys from `linkKey` for the links that lie along the critical path */
+    criticalLinkIds: Set<string>;
+    /** Ids caught in a dependency cycle - they get no metrics */
+    cycle: string[] | null;
+    /** The project's earliest finish (UTC ISO string), or null with no tasks */
+    projectFinish: string | null;
+}
+export interface CriticalPathOptions {
+    calendar?: WorkingCalendar;
+}
+/**
+ * Earliest each task can run given its predecessors, walked predecessors-first.
+ * A task with no predecessor stays on its own dates.
+ */
+export declare function forwardPass(tasks: Task[], calendar?: WorkingCalendar, graph?: TaskGraph): Map<string, EarlyDates>;
+/**
+ * Latest each task can run without moving the project's finish, walked successors-first.
+ *
+ * Takes the forward pass's output rather than recomputing it, so it can be exercised on
+ * its own with hand-written early dates.
+ */
+export declare function backwardPass(tasks: Task[], early: Map<string, EarlyDates>, calendar?: WorkingCalendar, graph?: TaskGraph, projectFinish?: Dayjs): Map<string, LateDates>;
+/** Forward pass, backward pass, and the slack numbers that fall out of the two */
+export declare function computeCriticalPath(tasks: Task[], options?: CriticalPathOptions): CriticalPathResult;

package/dist/core/dates.d.ts

@@ -0,0 +1,32 @@
+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
+ */
+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.
+ */
+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.
+ */
+export declare function startOfWeek(date: Dayjs, firstDayOfWeek?: number): Dayjs;

package/dist/core/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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';