@jaeungkim/gantt-chart 0.3.1 → 1.0.0

package/dist/interaction/hooks/useGanttInteraction.d.ts

@@ -0,0 +1,2 @@
+import { GanttInteractionConfig } from '../../shared/task';
+export declare function useGanttInteraction({ readOnly, allowMove, allowResize, allowProgressChange, allowLinkCreate, allowLinkDelete, allowTaskCreate, allowReorder, minDate, maxDate, }: GanttInteractionConfig): GanttInteractionConfig;

package/dist/interaction/hooks/useGanttKeyboardNav.d.ts

@@ -0,0 +1,33 @@
+import { ScrollAlign } from '../../shared/virtual/useVirtualWindow';
+import { RefObject } from 'react';
+import { GanttScrollApi } from '../../timeline/hooks/useGanttScrollApi';
+import { GanttTaskMoveApi } from '../../task-list/hooks/useGanttTaskMove';
+import { GanttLocaleOptions, GanttScaleKey } from '../../shared/types';
+import { GanttInteractionConfig, Task } from '../../shared/task';
+import { GanttFocus } from '../utils/a11y';
+import { GanttRow } from '../../rows/utils/rows';
+interface UseGanttKeyboardNavParams {
+    rows: GanttRow[];
+    rawTasks: Task[];
+    gridColumnCount: number;
+    hierarchy: boolean;
+    collapsedIds: ReadonlySet<string>;
+    selectedScale: GanttScaleKey;
+    localeOptions: GanttLocaleOptions | undefined;
+    interaction: GanttInteractionConfig;
+    onActivate?: (taskId: string) => void;
+    onToggleCollapse: (rowId: string) => void;
+    onTasksChange?: (updatedTasks: Task[]) => void;
+    move: GanttTaskMoveApi;
+    scrollToRow: (index: number, align?: ScrollAlign) => void;
+    scrollApi: GanttScrollApi;
+    bodyRef: RefObject<HTMLDivElement | null>;
+}
+interface GanttKeyboardNav {
+    focus: GanttFocus;
+    announcement: string;
+    onKeyDown: (event: React.KeyboardEvent<HTMLDivElement>) => void;
+    onFocusCapture: (event: React.FocusEvent<HTMLDivElement>) => void;
+}
+export declare function useGanttKeyboardNav({ rows, rawTasks, gridColumnCount, hierarchy, collapsedIds, selectedScale, localeOptions, interaction, onActivate, onToggleCollapse, onTasksChange, move, scrollToRow, scrollApi, bodyRef, }: UseGanttKeyboardNavParams): GanttKeyboardNav;
+export {};

package/dist/interaction/hooks/useGanttSelection.d.ts

@@ -0,0 +1,12 @@
+import { TaskTransformed } from '../../shared/task';
+interface UseGanttSelectionParams {
+    selectable?: boolean;
+    onTaskSelect?: (task: TaskTransformed | null) => void;
+    onTaskClick?: (task: TaskTransformed, event: React.MouseEvent) => void;
+}
+interface GanttSelection {
+    select: (task: TaskTransformed | null) => void;
+    onTaskClick: (task: TaskTransformed, event: React.MouseEvent) => void;
+}
+export declare function useGanttSelection({ selectable, onTaskSelect, onTaskClick, }: UseGanttSelectionParams): GanttSelection;
+export {};

package/dist/interaction/utils/a11y.d.ts

@@ -0,0 +1,84 @@
+import { Dayjs } from 'dayjs';
+import { GanttDragMode, GanttScaleKey } from '../../shared/types';
+import { GanttInteractionConfig, Task, TaskTransformed } from '../../shared/task';
+import { GanttRow } from '../../rows/utils/rows';
+export interface GanttFocus {
+    row: number;
+    col: number;
+}
+export interface GanttKeyboardRow {
+    cells: number;
+    firstBarCell: number;
+    expandable: boolean;
+    expanded: boolean;
+}
+type GanttKeyAction = {
+    kind: "focus";
+    focus: GanttFocus;
+} | {
+    kind: "toggle";
+    row: number;
+    col: number;
+} | {
+    kind: "activate";
+    row: number;
+    col: number;
+} | {
+    kind: "delete";
+    row: number;
+    col: number;
+} | {
+    kind: "nudge";
+    row: number;
+    col: number;
+    mode: GanttDragMode;
+    steps: number;
+} | {
+    kind: "progress";
+    row: number;
+    col: number;
+    delta: number;
+} | {
+    kind: "reorder";
+    row: number;
+    col: number;
+    delta: -1 | 1;
+} | {
+    kind: "reparent";
+    row: number;
+    col: number;
+    direction: -1 | 1;
+} | {
+    kind: "zoom";
+    direction: number;
+};
+interface GanttKeyEvent {
+    key: string;
+    altKey?: boolean;
+    shiftKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+}
+export declare function resolveKeyboardAction(event: GanttKeyEvent, focus: GanttFocus, rows: GanttKeyboardRow[]): GanttKeyAction | null;
+export declare function taskAtFocus(row: GanttRow | undefined, col: number, firstBarCell: number): TaskTransformed | undefined;
+export declare function formatTaskAriaLabel(task: Pick<TaskTransformed, "name" | "startDate" | "endDate" | "isSummary">, format: (date: Dayjs) => string, progress?: number | null): string;
+export declare function formatMovedAnnouncement(name: string, position: number, total: number, parentName: string | null): string;
+interface GanttRowAria {
+    role: "row";
+    "aria-level": number;
+    "aria-posinset": number;
+    "aria-setsize": number;
+    "aria-rowindex": number;
+    "aria-expanded"?: boolean;
+    "aria-owns"?: string;
+}
+export declare function rowAriaProps(row: GanttRow, rowIndex: number, options: {
+    headerOffset: number;
+    expandable: boolean;
+    expanded: boolean;
+    ownedIds?: string[];
+}): GanttRowAria;
+export declare function nudgeTaskDates(rawTasks: Task[], target: TaskTransformed, mode: GanttDragMode, steps: number, scaleKey: GanttScaleKey, interaction?: GanttInteractionConfig): Task[] | null;
+export declare function stepTaskProgress(rawTasks: Task[], target: TaskTransformed, delta: number, interaction?: GanttInteractionConfig): Task[] | null;
+export declare function deleteTask(rawTasks: Task[], target: TaskTransformed, interaction?: GanttInteractionConfig): Task[] | null;
+export {};

package/dist/props.d.ts

@@ -0,0 +1,121 @@
+import { GanttTaskMoveChange } from './core/reorder';
+import { GanttTaskDraft } from './bars/hooks/useGanttDrawCreate';
+import { GanttDependencyChange } from './dependencies/hooks/useGanttLinkDrag';
+import { GanttDateRange, GanttDetailRenderer, GanttFormatOverrides, GanttScaleKey, GanttTheme, Holiday } from './shared/types';
+import { Task, TaskTransformed } from './shared/task';
+export interface GanttProps {
+    /** Task data array - applied only when the contents change (a new array with equal contents is ignored); `[]` clears the chart. */
+    tasks?: Task[];
+    /** Callback invoked when tasks change */
+    onTasksChange?: (updatedTasks: Task[]) => void;
+    /** Chart height (px or a CSS value) */
+    height?: number | string;
+    /** Chart width (px or a CSS value) */
+    width?: number | string;
+    /** Theme setting - 'light', 'dark', or 'system'. Omitted, the host page's `color-scheme` decides. */
+    theme?: GanttTheme;
+    /** Scale the chart starts at (default `"month"`) - a mount-time seed; use `setScale` on the ref to change it later. */
+    defaultScale?: GanttScaleKey;
+    /** Called whenever the scale changes, from any source (ref, Ctrl/Cmd + wheel, `zoomToFit()`, keyboard) - not on mount. */
+    onScaleChange?: (scale: GanttScaleKey) => void;
+    /** Additional CSS class name */
+    className?: string;
+    /** Whether to shade non-working days (default true) - also hides holiday names */
+    showNonWorkingDays?: boolean;
+    /** Which weekdays are worked, 0 = Sunday (default Mon-Fri). Pass a stable array. */
+    workingWeekdays?: number[];
+    /** Days off beyond the weekend. A bare `YYYY-MM-DD` string is one with no label. Pass a stable array. */
+    holidays?: (string | Holiday)[];
+    /** Scroll here once after the first render - `"today"` or a date string; later data updates leave the scroll alone. */
+    initialScrollTo?: "today" | string;
+    /** Blocks moving, resizing and progress dragging on every task */
+    readOnly?: boolean;
+    /** Allows/blocks moving bars (default true) - beats `readOnly` */
+    allowMove?: boolean;
+    /** Allows/blocks resizing bars (default true) - beats `readOnly` */
+    allowResize?: boolean;
+    /** Allows/blocks dragging the progress handle (default true) - beats `readOnly` */
+    allowProgressChange?: boolean;
+    /** Earliest date any bar may be dragged to (ISO string) - a task's own `minDate` wins */
+    minDate?: string;
+    /** Latest date any bar may be dragged to (ISO string) - a task's own `maxDate` wins */
+    maxDate?: string;
+    /** Pins the timeline to start here (ISO string) instead of fitting to the tasks */
+    visibleStart?: string;
+    /** Pins the timeline to end here (ISO string) instead of fitting to the tasks */
+    visibleEnd?: string;
+    /** BCP 47 locale tag for every date label, e.g. `"ko-KR"`, via `Intl.DateTimeFormat` - omitted or unusable falls back to the built-in English labels. */
+    locale?: string;
+    /** Per-scale label overrides (`tick`, `header`, `tooltip`) - they win over `locale`, and the `Dayjs` handed in is in UTC mode. */
+    formats?: GanttFormatOverrides;
+    /** First day of the week, 0 = Sunday .. 6 = Saturday - set it to group the week scale's top header by week instead of by month (off when omitted). */
+    firstDayOfWeek?: number;
+    /** Whether to show the task list pane on the left (default false) - names only, per-task detail belongs in `renderDetail`. */
+    showTaskList?: boolean;
+    /** Whether the task list prints each row's `sequence` as a leading number column (default false). */
+    showRowNumbers?: boolean;
+    /** Whether to use the parentId hierarchy (default false) - parents become summary rows (dates and progress rolled up, dragging moves the subtree); row order still comes from `sequence`. */
+    hierarchy?: boolean;
+    /** Ids of collapsed parents (controlled - given, this value is what the chart shows) */
+    collapsedIds?: string[];
+    /** Initial collapsed list (uncontrolled seed; later changes are ignored) */
+    defaultCollapsedIds?: string[];
+    /** Called whenever the collapsed state changes - in controlled and uncontrolled mode alike */
+    onCollapsedChange?: (collapsedIds: string[]) => void;
+    /** Allows/blocks drawing dependencies between bars (default true) - beats `readOnly` */
+    allowLinkCreate?: boolean;
+    /** Allows/blocks selecting and deleting dependency arrows (default true) - beats `readOnly` */
+    allowLinkDelete?: boolean;
+    /** Allows/blocks drawing a new task below the last row (default true) - beats `readOnly` */
+    allowTaskCreate?: boolean;
+    /**
+     * Whether task-list rows can be dragged to a new position or a new parent (default false) - a
+     * task's own `allowReorder` wins, and a move rewrites `sequence` (re-parenting also `parentId`).
+     */
+    allowReorder?: boolean;
+    /** Called with the link the user drew, before it is applied - return false to reject it; self-links, duplicates and cycles never reach it. */
+    onDependencyCreate?: (change: GanttDependencyChange) => boolean | void;
+    /** Called with the arrow the user asked to remove, before it is applied - return false to keep it */
+    onDependencyDelete?: (change: GanttDependencyChange) => boolean | void;
+    /** Called with the range drawn below the last row, snapped to the current scale - the chart adds nothing itself, the host passes a new `tasks` array back. */
+    onTaskCreate?: (draft: GanttTaskDraft) => void;
+    /**
+     * Called with the move the user made, before it is applied - return false to reject it (sync only,
+     * revert by passing the previous `tasks` back). Carries `toParentId`/`toIndex` and `afterId`/`beforeId`;
+     * moves the chart already refuses never reach it.
+     */
+    onTaskMove?: (change: GanttTaskMoveChange) => boolean | void;
+    /** Fires when a bar or a task-list row is clicked (not after a drag) */
+    onTaskClick?: (task: TaskTransformed, event: React.MouseEvent) => void;
+    /** Fires on a double click. The two clicks that make it up still fire `onTaskClick` */
+    onTaskDoubleClick?: (task: TaskTransformed, event: React.MouseEvent) => void;
+    /** Fires when the selection changes, null when the empty timeline is clicked - passing it turns selection on. */
+    onTaskSelect?: (task: TaskTransformed | null) => void;
+    /** Whether clicking selects a row - omitted, selection is on exactly when `onTaskSelect` is given. */
+    selectable?: boolean;
+    /** Panel body shown beside the chart for one task - passing it turns the panel on, and the timeline narrows rather than being covered. The props include `update` for committing edits. */
+    renderDetail?: GanttDetailRenderer;
+    /**
+     * Whether the detail panel is available (omitted, it exists exactly when `renderDetail` is given;
+     * `true` alone shows the built-in field list, editable in place where the task's interaction
+     * flags allow). A click on a bar or row opens it, `Enter` on a focused row too. Turning it on
+     * also turns row selection on unless `selectable` says otherwise.
+     */
+    showDetail?: boolean;
+    /** Id of the task whose detail is open, `null` for closed (controlled - given, this value is what the chart shows) */
+    detailTaskId?: string | null;
+    /** Called on every open and close - in controlled and uncontrolled mode alike */
+    onDetailChange?: (task: TaskTransformed | null) => void;
+    /** Hover and drag tooltips (default true) - `false` suppresses both */
+    showTooltip?: boolean;
+    /** Whether Ctrl/Cmd + wheel steps through the scale ladder (default false) - the date under the cursor stays put. */
+    zoomOnWheel?: boolean;
+    /** Whether scrolling or dragging past an end grows the rendered range (default false) - it extends by about a viewport at a time. */
+    infiniteScroll?: boolean;
+    /** Called whenever the rendered timeline range changes - the hook for lazy-loading tasks */
+    onRangeChange?: (range: GanttDateRange) => void;
+    /** Whether a bar drag reaching a viewport edge scrolls the timeline (default true) */
+    autoScrollOnDrag?: boolean;
+    /** Snap a drag result forward off non-working days (default false) - uses the same days that shade the timeline; bars still span them visually. */
+    workingCalendar?: boolean;
+}

package/dist/rows/components/GanttRowsLayer.d.ts

@@ -0,0 +1,13 @@
+import { VirtualItem } from '../../shared/virtual/window';
+import { GanttRow } from '../utils/rows';
+interface GanttRowsLayerProps {
+    rows: GanttRow[];
+    virtualItems: VirtualItem[];
+    /** With the task list pane on screen the stripes carry no ARIA; without it they are the rows */
+    ownedByTaskList: boolean;
+    hierarchy: boolean;
+    collapsedIds: ReadonlySet<string>;
+}
+/** The row stripes behind the bars */
+export default function GanttRowsLayer({ rows, virtualItems, ownedByTaskList, hierarchy, collapsedIds, }: GanttRowsLayerProps): import("react").JSX.Element;
+export {};

package/dist/rows/hooks/useGanttCollapse.d.ts

@@ -0,0 +1,18 @@
+interface UseGanttCollapseParams {
+    /** Controlled list - given, this is what the chart shows */
+    collapsedIds?: string[];
+    /** Uncontrolled seed; later changes are ignored */
+    defaultCollapsedIds?: string[];
+    onCollapsedChange?: (collapsedIds: string[]) => void;
+}
+interface GanttCollapseState {
+    /** Ids of every collapsed parent and group header */
+    collapsedIds: ReadonlySet<string>;
+    /** Collapses an expanded row and expands a collapsed one */
+    toggle: (rowId: string) => void;
+    /** Expands a row, doing nothing when it is already open */
+    expand: (rowId: string) => void;
+}
+/** Which rows are collapsed - `collapsedIds` hands the decision to the host, otherwise the chart keeps the list */
+export declare function useGanttCollapse({ collapsedIds, defaultCollapsedIds, onCollapsedChange, }: UseGanttCollapseParams): GanttCollapseState;
+export {};

package/dist/rows/hooks/useGanttRowModel.d.ts

@@ -0,0 +1,19 @@
+import { Task, TaskTransformed } from '../../shared/task';
+import { GanttRow } from '../utils/rows';
+interface UseGanttRowModelParams {
+    /** Raw data - the parentId tree is built from it */
+    rawTasks: Task[];
+    /** The positioned rows to lay out */
+    tasks: TaskTransformed[];
+    hierarchy: boolean;
+    collapsedIds: ReadonlySet<string>;
+}
+interface GanttRowModel {
+    /** What both panes render, in screen order */
+    rows: GanttRow[];
+    /** Every task on a row, flattened - what the dependency arrows are drawn between */
+    tasks: TaskTransformed[];
+}
+/** The rows both panes render: hierarchy, then collapsing, then lane packing */
+export declare function useGanttRowModel({ rawTasks, tasks, hierarchy, collapsedIds, }: UseGanttRowModelParams): GanttRowModel;
+export {};

package/dist/rows/utils/rows.d.ts

@@ -0,0 +1,21 @@
+import { TaskTransformed } from '../../shared/task';
+/** One rendered row: one task, or several sharing a `lane` */
+export interface GanttRow {
+    /** Stable key - the ids on the row, joined with "+" */
+    id: string;
+    tasks: TaskTransformed[];
+    /** Indentation level, 0-based */
+    depth: number;
+    /** `aria-level`, 1-based */
+    level: number;
+    /** `aria-posinset` among the rows that share a parent */
+    posinset: number;
+    /** `aria-setsize` for that same set */
+    setsize: number;
+}
+/** Whether the row carries an expander: hierarchy on, and the task has children */
+export declare function isRowExpandable(row: GanttRow, hierarchy: boolean): boolean;
+/** Packs lane-sharing tasks onto as few rows as possible (greedy interval partitioning by start) */
+export declare function packLanes(tasks: TaskTransformed[]): TaskTransformed[][];
+/** The row model the chart renders; every task's `order` is rewritten to its row number */
+export declare function buildGanttRows(tasks: TaskTransformed[]): GanttRow[];

package/dist/shared/constants.d.ts

@@ -0,0 +1,24 @@
+import { GanttScaleConfig, GanttScaleKey } from './types';
+export declare const NODE_HEIGHT = 38;
+export declare const BAR_HEIGHT = 28;
+export declare const SUMMARY_BAR_HEIGHT = 18;
+export declare const HEADER_HEIGHT = 73;
+export declare const MIN_GRID_WIDTH = 120;
+export declare const MAX_GRID_WIDTH = 800;
+export declare const TREE_INDENT = 16;
+export declare const DEFAULT_GRID_WIDTH = 220;
+export declare const TIMELINE_SHIFT_BUFFER = 5;
+export declare const MIN_LABEL_INSIDE_WIDTH = 56;
+export declare const EDGE_THRESHOLD = 8;
+export declare const PROGRESS_HANDLE_INSET: number;
+export declare const TOUCH_EDGE_THRESHOLD = 44;
+export declare const MIN_RESIZABLE_WIDTH: number;
+export declare const MIN_TOUCH_RESIZABLE_WIDTH: number;
+export declare const MIN_BAR_WIDTH: number;
+export declare const LINK_ANCHOR_ZONE = 24;
+export declare const LINK_DRAG_SLOP = 4;
+export declare const HOVER_CARD_DELAY_MS = 450;
+export declare const DATE_FORMATS: Record<GanttScaleKey, string>;
+export declare const RANGE_FORMATS: Record<GanttScaleKey, string>;
+export declare const MIN_HOLIDAY_LABEL_PX = 44;
+export declare const GANTT_SCALE_CONFIG: Record<GanttScaleKey, GanttScaleConfig>;

package/dist/shared/context.d.ts

@@ -0,0 +1,4 @@
+import { GanttState, GanttStoreApi } from './store';
+export declare const GanttStoreContext: import('react').Context<import('zustand').StoreApi<GanttState> | null>;
+export declare function useGanttStoreApi(): GanttStoreApi;
+export declare function useGanttStore<T>(selector: (state: GanttState) => T): T;

package/dist/shared/hooks/useLatestRef.d.ts

@@ -0,0 +1,2 @@
+import { RefObject } from 'react';
+export declare function useLatestRef<T>(value: T): RefObject<T>;

package/dist/shared/hooks/useResolvedTheme.d.ts

@@ -0,0 +1,8 @@
+import { GanttTheme } from '../types';
+/**
+ * Resolves the `theme` prop to the value written to `data-theme`.
+ *
+ * 'light' / 'dark' are taken as given, 'system' asks the OS, and no prop at all follows the
+ * host page's `color-scheme`.
+ */
+export declare function useResolvedTheme(theme?: GanttTheme): 'light' | 'dark';

package/dist/shared/store.d.ts

@@ -0,0 +1,81 @@
+import { GanttBottomRowCell, GanttDragMode, GanttDragOffset, GanttLocaleOptions, GanttScaleKey } from './types';
+import { Task, TaskTransformed } from './task';
+import { GanttDropMode, GanttMoveRejection, GanttTaskMove } from '../core/reorder';
+import { LinkAnchor, LinkRejection } from '../dependencies/utils/link';
+interface GanttLinkDraft {
+    /** Task the drag started on - it becomes the predecessor */
+    fromTaskId: string;
+    fromAnchor: LinkAnchor;
+    /** Current pointer position */
+    toX: number;
+    toY: number;
+    /** Task under the pointer, null over empty space */
+    hoverTaskId: string | null;
+    hoverAnchor: LinkAnchor | null;
+    /** Why the hovered task cannot be linked - null when the drop would be accepted */
+    rejection: LinkRejection | null;
+}
+export interface GanttReorderDraft {
+    /** Row being dragged */
+    taskId: string;
+    /** Row the indicator attaches to - an index into the rendered rows */
+    rowIndex: number;
+    /** Where the drop lands relative to that row */
+    mode: GanttDropMode;
+    /** Indent the indicator is drawn at, in tree levels */
+    depth: number;
+    /** The move this drop would commit - null when there is nothing valid under the pointer */
+    move: GanttTaskMove | null;
+    /** Why the drop is refused - null when it would be accepted */
+    rejection: GanttMoveRejection | null;
+}
+/** Identifies one dependency: the successor that owns it and the predecessor it points at */
+interface GanttDependencyRef {
+    sourceId: string;
+    targetId: string;
+}
+export interface GanttState {
+    rawTasks: Task[];
+    rowTasks: TaskTransformed[];
+    bottomRowCells: GanttBottomRowCell[];
+    selectedScale: GanttScaleKey;
+    currentTask: TaskTransformed | null;
+    /** Which gesture the running bar drag is - null when none. The readout dims the anchored end. */
+    dragMode: GanttDragMode | null;
+    dragOffsets: Record<string, GanttDragOffset>;
+    transformedTasks: TaskTransformed[];
+    /** Locale and label formats - undefined means the built-in English labels */
+    localeOptions: GanttLocaleOptions | undefined;
+    /** Dependency drag in progress - null when none is running */
+    linkDraft: GanttLinkDraft | null;
+    /** Row drag in progress - null when none is running */
+    reorderDraft: GanttReorderDraft | null;
+    /** Arrow the user clicked, so Delete knows what to remove */
+    selectedDependency: GanttDependencyRef | null;
+    /** The selected row, or null - drives the highlight on the bar and on its grid row */
+    selectedTaskId: string | null;
+    hoveredTaskId: string | null;
+    setSelectedScale: (scale: GanttScaleKey) => void;
+    setLocaleOptions: (options: GanttLocaleOptions | undefined) => void;
+    setCurrentTask: (task: TaskTransformed | null) => void;
+    setDragMode: (mode: GanttDragMode | null) => void;
+    setSelectedTaskId: (taskId: string | null) => void;
+    setHoveredTaskId: (taskId: string | null) => void;
+    setRawTasks: (rawTasks: Task[]) => void;
+    /** Applies the `tasks` prop - an echo of what the chart just wrote is ignored */
+    syncTasksFromProps: (rawTasks: Task[]) => void;
+    setBottomRowCells: (cells: GanttBottomRowCell[]) => void;
+    setTransformedTasks: (tasks: TaskTransformed[]) => void;
+    setRowTasks: (tasks: TaskTransformed[]) => void;
+    /** Update several tasks' offsets at once - dragging a summary bar moves its whole subtree */
+    setDragOffsets: (offsets: Record<string, GanttDragOffset>) => void;
+    clearDragOffsets: (ids: string[]) => void;
+    clearAllDragOffsets: () => void;
+    setLinkDraft: (draft: GanttLinkDraft | null) => void;
+    setReorderDraft: (draft: GanttReorderDraft | null) => void;
+    setSelectedDependency: (dependency: GanttDependencyRef | null) => void;
+    getTotalWidth: () => number;
+}
+export type GanttStoreApi = ReturnType<typeof createGanttStore>;
+export declare function createGanttStore(initialScale?: GanttScaleKey): import('zustand').StoreApi<GanttState>;
+export {};

package/dist/shared/task.d.ts

@@ -0,0 +1,55 @@
+import { Task, TaskDependency } from '../core/types';
+export { normalizeProgress } from '../core/types';
+export type { DependencyType, Task, TaskDependency, } from '../core/types';
+/** Chart-wide interaction settings - every gesture is allowed by default (task creation also needs `onTaskCreate`), and a task's own field of the same name wins. */
+export interface GanttInteractionConfig {
+    readOnly?: boolean;
+    allowMove?: boolean;
+    allowResize?: boolean;
+    allowProgressChange?: boolean;
+    allowLinkCreate?: boolean;
+    allowLinkDelete?: boolean;
+    allowTaskCreate?: boolean;
+    /** Turns row reordering on - opt-in (default false). */
+    allowReorder?: boolean;
+    minDate?: string;
+    maxDate?: string;
+}
+interface ResolvedTaskInteraction {
+    canMove: boolean;
+    canResize: boolean;
+    canChangeProgress: boolean;
+    canCreateLink: boolean;
+    canDeleteLink: boolean;
+    canReorder: boolean;
+    minDate?: string;
+    maxDate?: string;
+}
+export declare function resolveTaskInteraction(task: Pick<Task, 'readOnly' | 'allowMove' | 'allowResize' | 'allowProgressChange' | 'allowLinkCreate' | 'allowLinkDelete' | 'allowReorder' | 'minDate' | 'maxDate'> & {
+    isSummary?: boolean;
+}, config?: GanttInteractionConfig): ResolvedTaskInteraction;
+export declare function canCreateTasks(config?: GanttInteractionConfig): boolean;
+interface TaskColorVars {
+    '--gantt-bar-color'?: string;
+    '--gantt-bar-color-hover'?: string;
+    '--gantt-progress-color'?: string;
+    '--gantt-bar-text-color'?: string;
+}
+export declare function resolveTaskColors(color: string | undefined): TaskColorVars;
+export interface TaskTransformed extends Task {
+    barLeft: number;
+    barWidth: number;
+    depth: number;
+    order: number;
+    originalOrder: number;
+    /** Row with children - its dates roll up, so resize and progress editing are off and dragging moves the subtree. */
+    isSummary?: boolean;
+    dependencies?: TaskDependency[];
+}
+export interface RenderedDependency extends TaskDependency {
+    sourceId: string;
+    fromX: number;
+    fromY: number;
+    toX: number;
+    toY: number;
+}

package/dist/shared/types.d.ts

@@ -0,0 +1,115 @@
+import { Dayjs } from 'dayjs';
+import { MouseEvent as ReactMouseEvent, ReactNode } from 'react';
+import { Task, TaskTransformed } from './task';
+/** Chart theme - 'system' follows the OS setting; omit the prop to follow the host page's `color-scheme`. */
+export type GanttTheme = 'light' | 'dark' | 'system';
+export type GanttScaleKey = 'day' | 'week' | 'month' | 'quarter' | 'year';
+export type GanttLabelUnit = 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year';
+export type GanttDragMode = 'bar' | 'left' | 'right';
+export interface GanttDragBounds {
+    min?: Dayjs;
+    max?: Dayjs;
+}
+export interface GanttVisibleRange {
+    start?: Dayjs;
+    end?: Dayjs;
+}
+export interface GanttScaleConfig {
+    labelUnit: GanttLabelUnit;
+    tickUnit: 'minute' | 'hour' | 'day' | 'week' | 'month';
+    unitPerTick: number;
+    tickAlign?: GanttLabelUnit;
+    dragStepUnit: 'minute' | 'hour' | 'day' | 'week';
+    dragStepAmount: number;
+    basePxPerDragStep: number;
+    formatTickLabel?: (date: Dayjs) => string;
+    formatHeaderLabel?: (date: Dayjs) => string;
+}
+/** Replaces the generated labels of one scale - whatever is left out keeps the built-in (or locale) label. */
+export interface GanttScaleFormat {
+    /** Bottom header row - one label per tick */
+    tick?: (date: Dayjs) => string;
+    /** Top header row - one label per group */
+    header?: (date: Dayjs) => string;
+    /**
+     * Every date the chart writes as a single date: the bar's hover tooltip, its live drag readout
+     * and aria-label, the header's drag guide labels (through `edge` and `range`, which follow this
+     * slot), and the detail panel's Start and End where they are not editable - an editable date is
+     * a native `<input type="date">` and never reaches a formatter.
+     */
+    tooltip?: (date: Dayjs) => string;
+}
+/** Per-scale label overrides, e.g. `{ quarter: { header: (d) => ... } }` */
+export type GanttFormatOverrides = Partial<Record<GanttScaleKey, GanttScaleFormat>>;
+/** Everything that decides how a date turns into a label */
+export interface GanttLocaleOptions {
+    /** BCP 47 tag handed to `Intl.DateTimeFormat`, e.g. `'ko-KR'` (default: the built-in English labels) */
+    locale?: string;
+    /** Per-scale label overrides - win over both the locale and the built-in labels */
+    formats?: GanttFormatOverrides;
+    /** First day of the week, 0 = Sunday .. 6 = Saturday (only affects week grouping) */
+    firstDayOfWeek?: number;
+}
+export interface GanttFormatters {
+    tick: (date: Dayjs) => string;
+    header: (date: Dayjs) => string;
+    tooltip: (date: Dayjs) => string;
+    range: (start: Dayjs, end: Dayjs) => string;
+    /** One end of a dragged range, at the readout's precision - `range` merged both ends */
+    edge: (date: Dayjs) => string;
+}
+/** A day off beyond the weekend. A bare `YYYY-MM-DD` string is the same thing with no label. */
+export interface Holiday {
+    /** UTC `YYYY-MM-DD` */
+    date: string;
+    /** Inclusive last day - omit for a single day */
+    endDate?: string;
+    /** Written in the tick row over the holiday's band, when the band is wide enough to hold it */
+    label?: string;
+    /** Any CSS colour. Tinted onto the grid at the weekend shade's weight, never painted over it. */
+    color?: string;
+}
+export interface GanttBottomRowCell {
+    startDate: Dayjs;
+    widthPx: number;
+}
+export interface GanttTopHeaderGroup {
+    startDate: Dayjs;
+    widthPx: number;
+    label: string;
+}
+/** The rendered timeline range, as reported by `onRangeChange` */
+export interface GanttDateRange {
+    start: Dayjs;
+    end: Dayjs;
+}
+export interface GanttRangeExtension {
+    before: number;
+    after: number;
+}
+export interface GanttDragOffset {
+    offsetX: number;
+    offsetWidth: number;
+    offsetStartDate: Dayjs;
+    offsetEndDate: Dayjs;
+}
+export interface GanttBarOptions {
+    onTasksChange?: (updatedTasks: Task[]) => void;
+    onTaskClick?: (task: TaskTransformed, event: ReactMouseEvent) => void;
+    onTaskDoubleClick?: (task: TaskTransformed, event: ReactMouseEvent) => void;
+    showTooltip?: boolean;
+}
+/** Props handed to a `renderDetail` override */
+export interface GanttDetailRenderProps {
+    task: TaskTransformed;
+    /** Closes the panel - wire it to your own close control */
+    close: () => void;
+    scale: GanttScaleKey;
+    /**
+     * Patches the open task through the chart's normal commit path (the store, then
+     * `onTasksChange`), so a custom body can commit edits in uncontrolled mode. Applies NO
+     * permission checks - a custom body enforces its own rules.
+     */
+    update: (patch: Partial<Omit<Task, 'id'>>) => void;
+}
+export type GanttDetailRenderer = (props: GanttDetailRenderProps) => ReactNode;

package/dist/shared/utils/holidays.d.ts

@@ -0,0 +1,12 @@
+import { Holiday } from '../types';
+export interface HolidayIndex {
+    /** Every day a holiday covers, `YYYY-MM-DD` -> the holiday covering it */
+    byDate: Map<string, Holiday>;
+    /** The same days, flat - what `createWorkingCalendar` takes */
+    dates: string[];
+}
+/**
+ * Expands `holidays` into a per-day lookup. A bare string is a holiday with no label.
+ * The first entry covering a day wins, so a later duplicate cannot rewrite its label.
+ */
+export declare function indexHolidays(holidays: (string | Holiday)[] | undefined): HolidayIndex;

package/dist/shared/utils/i18n.d.ts

@@ -0,0 +1,5 @@
+import { GanttFormatters, GanttLabelUnit, GanttLocaleOptions, GanttScaleKey } from '../types';
+export declare function resolveLabelUnit(scale: GanttScaleKey, options?: GanttLocaleOptions): GanttLabelUnit;
+export declare function resolveFormatters(scale: GanttScaleKey, options?: GanttLocaleOptions): GanttFormatters;
+/** Span label shared by the hover tooltip and the detail panel - hours under a day, whole days from there */
+export declare function formatDuration(durationMs: number): string;