@jaeungkim/gantt-chart 0.4.0 → 1.0.0

package/dist/components/GanttTaskGrid.d.ts

@@ -1,42 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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/criticalPath.d.ts

@@ -1,67 +0,0 @@
-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/scheduling.d.ts

@@ -1,104 +0,0 @@
-import { Dayjs } from 'dayjs';
-import { WorkingCalendar } from './calendar';
-import { DependencyType, Task } from './types';
-/**
- * How far a predecessor's move carries into its successors.
- *
- * - `off` - nothing propagates (the default; a chart behaves exactly as it did before)
- * - `shift-on-overlap` - a successor is pushed later only when a link would otherwise be
- *   broken, and is never pulled earlier
- * - `maintain-gap` - a successor sits exactly at its earliest legal date, so it follows the
- *   predecessor in both directions and the gap stays equal to the link's lag
- */
-export type SchedulingPolicy = 'off' | 'shift-on-overlap' | 'maintain-gap';
-/** One dependency, with both ends resolved */
-export interface SchedulingLink {
-    predecessorId: string;
-    successorId: string;
-    type: DependencyType;
-    /** Signed, in the calendar's day unit */
-    lag: number;
-}
-/** Stable identity for a link - used to tag the rendered arrow */
-export declare function linkKey(link: SchedulingLink): string;
-export interface TaskGraph {
-    byId: Map<string, Task>;
-    links: SchedulingLink[];
-    /** successor id -> the links that constrain it */
-    incoming: Map<string, SchedulingLink[]>;
-    /** predecessor id -> the links it constrains */
-    outgoing: Map<string, SchedulingLink[]>;
-    /** Topological order, predecessors first. Excludes anything caught in a cycle. */
-    order: string[];
-    /** Ids that could not be ordered because they sit on a cycle (null when there is none) */
-    cycle: string[] | null;
-}
-/**
- * Builds the dependency graph and topologically sorts it (Kahn).
- *
- * Links pointing at a task that is not in the data are dropped, and anything caught in a
- * cycle is left out of `order` and reported in `cycle` - so every caller walks a finite,
- * acyclic list no matter what the data says.
- */
-export declare function buildTaskGraph(tasks: Task[]): TaskGraph;
-/**
- * A dependency path from `fromId` to `toId`, or null when there is none.
- * Walks successors, so the result reads predecessor-first.
- */
-export declare function findPath(tasks: Task[], fromId: string, toId: string): string[] | null;
-/**
- * Whether a new predecessor -> successor link can be added without closing a loop.
- *
- * Call this before writing a link into the data: a cycle that never gets created is a
- * cycle the engine never has to work around. `cycle` is the offending chain, ready to
- * put in an error message.
- */
-export declare function canLink(tasks: Task[], predecessorId: string, successorId: string): {
-    ok: boolean;
-    cycle: string[] | null;
-};
-/** The instant a task starts (milestones are a single point at startDate) */
-export declare function taskStart(task: Task): Dayjs;
-/** The instant a task finishes (milestones are a single point at startDate) */
-export declare function taskEnd(task: Task): Dayjs;
-/** The predecessor end of a link: FS and FF hang off the finish, SS and SF off the start */
-export declare function linkSourceDate(link: SchedulingLink, predecessor: Task): Dayjs;
-/** The successor end of a link: FS and SS constrain the start, FF and SF the finish */
-export declare function linkTargetDate(link: SchedulingLink, successor: Task): Dayjs;
-/**
- * How many days the successor must move for this link to hold.
- *
- * Positive means it has to move later, negative means it is sitting later than it needs
- * to. Whole days in the calendar's unit, so applying it keeps every time of day intact.
- */
-export declare function linkDelta(link: SchedulingLink, predecessor: Task, successor: Task, calendar: WorkingCalendar): number;
-/** Moves a task by whole days - both ends together, so its duration is untouched */
-export declare function shiftTask(task: Task, days: number, calendar: WorkingCalendar): Task;
-export interface ScheduleOptions {
-    policy?: SchedulingPolicy;
-    calendar?: WorkingCalendar;
-    /**
-     * The tasks that just moved. Only their successors are rescheduled, and the seeds
-     * themselves are left exactly where the caller put them.
-     * Omitted, the whole project is levelled.
-     */
-    seeds?: Iterable<string>;
-    /** Pins summary rows - with hierarchy on their dates come from their children */
-    hierarchy?: boolean;
-    /** Called with the ids caught in a dependency cycle; those tasks are left alone */
-    onCycle?: (taskIds: string[]) => void;
-}
-export interface ScheduleResult {
-    /** The same array instance when nothing moved, so callers can skip the update */
-    tasks: Task[];
-    movedIds: string[];
-    cycle: string[] | null;
-}
-/**
- * Propagates a move through the dependency graph.
- *
- * One forward pass in topological order: each task is shifted by the largest delta its
- * predecessors demand, then becomes the input for its own successors. Cycles are reported
- * and skipped rather than followed, so this always terminates.
- */
-export declare function scheduleTasks(tasks: Task[], options?: ScheduleOptions): ScheduleResult;

package/dist/hooks/useGanttBarDrag.d.ts

@@ -1,35 +0,0 @@
-import { Dayjs } from 'dayjs';
-import { GanttBeforeChangeHandler, GanttDragMode, GanttScheduling } from '../types/gantt';
-import { GanttInteractionConfig, Task, TaskTransformed } from '../types/task';
-export type DragMode = GanttDragMode;
-export interface GanttBarDragOptions {
-    onTasksChange?: (updatedTasks: Task[]) => void;
-    onBeforeTaskChange?: GanttBeforeChangeHandler;
-    /** Scroll the timeline when the drag reaches a viewport edge (default true) */
-    autoScroll?: boolean;
-}
-/** The dates the drag is proposing for the tasks it moves directly */
-type DraggedDates = Map<string, {
-    start: Dayjs;
-    end: Dayjs;
-}>;
-/** The task array with the dragged tasks' proposed dates written in */
-export declare function applyDraggedDates(rawTasks: Task[], dragged: DraggedDates): Task[];
-/**
- * Runs the scheduling engine for the tasks the drag is moving.
- * The dragged tasks are the seeds, so only what they reach is rescheduled and the bar
- * under the pointer stays exactly where the pointer put it.
- */
-export declare function reschedule(rawTasks: Task[], dragged: DraggedDates, scheduling: GanttScheduling): import('core').ScheduleResult;
-/**
- * Hook providing the Gantt bar drag behavior
- *
- * `autoScroll` (default on) scrolls the timeline when the drag reaches a viewport edge,
- * faster the closer the pointer gets, and stops on drop or cancel.
- */
-export declare function useGanttBarDrag(task: TaskTransformed, options?: GanttBarDragOptions, interaction?: GanttInteractionConfig, scheduling?: GanttScheduling): {
-    onPointerDown: import('react').PointerEventHandler<HTMLDivElement>;
-    dragMode: GanttDragMode | null;
-    consumeDragClick: () => boolean;
-};
-export {};

package/dist/hooks/useGanttDrawCreate.d.ts

@@ -1,31 +0,0 @@
-/** 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;
-    /** Id of the task whose row the range was drawn on, null when the row has none */
-    rowTaskId: string | null;
-}
-/** The ghost bar drawn while the pointer is down (px, timeline content coordinates) */
-interface DrawGhost {
-    leftPx: number;
-    widthPx: number;
-    topPx: number;
-}
-interface UseGanttDrawCreateParams {
-    enabled: boolean;
-    /** Rows on screen, in order - the row under the pointer names the task it belongs to */
-    rowIds: (string | null)[];
-    onTaskCreate?: (draft: GanttTaskDraft) => void;
-}
-/**
- * Drawing a new task on the empty part of a row
- *
- * The chart never adds the task itself: the drawn range is snapped to the current scale
- * and handed to `onTaskCreate`, and the host decides what (if anything) to do with it.
- */
-export declare function useGanttDrawCreate({ enabled, rowIds, onTaskCreate, }: UseGanttDrawCreateParams): {
-    onDrawPointerDown: (e: React.PointerEvent<HTMLDivElement>) => void;
-    ghost: DrawGhost | null;
-};
-export {};

package/dist/hooks/useGanttExportApi.d.ts

@@ -1,30 +0,0 @@
-import { RefObject } from 'react';
-import { GanttBottomRowCell, GanttScaleKey } from '../types/gantt';
-import { GanttExportOptions } from '../utils/pngExport';
-/** Imperative export API */
-export interface GanttExportApi {
-    /**
-     * Renders the whole chart to a PNG and resolves with the blob
-     *
-     * No download is triggered - what to do with the blob is the caller's choice
-     * (save it, upload it, drop it into a PDF).
-     */
-    exportToPng: (options?: GanttExportOptions) => Promise<Blob>;
-}
-interface UseGanttExportApiParams {
-    scrollRef: RefObject<HTMLDivElement | null>;
-    bottomRowCells: GanttBottomRowCell[];
-    selectedScale: GanttScaleKey;
-    taskCount: number;
-    totalWidth: number;
-}
-/**
- * Imperative PNG export
- *
- * Rows, arrows and header cells are all virtualized, so the live DOM only ever
- * holds the visible slice. The export turns virtualization off, waits for the
- * full chart to render, captures it, and puts the chart back exactly as it was
- * - scroll position included - whether the capture succeeded or threw.
- */
-export declare function useGanttExportApi({ scrollRef, bottomRowCells, selectedScale, taskCount, totalWidth, }: UseGanttExportApiParams): GanttExportApi;
-export {};

package/dist/hooks/useGanttHistoryApi.d.ts

@@ -1,28 +0,0 @@
-import { default as React } from 'react';
-import { Task } from '../types/task';
-/** Imperative undo/redo API */
-export interface GanttHistoryApi {
-    /** Reverts the newest gesture and fires `onTasksChange`. No-op with an empty stack. */
-    undo: () => void;
-    /** Replays the newest undone gesture and fires `onTasksChange`. No-op with an empty stack. */
-    redo: () => void;
-    /** Whether there is a gesture to undo */
-    canUndo: boolean;
-    /** Whether there is an undone gesture to redo */
-    canRedo: boolean;
-}
-/**
- * Whether the key event landed in something the user is typing into, e.g. an input
- * rendered by a custom task list cell
- */
-export declare function isTextEntryTarget(target: unknown): boolean;
-/**
- * Undo/redo for the chart: the imperative methods plus the keyboard shortcuts.
- *
- * The key handler is meant for the chart container, so it only ever sees events
- * from inside the chart - the shortcut does nothing while the chart is not focused.
- */
-export declare function useGanttHistoryApi(onTasksChange?: (updatedTasks: Task[]) => void): {
-    historyApi: GanttHistoryApi;
-    onKeyDown: React.KeyboardEventHandler<HTMLElement>;
-};

package/dist/hooks/useGanttRowDrag.d.ts

@@ -1,33 +0,0 @@
-import { RefObject } from 'react';
-import { GanttReorderChange } from '../types/gantt';
-import { Task } from '../types/task';
-import { RowDropRow, RowDropTarget } from '../utils/rowDrag';
-export interface RowDragState {
-    draggedId: string;
-    /** Where the drop would land - null while the pointer is nowhere useful */
-    target: RowDropTarget | null;
-}
-interface UseGanttRowDragParams {
-    /** The rows on screen, in row order */
-    rows: RowDropRow[];
-    /** The element the rows are positioned in - pointer Y is measured from its top */
-    bodyRef: RefObject<HTMLDivElement | null>;
-    enabled: boolean;
-    onReorder?: (change: GanttReorderChange) => void | boolean;
-    onTasksChange?: (updatedTasks: Task[]) => void;
-}
-/**
- * Vertical drag of a grid row - reorders siblings and re-parents
- *
- * Deliberately separate from useGanttBarDrag: that one is horizontal and lives on the bars in
- * the timeline pane, this one is vertical and lives on the rows in the grid pane, so neither
- * gesture can start the other.
- *
- * Nothing is committed while the drop is illegal - the indicator says so during the drag and
- * the pointerup does nothing.
- */
-export declare function useGanttRowDrag({ rows, bodyRef, enabled, onReorder, onTasksChange, }: UseGanttRowDragParams): {
-    onRowPointerDown: import('react').PointerEventHandler<HTMLDivElement>;
-    dragState: RowDragState | null;
-};
-export {};

package/dist/hooks/useGanttSelectors.d.ts

@@ -1,23 +0,0 @@
-/**
- * Hook selecting the state and actions needed from the Gantt store
- * Uses shallow comparison to avoid unnecessary re-renders
- *
- * dragOffsets/currentTask change on every drag frame and are deliberately not
- * subscribed to here. (Components that need them subscribe individually - this keeps
- * the whole chart from re-rendering every frame)
- */
-export declare function useGanttSelectors(): {
-    rawTasks: import('..').Task[];
-    transformedTasks: import('..').TaskTransformed[];
-    bottomRowCells: import('../types/gantt').GanttBottomRowCell[];
-    selectedScale: import('..').GanttScaleKey;
-    selectedTaskId: string | null;
-    syncTasksFromProps: (rawTasks: import('..').Task[]) => void;
-    setHistoryLimit: (limit: number) => void;
-    setTransformedTasks: (tasks: import('..').TaskTransformed[]) => void;
-    setBottomRowCells: (cells: import('../types/gantt').GanttBottomRowCell[]) => void;
-    setSelectedScale: (scale: import('..').GanttScaleKey) => void;
-    setLocaleOptions: (options: import('../types/gantt').GanttLocaleOptions | undefined) => void;
-    clearAllDragOffsets: () => void;
-    getTotalWidth: () => number;
-};

package/dist/hooks/useGanttVirtualization.d.ts

@@ -1,32 +0,0 @@
-import { Virtualizer } from '@tanstack/react-virtual';
-import { RefObject } from 'react';
-import { GanttBottomRowCell } from '../types/gantt';
-interface UseGanttColumnVirtualizationParams {
-    bottomRowCells: GanttBottomRowCell[];
-    scrollRef: RefObject<HTMLDivElement | null>;
-}
-interface UseGanttColumnVirtualizationResult {
-    columnVirtualizer: Virtualizer<HTMLDivElement, Element>;
-    isBarVisible: (barLeft: number, barWidth: number) => boolean;
-}
-interface UseGanttVirtualizationParams extends UseGanttColumnVirtualizationParams {
-    /** Number of rows on screen - not the task count, since a lane can share one row */
-    rowCount: number;
-}
-interface UseGanttVirtualizationResult extends UseGanttColumnVirtualizationResult {
-    rowVirtualizer: Virtualizer<HTMLDivElement, Element>;
-}
-/**
- * Column virtualization
- *
- * Split out so that rendering the header's bottom time cells and judging horizontal
- * visibility use the same window - the header and the bars must not be culled by
- * different criteria.
- */
-export declare function useGanttColumnVirtualization({ bottomRowCells, scrollRef, }: UseGanttColumnVirtualizationParams): UseGanttColumnVirtualizationResult;
-/**
- * Hook managing the Gantt chart's virtualization
- * Sets up row and column virtualization and provides the visibility check
- */
-export declare function useGanttVirtualization({ rowCount, bottomRowCells, scrollRef, }: UseGanttVirtualizationParams): UseGanttVirtualizationResult;
-export {};

package/dist/hooks/useResolvedTheme.d.ts

@@ -1,15 +0,0 @@
-import { GanttTheme } from '../types/gantt';
-interface UseResolvedThemeResult {
-    containerClassName: string;
-    dataTheme: 'light' | 'dark' | undefined;
-}
-/**
- * Hook that resolves the theme and builds the matching class name and data attribute
- *
- * The 'system' theme is subscribed to with useSyncExternalStore - server rendering and
- * the first hydration render use null (no theme class) and switch to the real system
- * setting after hydration, so there is no hydration mismatch and no getting stuck on
- * the wrong theme.
- */
-export declare function useResolvedTheme(theme?: GanttTheme, baseClassName?: string): UseResolvedThemeResult;
-export {};